Technical Capabilities
Having trouble finding what you need?
Get in touch with us, so we can answer your specific questions directly.
Get In Touch
technical
/
API
/
VX/RT APIs

VX/RT APIs

Overview

VX/RT is the call-compatible OpenVMS runtime that lets migrated OpenVMS applications run without modification on RedHat and SUSE Linux. It replicates over 900 OpenVMS system service and run-time library calls in native C and C++, keeping argument structures, return codes, and error handling identical to the original VMS environment, so existing SYS$, LIB$, STR$, MTH$, and OTS$ calls link and run unchanged.

VX/RT is the umbrella runtime the other VX/TOOLS products link against. Each OpenVMS callable-service family (the api-* routine libraries such as LIB$, SYS$, EXE$, and STR$) has its own detailed reference page and is delivered inside VX/RT. This page is the runtime and API overview: how call-compatibility works, which families are covered, how status codes map, and where to find the per-library detail.

What VX/RT is

VX/RT is not a single binary. It is a collection of per-family routine libraries plus a shared runtime core. Each OpenVMS callable-service family maps to its own set of C++ translation units (one routine per file), compiled into the VX/RT run-time libraries that migrated OpenVMS applications (COBOL, FORTRAN, BASIC, Pascal, C) link against. The result is that an application keeps calling OpenVMS services by their original VMS names, and the linker resolves those names to Sector7's native implementations.

How call-compatibility works

The mechanism that makes a migrated program's SYS$ASCTIM(...) call resolve to Sector7 code is an assembler-level symbol alias. Each routine is written as a plain C function (for example SYS_D_ASCTIM) and then aliased to the VMS-spelled entry points, including the uppercase name, the lowercase name, and the FORTRAN trailing-underscore variant. Because the aliases are emitted as linker symbols, existing object references and recompiled call sites both resolve without any source change.

Caller
Migrated OpenVMS applicationCOBOL, FORTRAN, BASIC, Pascal, or C
Binding
Assembler .set symbol aliasesVMS-spelled entry points bind to native routine symbols at link time.
Libraries
VX/RT native C and C++ routinessys/, lib/, str/, mth/, ots/, smg/, cli/, and other families
Runtime core
VMS-compatible process substrateProcess context, ASTs, channels, event flags, IPC, and errno-to-VMS status mapping
Platform
LinuxRed Hat or SUSE on x86 or ARM
Call-compatible, not source-translated. VX/RT does not rewrite your application. Existing calls to SYS$, LIB$, STR$, MTH$, and OTS$ are preserved verbatim; only the implementation behind the VMS name changes.

Key capabilities

VX/RT reproduces the OpenVMS run-time environment as a whole, not just individual calls. The behaviour a migrated application depends on, file specifications, logical names, event flags, timers, and error semantics, is preserved so that application logic continues to work unchanged.

CapabilityWhat it provides
Call-compatible APIRecreates the behaviour of over 900 VMS and OpenVMS APIs in native C and C++, preserving argument structures, return codes, and error handling.
Seamless file specification handlingAccepts VMS-style file specifications, logical names, and search lists, translating them dynamically to Linux paths.
Identical error code mappingTranslates Linux and Windows errors to VMS status codes (for example ENOENT maps to RMS$_FNF).
Full RMS compatibilityProvides a complete RMS environment supporting FAB, RAB, NAM, and XAB control blocks, preserving record locking and data integrity.
Event flags and IPCSupports VMS-style event flags, inter-process communication, and shared memory, built on System V IPC primitives.
Logical name and symbol tablesReplicates VMS logical name tables and symbol management for cross-process communication.
Timers and asynchronous system callsImplements VMS-style timers, AST event handling, and asynchronous I/O.
DCL and CLI compatibilityIncludes VX/DCL, a fully functional OpenVMS DCL shell for Linux, together with VX/CLI for command parsing.
Batch and print queue supportImplements VMS batch and print queue management (SYS$SNDJBC, SYS$GETQUI, and related services).

Why teams choose VX/RT

  • Migrate OpenVMS applications to Linux with minimal source changes.
  • Retain existing API calls, file structures, and application logic.
  • Preserve RMS data integrity and record locking mechanisms.
  • Replicate VMS batch processing, DCL commands, and logical name handling.
  • Integrate with VX/DCL, VX/RMS, and the other Sector7 VX/TOOLS products.

VX/RT keeps VMS applications operational in modern Linux environments, removing the need for costly rewrites or extensive retraining.

Runtime libraries and API families

