VX/RT: Seamless OpenVMS API Compatibility on Linux

• Preserves existing development processes
• Minimizes code changes
• Ensures compatibility with modern infrastructure

• Full compatibility with OpenVMS BASIC runtime APIs
• Support for string conversion, editing, and execution control
• Integration with VX/RT for enhanced portability

• Full compatibility with OpenVMS CONV$ APIs
• Support for data format conversion and file transfer
• Option management and resource reclamation

Sector7 has an extensive library of these services running on Linux to perform the same functions as on OpenVMS.  our language conversion tools will adapt the arguments in the procedure API to work with this library.  For instance, VX/COBOL or VX/FORTRAN etc will transform the argument passed BY DESCRIPTOR to a method that will work on Linux.

When the code is compiled on Linux, the compiled objects are linked with the Sector7 library of system services and the program executes on Linux just as it does on OpenVMS, making full use of the various system services.

The critical point here is that there is no need to touch the original source code, the Sector7 tools do all the work.

VX/RT is a call-compatible library that enables OpenVMS applications to run without modifications on RedHat and SUSE Linux. It faithfully replicates over 900 OpenVMS system service calls, ensuring API behavior, argument structures, return codes, and error handling remain identical to the original VMS environment.

This eliminates the need for costly rewrites or extensive retraining when migrating from OpenVMS to Linux. To discuss your specific migration requirements, contact us.

Yes, VX/RT seamlessly accepts VMS-style file specifications, logical names, and search lists, translating them dynamically to Linux format.

VX/RT provides identical error code mapping by translating Linux errors to VMS error codes, such as converting ENOFILE to RMS$_FNF.

VX/RT provides a complete ODBC-accessible RMS environment supporting FAB, RAB, NAM, and XAB structures. This ensures data integrity and preserves record locking mechanisms from the original OpenVMS environment.

Organizations like SEB have successfully leveraged similar RMS compatibility approaches in their modernization projects.

VX/RT fully supports VMS-style event flags, inter-process communication (IPC), and shared memory operations.

VX/RT includes VX/DCL, a fully functional VMS/OpenVMS DCL shell for Linux, along with VX/CLI for command parsing. This replicates VMS logical name tables and symbol management, ensuring seamless cross-process communication and batch processing compatibility.

VX/RT enables migration of OpenVMS applications to Linux with minimal changes while retaining existing API calls, file structures, and application logic. It preserves RMS data integrity, replicates VMS batch processing and DCL commands, and integrates seamlessly with other Sector7 tools.

Companies like IKEA have successfully modernized their legacy systems using similar approaches. VX/RT ensures VMS applications remain operational in modern Linux environments, eliminating costly rewrites and extensive retraining.

Ready to start your migration journey? Contact us to discuss your specific requirements.

VX/CONV$ provides a call-compatible implementation of the OpenVMS file conversion API for x86 and ARM Linux platforms. It enables OpenVMS applications to convert file formats into Linux-compatible structures while preserving complete data integrity and format consistency during the migration process.

This solution allows organizations to migrate their OpenVMS applications that require file format transformations without major code modifications. For guidance on implementing VX/CONV$ in your migration project, contact our team.

VX/CONV$ supports all key OpenVMS CONV$ APIs including CONV$CONVERT for data format conversion, CONV$PASS_FILES for file passing, CONV$PASS_OPTIONS for conversion options, and CONV$RECLAIM for resource management.

Yes, VX/CONV$ provides full compatibility across both x86 and ARM Linux architectures, ensuring your OpenVMS file conversion applications can run on any modern Linux environment.

VX/CONV$ handles conversion through its four main API functions: converting data formats, passing files for processing, managing conversion options, and reclaiming system resources after completion.

VX/CONV$ seamlessly integrates with the VX/RT ecosystem to provide comprehensive OpenVMS file conversion capabilities on Linux. This integration ensures that applications requiring file format transformations work alongside other VX tools for complete OpenVMS compatibility.

Organizations like Telstra have successfully used integrated VX tool approaches for their complex system migrations involving multiple file formats and conversion requirements.

VX/CONV$ supports comprehensive data format conversion and file transfer operations, handling the various OpenVMS file structures and converting them to Linux-compatible formats while maintaining data integrity.

