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.
<!-- Webflow embed (min). Source: rt-apis-page-technical/rt-tech-body-embed-dark.html → python3 website/embeds/minify_webflow_embed.py … -->
<div class="s7-tech-embed" data-vxrtd-body-embed="1" data-technical-mega-embed="1" lang="en"><h2 id="architecture">What VX/RT is</h2><p>
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.
</p><h6>How call-compatibility works</h6><p>
The mechanism that makes a migrated program's <code>SYS$ASCTIM(...)</code> call resolve to
Sector7 code is an assembler-level symbol alias. Each routine is written as a plain C
function (for example <code>SYS_D_ASCTIM</code>) 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.
</p><style>.s7-tech-embed[data-vxrtd-body-embed] .compat-stack {display: grid;gap: 10px;margin: 1.5rem 0;padding: 16px;border: 1px solid var(--s7t-border);border-radius: 10px;background: rgba(255, 255, 255, 0.01);}.s7-tech-embed[data-vxrtd-body-embed] .compat-card {display: grid;grid-template-columns: minmax(110px, 0.28fr) minmax(0, 1fr);gap: 16px;align-items: center;padding: 14px 16px;border-radius: 8px;background: var(--s7t-surface);color: var(--s7t-text);}.s7-tech-embed[data-vxrtd-body-embed] .compat-card strong,.s7-tech-embed[data-vxrtd-body-embed] .compat-card span {display: block;}.s7-tech-embed[data-vxrtd-body-embed] .compat-card strong {margin-bottom: 4px;}.s7-tech-embed[data-vxrtd-body-embed] .compat-card span {color: var(--s7t-muted);font-size: 0.9em;line-height: 1.45;}.s7-tech-embed[data-vxrtd-body-embed] .compat-label,.s7-tech-embed[data-vxrtd-body-embed] .compat-link {font-family: var(--s7t-mono);color: var(--s7t-accent);font-size: 0.76em;font-weight: 700;letter-spacing: 0.08em;text-transform: uppercase;}.s7-tech-embed[data-vxrtd-body-embed] .compat-link {padding-left: 16px;}.s7-tech-embed[data-vxrtd-body-embed] .compat-runtime {border: 1px solid var(--s7t-note-bd);background: var(--s7t-note-bg);}@media (max-width: 700px) {.s7-tech-embed[data-vxrtd-body-embed] .compat-card {grid-template-columns: 1fr;gap: 5px;}.s7-tech-embed[data-vxrtd-body-embed] .compat-link {padding-left: 0;}}</style><div class="compat-stack" role="group" aria-label="VX/RT call compatibility stack"><div class="compat-card"><span class="compat-label">Caller</span><div><strong>Migrated OpenVMS application</strong><span>COBOL, FORTRAN, BASIC, Pascal, or C</span></div></div><div class="compat-link">Calls SYS$ASCTIM, LIB$GET_VM, STR$CONCAT, and other VMS names</div><div class="compat-card"><span class="compat-label">Binding</span><div><strong>Assembler .set symbol aliases</strong><span>VMS-spelled entry points bind to native routine symbols at link time.</span></div></div><div class="compat-link">Resolves into the matching routine family</div><div class="compat-card"><span class="compat-label">Libraries</span><div><strong>VX/RT native C and C++ routines</strong><span><code>sys/</code>, <code>lib/</code>, <code>str/</code>, <code>mth/</code>, <code>ots/</code>, <code>smg/</code>, <code>cli/</code>, and other families</span></div></div><div class="compat-link">Delegates shared execution semantics</div><div class="compat-card compat-runtime"><span class="compat-label">Runtime core</span><div><strong>VMS-compatible process substrate</strong><span>Process context, ASTs, channels, event flags, IPC, and errno-to-VMS status mapping</span></div></div><div class="compat-link">Runs natively on the target host</div><div class="compat-card"><span class="compat-label">Platform</span><div><strong>Linux</strong><span>Red Hat or SUSE on x86 or ARM</span></div></div></div><div class="callout"><strong>Call-compatible, not source-translated.</strong> VX/RT does not rewrite your
application. Existing calls to <code>SYS$</code>, <code>LIB$</code>, <code>STR$</code>,
<code>MTH$</code>, and <code>OTS$</code> are preserved verbatim; only the implementation
behind the VMS name changes.
</div><h2 id="capabilities">Key capabilities</h2><p>
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.
</p><div class="table-wrapper"><table><thead><tr><th>Capability</th><th>What it provides</th></tr></thead><tbody><tr><td><strong>Call-compatible API</strong></td><td>Recreates the behaviour of over 900 VMS and OpenVMS APIs in native C and C++, preserving argument structures, return codes, and error handling.</td></tr><tr><td><strong>Seamless file specification handling</strong></td><td>Accepts VMS-style file specifications, logical names, and search lists, translating them dynamically to Linux paths.</td></tr><tr><td><strong>Identical error code mapping</strong></td><td>Translates Linux and Windows errors to VMS status codes (for example <code>ENOENT</code> maps to <code>RMS$_FNF</code>).</td></tr><tr><td><strong>Full RMS compatibility</strong></td><td>Provides a complete RMS environment supporting FAB, RAB, NAM, and XAB control blocks, preserving record locking and data integrity.</td></tr><tr><td><strong>Event flags and IPC</strong></td><td>Supports VMS-style event flags, inter-process communication, and shared memory, built on System V IPC primitives.</td></tr><tr><td><strong>Logical name and symbol tables</strong></td><td>Replicates VMS logical name tables and symbol management for cross-process communication.</td></tr><tr><td><strong>Timers and asynchronous system calls</strong></td><td>Implements VMS-style timers, AST event handling, and asynchronous I/O.</td></tr><tr><td><strong>DCL and CLI compatibility</strong></td><td>Includes VX/DCL, a fully functional OpenVMS DCL shell for Linux, together with VX/CLI for command parsing.</td></tr><tr><td><strong>Batch and print queue support</strong></td><td>Implements VMS batch and print queue management (<code>SYS$SNDJBC</code>, <code>SYS$GETQUI</code>, and related services).</td></tr></tbody></table></div><h6>Why teams choose VX/RT</h6><ul><li>Migrate OpenVMS applications to Linux with minimal source changes.</li><li>Retain existing API calls, file structures, and application logic.</li><li>Preserve RMS data integrity and record locking mechanisms.</li><li>Replicate VMS batch processing, DCL commands, and logical name handling.</li><li>Integrate with VX/DCL, VX/RMS, and the other Sector7 VX/TOOLS products.</li></ul><p>
VX/RT keeps VMS applications operational in modern Linux environments, removing the need for
costly rewrites or extensive retraining.
</p><h2 id="families">Runtime libraries and API families</h2><p>
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.
</p><h6>Supported system services</h6><p>The <code>SYS$</code> system-service surface spans the areas an OpenVMS application relies on:</p><ul><li><strong>File management</strong>: <code>SYS$OPEN</code>, <code>SYS$SEARCH</code>, <code>SYS$RENAME</code>, <code>SYS$DELETE</code>.</li><li><strong>Process control</strong>: <code>SYS$CREPRC</code>, <code>SYS$DELPRC</code>, <code>SYS$HIBER</code>, <code>SYS$WAKE</code>.</li><li><strong>Inter-process communication</strong>: <code>SYS$SNDJBC</code>, <code>SYS$GETQUI</code>, <code>SYS$GETMSG</code>.</li><li><strong>Timers and AST handling</strong>: <code>SYS$SETIMR</code>, <code>SYS$CANTIM</code>, <code>SYS$SCHDWK</code>.</li><li><strong>Memory management</strong>: <code>LIB$GET_VM</code>, <code>LIB$FREE_VM</code>, <code>LIB$CREATE_VM_ZONE</code>.</li><li><strong>String and math libraries</strong>: <code>STR$</code>, <code>MTH$</code>, <code>OTS$</code>.</li></ul><h6>Core system services and RTL</h6><div class="table-wrapper"><table><thead><tr><th>Library</th><th>Role</th><th>Reference</th></tr></thead><tbody><tr><td><code>SYS$</code></td><td>Core system service calls: process control, event flags, logical names, I/O, memory.</td><td><a href="/technical/api-sys-interface-routines">System Interface Routines</a></td></tr><tr><td><code>LIB$</code></td><td>General-purpose utilities: string, math, date and time, virtual memory, queues.</td><td><a href="/technical/api-lib-general-routines">General Routines</a></td></tr><tr><td><code>EXE$</code></td><td>Operating-system interface: process execution and image management.</td><td><a href="/technical/api-exe-operating-system-interface">Operating System Interface</a></td></tr><tr><td><code>STR$</code></td><td>String descriptor routines: concat, copy, compare, extract, format.</td><td><a href="/technical/api-str-string-interface-routines">STRING Interface Routines</a></td></tr><tr><td><code>MTH$</code></td><td>Mathematics run-time library: trigonometry, logarithms, exponentials, conversions.</td><td><a href="/technical/api-mth-math-routines">MATH Routines</a></td></tr><tr><td><code>OTS$</code></td><td>Language-independent RTL: radix conversions, string-descriptor copy, power operations.</td><td><a href="/technical/api-ots-data-conversion-routines">Data Conversion Routines</a></td></tr><tr><td><code>CLI$</code></td><td>Command-language interface: DCL parse, dispatch, get value, foreign commands.</td><td><a href="/technical/api-cli-command-line-interface">OpenVMS Command Interface</a></td></tr></tbody></table></div><h6>Language runtimes</h6><div class="table-wrapper"><table><thead><tr><th>Library</th><th>Role</th><th>Reference</th></tr></thead><tbody><tr><td><code>BAS$</code></td><td>BASIC run-time support for OpenVMS applications on Linux.</td><td><a href="/technical/api-bas-basic-runtime-support">BASIC Runtime Support</a></td></tr><tr><td><code>COB$</code></td><td>COBOL run-time support, preserving system-call compatibility and program logic.</td><td><a href="/technical/api-cob-cobol-support-routines">COBOL Support Routines</a></td></tr><tr><td><code>FOR$</code></td><td>FORTRAN run-time support, preserving language features and execution behaviour.</td><td><a href="/technical/api-for-fortran-support-routines">FORTRAN Support Routines</a></td></tr><tr><td><code>PAS$</code></td><td>Pascal run-time support, preserving language semantics on Linux.</td><td><a href="/technical/pascal-support-routines">PASCAL Support Routines</a></td></tr></tbody></table></div><h6>Files, data, and utilities</h6><div class="table-wrapper"><table><thead><tr><th>Library</th><th>Role</th><th>Reference</th></tr></thead><tbody><tr><td><code>FDL$</code></td><td>File Definition Language: create RMS files from an FDL and generate an FDL from a file.</td><td><a href="/technical/api-fdl-file-definition-language">File Definition Language</a></td></tr><tr><td><code>CONV$</code></td><td>File conversion: copy RMS records with FDL-defined output, preserving integrity.</td><td><a href="/technical/api-conv-file-conversion">File Conversion</a></td></tr><tr><td><code>CVT$</code></td><td>Data conversion utilities: OpenVMS data format conversions for Linux systems.</td><td><a href="/technical/api-ots-data-conversion-routines">Data Conversion Routines</a></td></tr><tr><td><code>SOR$</code></td><td>Callable SORT and MERGE interface for structured data processing.</td><td><a href="/technical/api-sor-interface-to-sort">Interface to SORT</a></td></tr><tr><td><code>SQL$</code></td><td>SQL database interface, preserving query execution behaviour for OpenVMS applications.</td><td><a href="/technical/api-sql-database-interface">SQL Database Interface</a></td></tr><tr><td><code>LBR$</code></td><td>Callable librarian: archive and module management routines.</td><td><a href="/technical/api-lbr-callable-librarian">Callable Librarian</a></td></tr><tr><td><code>EDT$</code></td><td>Callable EDT-compatible editor for interactive and programmatic use.</td><td><a href="/technical/api-edt-callable-editor">Callable Editor</a></td></tr></tbody></table></div><h6>Screen and forms</h6><div class="table-wrapper"><table><thead><tr><th>Library</th><th>Role</th><th>Reference</th></tr></thead><tbody><tr><td><code>SMG$</code></td><td>Screen management routines for interactive and terminal-based applications.</td><td><a href="/technical/api-smg-screen-management">Screen Management</a></td></tr><tr><td><code>FORMS$</code></td><td>DECforms integration, maintaining structured UI and interaction logic.</td><td><a href="/technical/api-forms-dec-integration">DECFORMS Integration</a></td></tr><tr><td><code>FDV$</code></td><td>FMS forms management: forms processing and user-interaction handling.</td><td><a href="/technical/api-fms-forms-management-system">Forms Management System</a></td></tr></tbody></table></div><div class="callout"><strong>Adjacent products.</strong> VX/RT works alongside
<a href="/technical/vx-dcl-vms-dcl">VX/DCL</a> for command language,
<a href="/technical/vx-rms-sys-routines-for-rms">VX/RMS</a> for record management,
<a href="/technical/vx-fdl-file-description-language-routines">VX/FDL</a> for file definition, and
<a href="/technical/vx-jsp-vms-print-batch">VX/JSP</a> for print and batch queues.
</div><h2 id="routine-anatomy">Anatomy of a VX/RT routine</h2><p>
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 <code>SYS$ASCTIM</code>, which
converts a VMS quadword binary time to an ASCII date and time string.
</p>
<pre><span class="cmt">// extern worker (the actual conversion lives in the EXE_ layer)</span>
<span class="kw">extern</span> <span class="str">"C"</span> 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; <span class="cmt">// trace / coverage entry hook</span>
U32 rc = EXE_D_ASCTIM(Return_Length, Return_String,
(Q_word*)v_qtime, Flag);
VX_RETURNS(rc); <span class="cmt">// trace hook + return</span>
}
<span class="cmt">// distinct FORTRAN entry: descriptors arrive as F4STR, hidden length last</span>
<span class="kw">extern</span> <span class="str">"C"</span> U32 F4_SYS_D_ASCTIM(U16 *dplen, F4STR(dp), Q_word *p_qtime,
U32 flag, F4STR_N(dp))
{
F4STR_DECL(dp);
F4STR_INIT(dp);
<span class="kw">return</span> SYS_D_ASCTIM(dplen, dp, p_qtime, flag);
}
<span class="cmt">// publish the VMS-spelled entry points (C + FORTRAN)</span>
__AliasF4(SYS_D_ASCTIM, F4_SYS_D_ASCTIM, SYS$ASCTIM, sys$asctim);</pre>
<h6>What a developer needs to know</h6><ul><li><strong>Trace hooks are real.</strong> The <code>VX_BEGINS</code> and
<code>VX_RETURNS(x)</code> 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.</li><li><strong>Descriptors match VMS.</strong> String and array arguments are OpenVMS
descriptors. VX/RT reproduces the DEC descriptor headers verbatim
(<code>dsc$w_length</code>, <code>dsc$b_dtype</code>, <code>dsc$b_class</code>,
<code>dsc$a_pointer</code>), including the 32-bit and 64-bit forms, so struct layout is
identical.</li><li><strong>Status is returned by value.</strong> Routines return an OpenVMS condition
value where an odd value means success, which is why callers test <code>status & 1</code>
(or the <code>ODD()</code> convention).</li><li><strong>FORTRAN gets its own entry point</strong> where hidden string lengths require
it, generated through the <code>__AliasF4</code> macro and the <code>F4STR</code> helpers.</li></ul><h2 id="status-codes">Status codes and error mapping</h2><p>
Return codes follow the OpenVMS condition-value convention: odd means success, which is why
routines test <code>status & 1</code>. VX/RT reproduces the VMS status universe through
the standard definition headers (<code>ssdef.h</code> for system-service status and
<code>rmsdef.h</code> for RMS status), so an application that inspects VMS status codes
behaves exactly as it did on OpenVMS.
</p><h6>Linux errno to VMS status</h6><p>
The headline example, a Linux file-not-found error surfacing as the VMS status
<code>RMS$_FNF</code>, is implemented by a runtime translation function that maps each Linux
errno onto its VMS equivalent. Representative mappings:
</p><div class="table-wrapper"><table><thead><tr><th>Linux <code>errno</code></th><th>VMS status</th><th>Meaning</th></tr></thead><tbody><tr><td><code>0</code></td><td><code>SS$_NORMAL</code></td><td>Success.</td></tr><tr><td><code>EPERM</code></td><td><code>SS$_NOPRIV</code></td><td>No privilege.</td></tr><tr><td><code>EINTR</code></td><td><code>SS$_CANCEL</code></td><td>Interrupted.</td></tr><tr><td><code>EACCES</code></td><td><code>RMS$_PRV</code></td><td>Protection violation.</td></tr><tr><td><code>EAGAIN</code></td><td><code>RMS$_RLK</code></td><td>Record locked.</td></tr><tr><td><code>ENOENT</code></td><td><code>RMS$_FNF</code></td><td>File not found.</td></tr><tr><td><code>ENOREC</code></td><td><code>RMS$_RNF</code></td><td>Record not found.</td></tr><tr><td><code>EEXIST</code></td><td><code>RMS$_FEX</code></td><td>File already exists.</td></tr><tr><td><code>EBUSY</code></td><td><code>RMS$_FLK</code></td><td>File locked.</td></tr><tr><td><code>EISDIR</code></td><td><code>RMS$_DIR</code></td><td>Is a directory.</td></tr><tr><td><code>EINVAL</code></td><td><code>SS$_INVARG</code></td><td>Invalid argument.</td></tr><tr><td><code>EMFILE</code></td><td><code>SS$_EXFILLM</code></td><td>Open-file limit exceeded.</td></tr></tbody></table></div><p>
So <code>ENOENT</code> resolving to <code>RMS$_FNF</code> 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.
</p><h2 id="runtime-core">Runtime core, IPC, and configuration</h2><p>
All of the <code>$</code>-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.
</p><h6>What the core provides</h6><ul><li><strong>Process and execution model</strong>: a VMS-like process context, image
activation, and cluster plumbing.</li><li><strong>Event flags, ASTs, and channels</strong>: common event flags, asynchronous
system traps, condition handling, and queue primitives that back
<code>SYS$ASCEFC</code>, <code>SYS$SETEF</code>, <code>SYS$SETIMR</code>, and
<code>SYS$SETAST</code>.</li><li><strong>C run-time bridge</strong>: the errno-to-VMS status mapping and the shims that
connect VMS semantics to the underlying C library.</li><li><strong>Global sections and shared memory</strong>: VMS event flags, mailboxes, and
global sections are emulated on System V IPC and shared memory.</li><li><strong>Message formatting</strong>: <code>SYS$GETMSG</code>-style message-file lookup
and diagnostic formatting.</li><li><strong>Logical name and symbol translation</strong>: the logical name tables and
symbol tables that migrated applications and DCL depend on.</li></ul><h6>Configuration and logging</h6><p>
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.
</p><p>
The trace facilities that the <code>VX_BEGINS</code> and <code>VX_RETURNS</code> 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.
</p><h2 id="divergences">Divergences from OpenVMS</h2><p>
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.
</p><div class="table-wrapper"><table><thead><tr><th>Area</th><th>Divergence</th><th>Reason</th></tr></thead><tbody><tr><td>Time range</td><td><code>SYS$ASCTIM</code> cannot represent dates before 1901.</td><td>Built on the UNIX time base rather than the VMS epoch.</td></tr><tr><td>IPC substrate</td><td>VMS event flags, mailboxes, and global sections are emulated.</td><td>Implemented on System V IPC and shared memory on Linux.</td></tr><tr><td>Symbol spelling</td><td>Implementation code uses C-safe symbol names internally; VMS dollar-sign names are published through headers and aliases.</td><td>The <code>$</code> character is not a legal C identifier, so internal tokens substitute an underscore form.</td></tr><tr><td>FORTRAN linkage</td><td>Some routines need a separate FORTRAN entry point.</td><td>FORTRAN passes hidden string lengths, handled by the <code>__AliasF4</code> and <code>F4STR</code> wrappers.</td></tr></tbody></table></div><div class="callout"><strong>Planning note.</strong> 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.
</div><h2 id="quickref">Quick reference</h2><h6>Calling a service</h6><p>
Link the application against VX/RT and call services by their VMS names.
<code>SYS$ASCTIM</code>, <code>LIB$GET_VM</code>, <code>STR$CONCAT</code>,
<code>MTH$SQRT</code>, and <code>OTS$SCOPY</code> all resolve through the assembler-level
aliases. Test success with <code>if (status & 1) { /* ok */ }</code>.
</p><h6>Platforms</h6><ul><li>RedHat and SUSE Linux.</li><li>x86 and ARM Linux.</li></ul><h6>Status and definitions</h6><ul><li>System-service status: <code>ssdef.h</code>.</li><li>RMS status: <code>rmsdef.h</code>.</li><li>Descriptor structures: <code>dsc$descriptor</code> and its fixed-length, 32-bit, and 64-bit forms.</li><li>Success convention: odd status is success (<code>status & 1</code>).</li></ul><h6>Representative routines by family</h6><div class="table-wrapper"><table><thead><tr><th>Family</th><th>Representative routines</th></tr></thead><tbody><tr><td><code>SYS$</code></td><td><code>ASCTIM</code>, <code>BINTIM</code>, <code>ASCEFC</code>, <code>ASSIGN</code>, <code>CANTIM</code>, <code>CRELNM</code>, <code>CREPRC</code>, <code>CRMPSC</code></td></tr><tr><td><code>LIB$</code></td><td><code>GET_VM</code>, <code>FREE_VM</code>, <code>CREATE_VM_ZONE</code>, <code>ADDTIMES</code>, <code>CALLG</code>, <code>DO_COMMAND</code></td></tr><tr><td><code>STR$</code></td><td><code>CONCAT</code>, <code>APPEND</code>, <code>COMPARE</code>, <code>COPY_DX</code>, <code>MATCHWILD</code>, <code>POSITION</code></td></tr><tr><td><code>MTH$</code></td><td><code>SQRT</code>, <code>ALOG</code>, <code>ALOG10</code>, <code>SIN</code>, <code>COS</code>, <code>ATAN2</code></td></tr><tr><td><code>OTS$</code></td><td><code>SCOPY</code>, <code>CNVOUT</code>, <code>CVT_L_TB</code>, <code>MOVE3</code>, <code>POWDD</code></td></tr></tbody></table></div><div class="callout"><strong>Per-library detail.</strong> Each family has its own reference page linked in
<a href="#families">Runtime libraries and API families</a> above, with full routine tables
and status matrices.
</div></div>