VX/RT provides call-compatible implementations of the major OpenVMS run-time libraries and system services. Each family below is delivered inside VX/RT and has its own detailed reference page. Use this section as the hub: start here for the runtime overview, then follow the link for per-routine detail, signatures, and status matrices.

Supported system services

The SYS$ system-service surface spans the areas an OpenVMS application relies on:

  • File management: SYS$OPEN, SYS$SEARCH, SYS$RENAME, SYS$DELETE.
  • Process control: SYS$CREPRC, SYS$DELPRC, SYS$HIBER, SYS$WAKE.
  • Inter-process communication: SYS$SNDJBC, SYS$GETQUI, SYS$GETMSG.
  • Timers and AST handling: SYS$SETIMR, SYS$CANTIM, SYS$SCHDWK.
  • Memory management: LIB$GET_VM, LIB$FREE_VM, LIB$CREATE_VM_ZONE.
  • String and math libraries: STR$, MTH$, OTS$.

Core system services and RTL

LibraryRoleReference
SYS$Core system service calls: process control, event flags, logical names, I/O, memory.System Interface Routines
LIB$General-purpose utilities: string, math, date and time, virtual memory, queues.General Routines
EXE$Operating-system interface: process execution and image management.Operating System Interface
STR$String descriptor routines: concat, copy, compare, extract, format.STRING Interface Routines
MTH$Mathematics run-time library: trigonometry, logarithms, exponentials, conversions.MATH Routines
OTS$Language-independent RTL: radix conversions, string-descriptor copy, power operations.Data Conversion Routines
CLI$Command-language interface: DCL parse, dispatch, get value, foreign commands.OpenVMS Command Interface

Language runtimes

LibraryRoleReference
BAS$BASIC run-time support for OpenVMS applications on Linux.BASIC Runtime Support
COB$COBOL run-time support, preserving system-call compatibility and program logic.COBOL Support Routines
FOR$FORTRAN run-time support, preserving language features and execution behaviour.FORTRAN Support Routines
PAS$Pascal run-time support, preserving language semantics on Linux.PASCAL Support Routines

Files, data, and utilities

LibraryRoleReference
FDL$File Definition Language: create RMS files from an FDL and generate an FDL from a file.File Definition Language
CONV$File conversion: copy RMS records with FDL-defined output, preserving integrity.File Conversion
CVT$Data conversion utilities: OpenVMS data format conversions for Linux systems.Data Conversion Routines
SOR$Callable SORT and MERGE interface for structured data processing.Interface to SORT
SQL$SQL database interface, preserving query execution behaviour for OpenVMS applications.SQL Database Interface
LBR$Callable librarian: archive and module management routines.Callable Librarian
EDT$Callable EDT-compatible editor for interactive and programmatic use.Callable Editor

Screen and forms

LibraryRoleReference
SMG$Screen management routines for interactive and terminal-based applications.Screen Management
FORMS$DECforms integration, maintaining structured UI and interaction logic.DECFORMS Integration
FDV$FMS forms management: forms processing and user-interaction handling.Forms Management System
Adjacent products. VX/RT works alongside VX/DCL for command language, VX/RMS for record management, VX/FDL for file definition, and VX/JSP for print and batch queues.

Anatomy of a VX/RT routine

Every VX/RT service shares the same shape: a thread-safe wrapper, delegation to an internal worker, a separate FORTRAN entry point where the calling convention needs one, and the alias macro that publishes the VMS-spelled names. Below is SYS$ASCTIM, which converts a VMS quadword binary time to an ASCII date and time string.

// extern worker (the actual conversion lives in the EXE_ layer)
extern "C" U32 EXE_D_ASCTIM( U16 *dplen, void *dp, Q_word *p_qtime, U32 flag );

U32 SYS_D_ASCTIM( U16 *Return_Length, void *Return_String,
                  void *v_qtime, U32 Flag )
{
    VX_BEGINS;                                     // trace / coverage entry hook
    U32 rc = EXE_D_ASCTIM(Return_Length, Return_String,
                          (Q_word*)v_qtime, Flag);
    VX_RETURNS(rc);                                // trace hook + return
}

// distinct FORTRAN entry: descriptors arrive as F4STR, hidden length last
extern "C" U32 F4_SYS_D_ASCTIM(U16 *dplen, F4STR(dp), Q_word *p_qtime,
                               U32 flag, F4STR_N(dp))
{
    F4STR_DECL(dp);
    F4STR_INIT(dp);
    return SYS_D_ASCTIM(dplen, dp, p_qtime, flag);
}

// publish the VMS-spelled entry points (C + FORTRAN)
__AliasF4(SYS_D_ASCTIM, F4_SYS_D_ASCTIM, SYS$ASCTIM, sys$asctim);