VX/CONV$ is specifically designed to ensure complete data integrity and consistency during file structure conversions. This addresses one of the most critical challenges in OpenVMS migration - maintaining data accuracy while adapting file formats for Linux environments.

VX/CONV$ enables direct porting of OpenVMS applications requiring file format conversions without major modifications, significantly reducing development costs and preserving productivity. It supports all key OpenVMS conversion operations while ensuring complete data integrity throughout the migration process.

The tool integrates seamlessly into the VX/RT ecosystem, providing organizations with a comprehensive solution for maintaining file conversion capabilities on Linux. Companies like BNY Mellon have leveraged similar VX tools for their critical system migrations involving complex file operations.

To explore how VX/CONV$ can streamline your OpenVMS file conversion migration, contact our migration specialists.

VX/EDT$ provides an OpenVMS EDT-compatible text editor for x86 and ARM Linux, supporting both interactive and programmatic use. This tool enables OpenVMS applications and users to maintain familiar editing workflows while working in a Linux environment.

By preserving OpenVMS editing workflows and providing full compatibility with OpenVMS EDT$ text manipulation functions, VX/EDT$ ensures seamless migration without major modifications. To discuss how this can benefit your migration project, contact us.

Yes, VX/EDT$ maintains familiar EDT command structures and key bindings, ensuring users can continue working with their established editing workflows.

VX/EDT$ runs on both x86 and ARM Linux platforms, providing flexibility for different hardware architectures.

VX/EDT$ seamlessly integrates with VX/RT to provide full OpenVMS text editing capabilities on Linux. This integration is part of the comprehensive VX/RT ecosystem that enables complete OpenVMS compatibility.

Companies like Telstra have successfully used integrated VX tools for complex system migrations while preserving critical functionality.

Yes, VX/EDT$ supports both interactive text editing and automated text processing, providing flexibility for developers and maintaining compatibility with existing OpenVMS applications.

VX/EDT$ includes character set translation capabilities through the EDT$XLATE function, enabling proper handling of different character encodings during text editing operations.

VX/EDT$ delivers significant migration benefits by preserving OpenVMS editing workflows and enabling direct porting of applications and user scripts. The tool provides full compatibility with OpenVMS EDT$ text manipulation functions, eliminating the need for major code modifications.

This approach minimizes development costs and preserves productivity during migration projects. Organizations can maintain their existing text processing workflows while gaining the benefits of modern Linux infrastructure.

Similar migration strategies have proven successful for companies like SEB in their system modernization projects. To explore how VX/EDT$ can streamline your migration, contact us.

VX/EXE$ provides a call-compatible implementation of OpenVMS process execution and image management APIs for x86 and ARM Linux. It enables seamless migration of OpenVMS applications that rely on EXE$ routines for process control, file handling, and execution workflows while maintaining compatibility with existing OpenVMS logic.

Organizations can migrate critical applications without major modifications, preserving productivity and minimizing development costs. Contact us to discuss your OpenVMS migration requirements.

VX/EXE$ supports comprehensive OpenVMS EXE$ APIs including process execution, file management, data retrieval, and system interactions such as EXE$CREATE, EXE$DELETE, EXE$QIO, EXE$READ, EXE$WRITE, and EXE$GETTIM.

Yes, VX/EXE$ maintains OpenVMS process control semantics to ensure consistent behavior on Linux, preserving the original application logic and execution workflows.

VX/EXE$ supports process connections, synchronization, resource management, queue operations, and time management functions including EXE$CONNECT, EXE$SYNCH, EXE$GETQUI, and EXE$ASCTIM.

VX/EXE$ provides comprehensive file management through APIs like EXE$OPEN, EXE$CLOSE, EXE$COPY, EXE$RENAME, EXE$TRUNCATE, and EXE$UPDATE. These functions enable applications to perform complete file lifecycle operations while maintaining OpenVMS compatibility.

Organizations like Telstra have successfully migrated complex file management systems using similar OpenVMS compatibility tools.

VX/EXE$ seamlessly integrates with VX/RT to provide full OpenVMS execution and image management capabilities on x86 and ARM Linux platforms.

VX/EXE$ preserves OpenVMS execution logic, provides full compatibility with process and file management functions, supports critical execution workflows, and enables direct porting without major application modifications.

Organizations implementing VX/EXE$ achieve seamless OpenVMS application migration with preserved functionality and reduced development costs. The tool ensures applications requiring EXE$ services migrate without major modifications while maintaining productivity.

Companies like Allianz have successfully modernized their OpenVMS systems using comprehensive migration approaches. VX/EXE$ eliminates vendor lock-in and enables organizations to leverage modern Linux infrastructure while preserving critical business logic.

To explore how VX/EXE$ can support your migration project, contact us for a consultation.

VX/FDL$ provides a call-compatible implementation of OpenVMS File Definition Language (FDL$) APIs for x86 and ARM Linux. It enables seamless migration of OpenVMS applications that rely on FDL$ routines for file structure definition, parsing, and management while maintaining compatibility with existing workflows. Contact us to discuss your OpenVMS to Linux migration requirements.

Yes, VX/FDL$ maintains OpenVMS file structure semantics to ensure consistent behavior on Linux platforms.

VX/FDL$ seamlessly integrates with VX/RT to provide full OpenVMS file definition capabilities on x86 and ARM Linux systems.

VX/FDL$ provides full compatibility with OpenVMS FDL$ file management functions, including file structure definition, parsing, and management. This enables direct porting of applications without major modifications, preserving productivity and minimizing development costs. Organizations like Allianz have successfully migrated similar OpenVMS systems to Linux.

VX/FDL$ preserves OpenVMS file structure logic, enabling direct porting of applications that rely on FDL$ routines.

VX/FDL$ supports both x86 and ARM Linux platforms, providing flexibility for different hardware architectures.

VX/FDL$ eliminates the need for extensive application rewrites by providing call-compatible OpenVMS FDL$ APIs on Linux. This preserves existing file definition workflows while enabling migration to modern, cost-effective Linux infrastructure.

The tool ensures that critical OpenVMS file definition workflows, including structure generation and parsing, continue to function seamlessly. Companies like BNY Mellon have leveraged similar OpenVMS compatibility tools for successful migrations. Contact our team to learn how VX/FDL$ can streamline your OpenVMS to Linux migration.

VX/FOR$ provides a call-compatible implementation of OpenVMS Fortran runtime APIs for x86 and ARM Linux. It ensures that OpenVMS Fortran applications can execute seamlessly while preserving language features, execution behavior, and system interactions.

This tool eliminates the need to rewrite complex Fortran runtime dependencies, allowing organizations to migrate legacy applications efficiently. For migration planning and implementation support, contact our team.

VX/FOR$ supports key APIs including FOR$CVT_D_TE for decimal to text conversion, FOR$CVT_G_TE for floating-point G format conversion, FOR$CVT_H_TE for hexadecimal to text conversion, and FOR$RAB for Record Access Block operations.

VX/FOR$ seamlessly integrates with VX/RT to provide full OpenVMS Fortran runtime capabilities on x86 and ARM Linux systems.

Yes, VX/FOR$ includes full support for Record Access Block (RAB) operations, which are essential for OpenVMS applications that perform complex file I/O and data management tasks. The tool preserves the original OpenVMS behavior for these operations on Linux.

Organizations like BNY Mellon have successfully migrated complex Fortran applications with similar record management requirements.

VX/FOR$ is designed to minimize code modifications by providing call-compatible implementations of OpenVMS FOR$ APIs, allowing direct porting of applications.

VX/FOR$ maintains full compatibility with OpenVMS FOR$ runtime functions and preserves OpenVMS Fortran execution logic. This ensures that migrated applications behave identically to their original OpenVMS counterparts, reducing testing requirements and migration risks.

VX/FOR$ delivers significant cost and time savings by preserving existing OpenVMS Fortran execution logic and enabling direct porting without major modifications. Organizations can maintain productivity while modernizing their infrastructure.

The tool supports key OpenVMS Fortran operations including data conversion and record access, ensuring comprehensive compatibility. Companies like Amprion GmbH have successfully leveraged similar runtime preservation strategies for complex Fortran applications.