What a developer needs to know

  • Trace hooks are real. The VX_BEGINS and VX_RETURNS(x) are not no-ops: they record entry and exit and can emit a per-service coverage trace record. The return value passes through the exit hook, so the runtime observes every service's status code.
  • Descriptors match VMS. String and array arguments are OpenVMS descriptors. VX/RT reproduces the DEC descriptor headers verbatim (dsc$w_length, dsc$b_dtype, dsc$b_class, dsc$a_pointer), including the 32-bit and 64-bit forms, so struct layout is identical.
  • Status is returned by value. Routines return an OpenVMS condition value where an odd value means success, which is why callers test status & 1 (or the ODD() convention).
  • FORTRAN gets its own entry point where hidden string lengths require it, generated through the __AliasF4 macro and the F4STR helpers.

Status codes and error mapping

Return codes follow the OpenVMS condition-value convention: odd means success, which is why routines test status & 1. VX/RT reproduces the VMS status universe through the standard definition headers (ssdef.h for system-service status and rmsdef.h for RMS status), so an application that inspects VMS status codes behaves exactly as it did on OpenVMS.

Linux errno to VMS status

The headline example, a Linux file-not-found error surfacing as the VMS status RMS$_FNF, is implemented by a runtime translation function that maps each Linux errno onto its VMS equivalent. Representative mappings:

Linux errnoVMS statusMeaning
0SS$_NORMALSuccess.
EPERMSS$_NOPRIVNo privilege.
EINTRSS$_CANCELInterrupted.
EACCESRMS$_PRVProtection violation.
EAGAINRMS$_RLKRecord locked.
ENOENTRMS$_FNFFile not found.
ENORECRMS$_RNFRecord not found.
EEXISTRMS$_FEXFile already exists.
EBUSYRMS$_FLKFile locked.
EISDIRRMS$_DIRIs a directory.
EINVALSS$_INVARGInvalid argument.
EMFILESS$_EXFILLMOpen-file limit exceeded.

So ENOENT resolving to RMS$_FNF is a real, traceable mapping rather than a slogan: the same table drives every file and record operation, which is what keeps error-handling logic in migrated applications working unchanged.

Runtime core, IPC, and configuration

All of the $-families sit on a shared runtime core: the substrate that boots a VMS-like process context and provides the primitives the services build on. This is what turns a set of call-compatible routines into a faithful OpenVMS runtime.

What the core provides

  • Process and execution model: a VMS-like process context, image activation, and cluster plumbing.
  • Event flags, ASTs, and channels: common event flags, asynchronous system traps, condition handling, and queue primitives that back SYS$ASCEFC, SYS$SETEF, SYS$SETIMR, and SYS$SETAST.
  • C run-time bridge: the errno-to-VMS status mapping and the shims that connect VMS semantics to the underlying C library.
  • Global sections and shared memory: VMS event flags, mailboxes, and global sections are emulated on System V IPC and shared memory.
  • Message formatting: SYS$GETMSG-style message-file lookup and diagnostic formatting.
  • Logical name and symbol translation: the logical name tables and symbol tables that migrated applications and DCL depend on.

Configuration and logging

Runtime behaviour is driven by an INI-style configuration file with per-subsystem sections (operating system, VX/RT core, cluster services, device I/O, RMS, DCL, the C and C++ RTL, the BASIC, FORTRAN, and Pascal RTLs, print and batch, and logging). A separate platform variant covers macOS.

The trace facilities that the VX_BEGINS and VX_RETURNS hooks feed are tunable at run time. Operators can set, clear, allow, or disallow individual facilities (for example DCL, QIO, or process activation) and set per-facility levels, which makes it possible to turn on per-service coverage tracing for a specific subsystem without recompiling.

Divergences from OpenVMS

VX/RT aims for behavioural fidelity, but it runs on Linux rather than VMS, so a few differences are inherent to the platform. These are the ones worth knowing when planning a migration.

AreaDivergenceReason
Time rangeSYS$ASCTIM cannot represent dates before 1901.Built on the UNIX time base rather than the VMS epoch.
IPC substrateVMS event flags, mailboxes, and global sections are emulated.Implemented on System V IPC and shared memory on Linux.
Symbol spellingImplementation code uses C-safe symbol names internally; VMS dollar-sign names are published through headers and aliases.The $ character is not a legal C identifier, so internal tokens substitute an underscore form.
FORTRAN linkageSome routines need a separate FORTRAN entry point.FORTRAN passes hidden string lengths, handled by the __AliasF4 and F4STR wrappers.
Planning note. Family-level coverage is broad and the runtime wires VMS names to native implementations across every listed family. For workloads with unusual edge-case status dependencies, validate the specific status mappings your application relies on during migration testing.