VX/FOR$ minimizes development costs and accelerates migration timelines. To explore how VX/FOR$ can streamline your Fortran migration project, contact us for a consultation.

VX/FORMS$ provides a call-compatible implementation of OpenVMS DECforms APIs for x86 and ARM Linux. It ensures that OpenVMS applications using DECforms maintain their structured user interfaces and interaction logic while running in a Linux environment.

This allows organizations to preserve their existing form-based UI investments while modernizing their infrastructure. Contact us to learn how VX/FORMS$ can support your OpenVMS migration project.

VX/FORMS$ supports all essential OpenVMS FORMS$ APIs including FORMS$DISABLE, FORMS$ENABLE, FORMS$RECEIVE, FORMS$SEND, and FORMS$TRANSCEIVE for complete form message handling and interface control.

VX/FORMS$ preserves OpenVMS form processing logic without requiring major application modifications, enabling direct porting of DECforms-based applications to Linux.

VX/FORMS$ supports structured form-based user interactions, enabling seamless UI management with full compatibility for OpenVMS DECforms runtime and event handling.

VX/FORMS$ integrates seamlessly with the VX/RT ecosystem to provide comprehensive OpenVMS compatibility on x86 and ARM Linux. This integration ensures that form-based applications work alongside other migrated OpenVMS components.

Organizations like Telstra have successfully leveraged integrated VX tools for complex system migrations while preserving critical UI functionality.

VX/FORMS$ runs on both x86 and ARM Linux platforms, providing flexible deployment options for modernized OpenVMS applications.

VX/FORMS$ maintains the exact OpenVMS UI structures and user interaction logic that applications depend on. This includes supporting key form-based interactions such as message transmission and reception, ensuring that migrated applications behave identically to their OpenVMS counterparts.

The tool provides full compatibility with OpenVMS DECforms runtime, preserving the familiar user experience while running on modern Linux infrastructure.

VX/FORMS$ delivers significant migration benefits by preserving productivity and minimizing development costs. Organizations can migrate DECforms-based applications without major modifications while maintaining all existing UI functionality.

The tool eliminates the need to rebuild user interfaces from scratch, reducing project risk and timeline. Companies like SEB have successfully modernized their systems while preserving critical user interaction components.

To discuss how VX/FORMS$ can accelerate your migration project, contact our migration specialists.

VX/LBR provides a call-compatible implementation of the OpenVMS Librarian (LBR$) API for Linux. It enables seamless migration of OpenVMS library management routines, preserving existing functionality and workflows without requiring major code modifications. This allows organizations to modernize their infrastructure while maintaining their valuable software investments. Contact us to discuss your OpenVMS migration requirements.

VX/LBR supports all essential LBR$ functions including LBR$OPEN, LBR$CLOSE, LBR$GET_RECORD, LBR$PUT_RECORD, LBR$FIND, LBR$DELETE_DATA, and key management operations like LBR$INSERT_KEY and LBR$LOOKUP_KEY.

VX/LBR seamlessly integrates into the VX/RT ecosystem, providing enhanced portability on Linux and complete OpenVMS compatibility when used alongside other VX/RT components.

VX/LBR supports both record-based and key-based library operations, including record storage, retrieval, indexing, deletion, and comprehensive library management functions.

VX/LBR maintains full compatibility with OpenVMS Librarian functionality, allowing development teams to continue using familiar processes and procedures. The API provides identical behavior to OpenVMS LBR$ routines, ensuring that existing scripts, build processes, and library management workflows function unchanged on Linux. Companies like Telstra have successfully preserved their operational processes during similar migrations.

No, VX/LBR enables direct porting of OpenVMS applications without major modifications to existing code that uses LBR$ routines.

VX/LBR delivers significant value by preserving productivity and minimizing development costs during OpenVMS to Linux migrations. Organizations maintain their existing library management infrastructure while gaining the benefits of modern Linux platforms.

The solution provides full API compatibility, supports all library operations, and integrates seamlessly with other VX/RT components. Companies like SEB have leveraged similar migration strategies to modernize their infrastructure while preserving critical functionality. Contact us to learn how VX/LBR can streamline your migration project.

VX/LIB$ provides a call-compatible implementation of OpenVMS general-purpose utility APIs for x86 and ARM Linux. It enables seamless migration of OpenVMS applications by preserving essential string manipulation, mathematical operations, and system functions while maintaining compatibility with existing logic and execution behavior.

This comprehensive API library ensures that OpenVMS applications requiring LIB$ services can be migrated without major modifications, preserving productivity and minimizing development costs. To explore how VX/LIB$ can streamline your migration project, contact our migration experts.

VX/LIB$ supports over 150 OpenVMS LIB$ callable routines including string operations, mathematical calculations, time management, memory operations, and system utilities.

Yes, VX/LIB$ is fully compatible with OpenVMS LIB$ APIs and preserves OpenVMS system utility behaviors for direct application porting.

VX/LIB$ provides comprehensive virtual memory management through functions like LIB$GET_VM, LIB$FREE_VM, and zone-based operations including LIB$CREATE_VM_ZONE and LIB$DELETE_VM_ZONE.

VX/LIB$ seamlessly integrates into the VX/RT ecosystem to provide full OpenVMS utility functionality on x86 and ARM Linux platforms.

VX/LIB$ delivers significant migration benefits by preserving OpenVMS system utility behaviors and enabling direct application porting without major code modifications. This approach dramatically reduces development time and costs while maintaining operational compatibility.

The library supports essential OpenVMS operations including time management, checksum calculations, and memory management, ensuring applications function identically on Linux. Companies like BNY Mellon have successfully leveraged similar utility preservation strategies during their critical system migrations.

By providing full compatibility with OpenVMS LIB$ functions, VX/LIB$ enables organizations to modernize their infrastructure while protecting existing software investments. Contact us to learn how VX/LIB$ can accelerate your migration timeline.

VX/MTH$ provides a call-compatible implementation of OpenVMS mathematical functions for x86 and ARM Linux environments. It ensures precision and compatibility for OpenVMS applications performing mathematical computations, enabling seamless execution on Linux without requiring major code modifications.

This compatibility layer eliminates the need to rewrite mathematical logic during migration, preserving your existing computational workflows. For guidance on planning your OpenVMS modernization strategy, contact our migration specialists.

VX/MTH$ provides over 180 callable routines that mirror the complete OpenVMS MTH$ API set.

Yes, VX/MTH$ ensures numerical precision and maintains OpenVMS computation behavior exactly as it functioned on the original platform.

VX/MTH$ seamlessly integrates with VX/RT to provide full OpenVMS mathematical functionality on x86 and ARM Linux platforms. This integration ensures that applications using MTH$ routines alongside other OpenVMS services maintain complete compatibility during migration.

Organizations like SEB have successfully leveraged integrated migration approaches for their legacy system modernization.

VX/MTH$ includes basic arithmetic, trigonometric functions (sin, cos, tan), logarithmic operations, exponential functions, and specialized routines for integer operations and floating-point conversions.

Yes, VX/MTH$ allows seamless migration of OpenVMS applications that rely on MTH$ routines without requiring major code modifications. The API maintains full compatibility with original OpenVMS function calls and return values.

VX/MTH$ preserves OpenVMS mathematical computation logic, enabling direct porting of applications while maintaining numerical precision on Linux. This approach eliminates vendor lock-in and reduces infrastructure costs while preserving productivity.

The solution minimizes development costs by avoiding the need to rewrite mathematical components. Companies like Ford have achieved significant cost savings through similar modernization strategies.

To explore how VX/MTH$ can streamline your OpenVMS migration project, contact our technical team.

VX/OTS$ provides a call-compatible implementation of OpenVMS data conversion and structured data handling APIs for x86 and ARM Linux. It ensures seamless migration of OpenVMS applications that rely on OTS$ routines while maintaining compatibility with existing logic and execution behavior.

This tool is essential for organizations migrating applications that perform encoding transformations, structured data manipulation, and memory operations. Contact us to discuss how VX/OTS$ can simplify your OpenVMS migration.