Quick reference

Calling a service

Link the application against VX/RT and call services by their VMS names. SYS$ASCTIM, LIB$GET_VM, STR$CONCAT, MTH$SQRT, and OTS$SCOPY all resolve through the assembler-level aliases. Test success with if (status & 1) { /* ok */ }.

Platforms

  • RedHat and SUSE Linux.
  • x86 and ARM Linux.

Status and definitions

  • System-service status: ssdef.h.
  • RMS status: rmsdef.h.
  • Descriptor structures: dsc$descriptor and its fixed-length, 32-bit, and 64-bit forms.
  • Success convention: odd status is success (status & 1).

Representative routines by family

FamilyRepresentative routines
SYS$ASCTIM, BINTIM, ASCEFC, ASSIGN, CANTIM, CRELNM, CREPRC, CRMPSC
LIB$GET_VM, FREE_VM, CREATE_VM_ZONE, ADDTIMES, CALLG, DO_COMMAND
STR$CONCAT, APPEND, COMPARE, COPY_DX, MATCHWILD, POSITION
MTH$SQRT, ALOG, ALOG10, SIN, COS, ATAN2
OTS$SCOPY, CNVOUT, CVT_L_TB, MOVE3, POWDD
Per-library detail. Each family has its own reference page linked in Runtime libraries and API families above, with full routine tables and status matrices.

Frequently Asked Questions

Curious about how Sector7 can facilitate your application migration? Explore our FAQs for expert insights.

What is VX/RT and how does it help with OpenVMS migration?

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.

What system services does VX/RT support?

VX/RT provides comprehensive support for file management (SYS$OPEN, SYS$SEARCH, SYS$DELETE), process control (SYS$CREPRC, SYS$DELPRC), inter-process communication (SYS$SNDJBC, SYS$GETQUI), timers and AST handling (SYS$SETIMR, SYS$CANTIM), memory management (LIB$GET_VM, LIB$FREE_VM), and string and math libraries (STR$, MTH$, OTS$).

Does VX/RT handle VMS file specifications and logical names?

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

How does VX/RT handle error code mapping?

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

Does VX/RT support VMS event flags and inter-process communication?

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

What DCL and command interface capabilities are included?

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.

Do OpenVMS applications need to be modified to run on Linux with VX/RT?

No. VX/RT is a call-compatible library that lets OpenVMS applications run without modifications on RedHat and SUSE Linux. It replicates the API behaviour, argument structures, return codes, and error handling of the original VMS environment, so existing API calls, file structures, and application logic are retained.

How many OpenVMS system service calls does VX/RT replicate?

VX/RT replicates over 900 OpenVMS system service calls, recreating the behaviour of those VMS and OpenVMS APIs in native C and C++ while keeping argument structures, return codes, and error handling identical to VMS.

Which Linux distributions and platforms does VX/RT support?

VX/RT enables OpenVMS applications to run on RedHat and SUSE Linux, on both x86 and ARM architectures.

How does VX/RT map error codes between Linux and VMS?

VX/RT provides identical error code mapping, translating Linux errors into VMS status codes. For example, a file-not-found error surfaces as the VMS status RMS$_FNF, so applications that inspect VMS status codes behave as they did on OpenVMS.

What RMS features does VX/RT provide?

VX/RT provides a complete RMS environment supporting the FAB, RAB, NAM, and XAB control blocks, and preserves RMS data integrity and record locking mechanisms so file-based application logic is unchanged.

Does VX/RT include a DCL shell and command-line interface?

Yes. It includes VX/DCL, a fully functional OpenVMS DCL shell for Linux, plus VX/CLI for command parsing. It also replicates VMS logical name tables and symbol management for cross-process communication.

Which OpenVMS runtime libraries does VX/RT support?

VX/RT provides call-compatible implementations of the major OpenVMS runtime libraries, including LIB$ (general routines), STR$ (string), MTH$ (math), OTS$ (data conversion), and SYS$ (system interface), along with language runtimes such as BAS$, COB$, FOR$, and PAS$. Each family has its own detailed reference page under /technical/.

Does VX/RT support VMS batch and print queue management?

Yes. VX/RT implements VMS batch and print queue management using services such as SYS$SNDJBC and SYS$GETQUI, alongside VMS-style timers, AST event handling, and asynchronous I/O operations.

Transform Your Legacy Software Today!

Get In Touch
Unlock the potential of your legacy software with our expert migration services.