VX/OTS$ supports all major OpenVMS OTS$ APIs including OTS$CNVOUT, OTS$CVT_L_TB, OTS$CVT_T_D, OTS$MOVE3, OTS$MOVE5, and OTS$POWDD among others.

Yes, VX/OTS$ ensures consistency in numerical representation, memory operations, and encoding across platforms when migrating from OpenVMS to Linux.

VX/OTS$ includes memory movement functions like OTS$MOVE3 and OTS$MOVE5 that preserve OpenVMS memory handling behavior on Linux platforms.

VX/OTS$ seamlessly integrates into the VX/RT ecosystem for comprehensive OpenVMS compatibility on x86 and ARM Linux. This integration provides full OpenVMS-style data processing capabilities alongside other VX tools.

Organizations like Allianz have successfully leveraged multiple VX tools for complex migrations involving data conversion and processing requirements.

VX/OTS$ supports OpenVMS encoding transformations including conversion between numeric formats, timezone handling, and structured data encoding operations.

VX/OTS$ includes mathematical functions like OTS$POWDD for double-precision power calculations and OTS$POWLULU for long integer power operations, maintaining OpenVMS computational accuracy.

VX/OTS$ preserves OpenVMS data transformation logic, enabling direct porting of applications without major modifications. This reduces development costs and maintains productivity during migration.

The tool provides full compatibility with OpenVMS OTS$ functions, ensuring seamless execution of structured data operations on Linux. Companies like BNY Mellon have leveraged similar migration strategies for critical financial applications.

By eliminating the need to rewrite data conversion logic, VX/OTS$ significantly accelerates migration timelines. Contact our team to learn how VX/OTS$ can streamline your OpenVMS modernization project.

VX/SOR$ provides a call-compatible implementation of OpenVMS sorting routines for x86 and ARM Linux. It enables seamless migration of OpenVMS applications that rely on SOR$ routines by maintaining compatibility with existing logic and execution behavior.

This tool is essential for organizations migrating from OpenVMS to Linux while preserving their investment in sorting and data processing applications. Contact us to discuss your OpenVMS migration requirements.

VX/SOR$ supports structured data sorting, merging, record-based processing, and file-based sorting operations.

VX/SOR$ supports all key OpenVMS SOR$ APIs including SOR$BEGIN_SORT, SOR$END_SORT, SOR$INIT_SORT, SOR$PASS_FILES, SOR$RELEASE_REC, SOR$RETURN_REC, SOR$SORT_MERGE, and SOR$STAT.

VX/SOR$ seamlessly integrates with the VX/RT ecosystem to provide comprehensive OpenVMS compatibility on x86 and ARM Linux platforms.

No, VX/SOR$ provides full compatibility with OpenVMS SOR$ functions, enabling applications to be migrated without major modifications to sorting logic.

VX/SOR$ is designed specifically for x86 and ARM Linux platforms, providing OpenVMS-compatible sorting functionality on modern Linux systems.

VX/SOR$ preserves existing OpenVMS sorting logic and ensures consistency in sorting operations across platforms. This minimizes development costs and preserves productivity during migration.

The tool enables organizations to modernize their infrastructure while maintaining critical data processing capabilities. Companies can eliminate vendor lock-in and move to standard Linux platforms without losing functionality.

Similar to Telstra's successful migration, organizations benefit from reduced maintenance costs and improved scalability. To explore how VX/SOR$ can support your migration project, contact our team.

VX/SQL$ is a call-compatible implementation of OpenVMS SQL-based data access routines designed for x86 and ARM Linux platforms. It enables OpenVMS applications to execute SQL queries, handle database interactions, and manage errors while maintaining full compatibility with existing execution behavior.

This solution allows organizations to migrate their OpenVMS database applications to Linux without requiring major code modifications, preserving productivity and minimizing development costs. Contact us to discuss your SQL migration requirements.

VX/SQL$ supports three core SQL$ callable routines: SQL$GET_ERROR_TEST for retrieving last SQL error messages, SQL$GET_ERROR_TEXT for detailed error text, and SQL$SIGNAL for signaling SQL exceptions or warnings.

Yes, VX/SQL$ preserves OpenVMS SQL query execution logic completely, ensuring that database interactions remain consistent when migrating to Linux.