LIB$ – General Routines

VX/LIB$ is a call-compatible implementation of the OpenVMS LIB$ general-purpose run-time library for x86 and ARM Linux. Applications that call LIB$ routines for string handling, integer and extended arithmetic, date and time, virtual-memory management, queues, balanced trees, and system services link against the VX runtime and run unchanged, keeping the same calling conventions, string descriptors, and condition-code behavior they relied on under OpenVMS.

VX/LIB$ is a library, not a server or daemon. Its routines are compiled into the VX runtime library and linked directly into the migrated program. Over 150 LIB$ entry points are implemented and exposed under their VMS dollar-sign names as well as portable C and Fortran-callable aliases, so existing object references resolve and existing source compiles without rewriting the calling logic. VX/LIB$ integrates with VX/RT to deliver full OpenVMS utility functionality across x86 and ARM Linux.

Architecture and linkage

VX/LIB$ is a library, not a running service. Its routines are compiled from C++ (with a small number of C modules) into object modules and archived into the VX runtime static library, libvxrt.a. A migrated application links that archive and calls the LIB$ entry points directly, exactly as it linked the OpenVMS run-time library before. There is no LIB$ server process, no daemon, and no inter-process substrate to configure.

Property	VX/LIB$
Delivery	Object modules archived into `libvxrt.a`, linked into the application.
Implementation language	C++ with `extern "C"` bodies, plus a small number of C modules.
Public entry points	Over 150 distinct `LIB$` routines.
Calling model	Direct in-process function calls; no runtime server, no IPC.
Target platforms	x86 and ARM Linux, through the VX/RT runtime.
Prototypes	Shared VX headers (string descriptors, aliases, `lib$routines.h`).

Link model

Caller

Application object codeCalls LIB$INDEX, LIB$GET_VM, LIB$ADD_TIMES, LIB$SYS_FAO, and related routines.

Naming, linkage and calling conventions

Every routine is exposed under several equivalent names, so existing object references and source in any supported language resolve without change. The VMS dollar-sign form (LIB$INDEX) and its lowercase spelling (lib$index) are aliases for a canonical C symbol; Fortran callers reach the same body through a thunk that unpacks the hidden trailing length arguments the Fortran ABI passes.

Name form	Example	Used by
VMS dollar-sign name	`LIB$INDEX`	Recompiled OpenVMS object code and assembler references.
Lowercase alias	`lib$index`	Case-sensitive toolchains and mixed-case source.
Canonical C symbol	`LIB_D_INDEX`	Portable C and C++ callers.
Fortran-callable thunk	`LIB$CRC` (with length args)	Fortran callers that pass hidden string lengths.

Condition-code convention

Routines that report status return a 32-bit VMS condition value by value: odd means success, even means failure. Callers test the low bit (status & 1, or ODD(status) in the original languages) rather than comparing against a single success constant, because success can be reported as either SS$_NORMAL or LIB$_NORMAL. A small number of routines report results by raising a VMS-style signal instead of returning: LIB$SIGNAL, LIB$STOP and LIB$SIG_TO_STOP, caught through LIB$ESTABLISH or an equivalent handler.

Symbol	Value	Meaning
`SS$_NORMAL`	`1`	Generic success.
`LIB$_NORMAL`	`0x158009`	LIB$ success (distinct from `SS$_NORMAL`).
`LIB$_STRTRU`	`0x158040`	Output string truncated (qualified success).
`LIB$_INTOVF`	`0x150854`	Integer overflow.
`LIB$_INVARG`	`0x158094`	Invalid argument.
`LIB$_INSVIRMEM`	`0x15800C`	Insufficient virtual memory.
`LIB$_ONEDELTIM`	`0x158434`	At least one delta time required.
`LIB$_KEYNOTFOU`	`0x158184`	Key not found (tree lookup).
`LIB$_QUEWASEMP`	`0x15816C`	Queue was empty.

A routine body

Routine bodies are plain extern "C" functions that unpack their string descriptors and return a condition value or result. LIB$INDEX, which returns the 1-based position of a substring, is representative:

extern "C" U32 LIB_D_INDEX( VMS_DESCR *sourcestring, VMS_DESCR *substring )
{
    /* unpack both descriptors to pointer + length */
    subp = vxrt_strptr16(substring,   &subl);
    srcp = vxrt_strptr16(sourcestring, &srcl);
    if (subl > srcl) return 0;
    for (i = 0; i < srcl && (i + subl) <= srcl; i++)
        if (!memcmp(srcp + i, subp, subl)) return i + 1;
    return 0;
}

Calling a routine

A migrated program links against libvxrt.a and calls the LIB$ entry points directly. The example below allocates a buffer, locates a field within a statement line, and formats an operator message, testing the low bit of each status:

/* allocate a working buffer from LIB$ virtual memory */
status = LIB$GET_VM(&buf_size, &buffer_addr);
if (!(status & 1)) return status;         /* odd = success */

/* 1-based position of the account reference in a statement line */
position = LIB$INDEX(&statement_line, &acct_ref);

/* format an operator message with FAO directives */
status = LIB$SYS_FAO(&fao_control, &out_len, &message,
                     transfer_id, transfer_amount);

/* release the buffer back to the VM zone */
status = LIB$FREE_VM(&buf_size, &buffer_addr);

Data model

Two OpenVMS data conventions matter to almost every caller: the string descriptor and the quadword. VX/LIB$ accepts both the 32-bit and 64-bit VMS descriptor layouts and infers which one is in use from the descriptor's first word, so mixed 32-bit and 64-bit code links together without change.

String descriptors

String arguments are passed by descriptor rather than as bare pointers. The descriptor records the storage class, data type, length, and address of the string. The storage class determines how the buffer is managed:

Class	Value	Storage
`DSC$K_CLASS_S`	1	Static: a fixed caller-supplied buffer.
`DSC$K_CLASS_D`	2	Dynamic: runtime-allocated and resizable through `LIB$SGET1_DD`.
`DSC$K_CLASS_VS`	11	Varying: a 16-bit current-length prefix plus a fixed buffer.
`DSC$K_CLASS_SD`	9	Scaled decimal, used by `LIB$CVT_DX_DX`.

Quadwords and VMS time

Time values are 64-bit quadwords, a pair of 32-bit fields (a low and a high longword). VMS time is counted in 100-nanosecond ticks from the standard 1858-11-17 epoch. A delta (relative) time is distinguished from an absolute time by the top bit of the high longword, which the time routines test before choosing how to add, subtract, or scale two values. This is why routines such as LIB$ADD_TIMES and LIB$SUB_TIMES return LIB$_ONEDELTIM when neither operand is a delta time: the operation is only defined when at least one operand is relative.

Routine groups

The LIB$ library spans a wide range of general-purpose services. The table below groups the implemented routines by function and names a representative sample from each group; the full list follows in the next section.

Group	What it covers	Representative routines
Integer and bit arithmetic	Extended-precision add, subtract, multiply and divide, and bit-field operations.	`LIB$ADDX`, `LIB$SUBX`, `LIB$EDIV`, `LIB$EMUL`, `LIB$INSV`, `LIB$FFS`
String and character	Search, compare, move, translate and copy operations over descriptor strings.	`LIB$INDEX`, `LIB$LEN`, `LIB$MATCHC`, `LIB$SCANC`, `LIB$MOVC3`, `LIB$MOVTC`
Date and time	Current time, time arithmetic, and conversion to and from the system internal time format.	`LIB$DATE_TIME`, `LIB$ADD_TIMES`, `LIB$SUB_TIMES`, `LIB$DAY_OF_WEEK`, `LIB$FORMAT_DATE_TIME`
Data conversion	Radix conversion, numeric formatting, and character-set translation.	`LIB$CVT_HTB`, `LIB$CVT_OTB`, `LIB$CURRENCY`, `LIB$TRA_ASC_EBC`, `LIB$TRA_EBC_ASC`
Virtual memory (32 and 64 bit)	General allocation, page allocation, and zone management in both addressing modes.	`LIB$GET_VM`, `LIB$FREE_VM`, `LIB$CREATE_VM_ZONE`, `LIB$GET_VM_64`
Queues and trees	Self-relative interlocked queues and balanced binary trees.	`LIB$INSQHI`, `LIB$REMQTI`, `LIB$INSERT_TREE`, `LIB$LOOKUP_TREE`
Symbols, logicals and common	DCL symbol and logical-name access and the inter-image common block.	`LIB$GET_SYMBOL`, `LIB$SET_LOGICAL`, `LIB$SYS_TRNLOG`, `LIB$GET_COMMON`
Process and system information	Device, process, queue and system inquiry, and subprocess control.	`LIB$GETDVI`, `LIB$GETJPI`, `LIB$GETSYI`, `LIB$SPAWN`, `LIB$RUN_PROGRAM`
Screen and terminal	Cursor placement, screen and line erase, scrolling and buffered output.	`LIB$SET_CURSOR`, `LIB$ERASE_LINE`, `LIB$PUT_SCREEN`, `LIB$SCREEN_INFO`
Condition handling and signals	Establishing and reverting handlers and signalling conditions.	`LIB$SIGNAL`, `LIB$STOP`, `LIB$ESTABLISH`, `LIB$REVERT`, `LIB$SIG_TO_RET`
Files	File search, scan, rename, delete and directory creation.	`LIB$FIND_FILE`, `LIB$FILE_SCAN`, `LIB$DELETE_FILE`, `LIB$CREATE_DIR`
Event flags, LUNs and timers	Allocation of event flags and logical unit numbers, and timing statistics.	`LIB$GET_EF`, `LIB$GET_LUN`, `LIB$INIT_TIMER`, `LIB$STAT_TIMER`
Messages and formatting	FAO output formatting, system message retrieval, and input and output helpers.	`LIB$SYS_FAO`, `LIB$SYS_FAOL`, `LIB$SYS_GETMSG`, `LIB$PUT_OUTPUT`
Checksums	CRC checksum generation over a descriptor byte stream.	`LIB$CRC`, `LIB$CRC_TABLE`

VX/LIB$ callable routines

The full set of callable routines, over 150 in total, spanning string handling, arithmetic, date and time, virtual memory, queues, trees, screen control, files, and system services. Each is available under its VMS dollar-sign name as well as the portable C and Fortran-callable aliases described above.

LIB$ API	Function
`LIB$ADAWI`	Adds a word-integer value
`LIB$ADD_TIMES`	Add two time values
`LIB$ADDX`	Add two numbers
`LIB$ANALYZE_SDESC`	Analyze string descriptor
`LIB$ASN_WTH_MBX`	Assigns a mailbox for communication
`LIB$AST_IN_PROG`	Checks if an AST (Asynchronous System Trap) is in progress
`LIB$ATTACH`	Attach to process
`LIB$BBCCI`	Performs bitwise operations on bit fields
`LIB$CALLG`	General call function
`LIB$CALLG_64`	Calls a function with arguments in 64-bit addressing
`LIB$CONVERT_DATE_STRING`	Convert date string
`LIB$CRC`	Compute CRC checksum
`LIB$CRC_TABLE`	Generate CRC table
`LIB$CREATE_DIR`	Create a directory
`LIB$CREATE_VM_ZONE`	Create VM zone
`LIB$CREATE_VM_ZONE_64`	Creates a 64-bit virtual memory zone
`LIB$CURRENCY`	Formats numbers as currency values
`LIB$CVT_DTB`	Convert date to binary
`LIB$CVT_DTB_64`	Converts a 64-bit date-time value to binary
`LIB$CVT_DX_DX`	Convert descriptor to descriptor
`LIB$CVT_FROM_INTERNAL_TIME`	Converts system internal time to standard format
`LIB$CVT_HTB`	Convert hex to binary
`LIB$CVT_OTB`	Convert octal to binary
`LIB$CVT_TO_INTERNAL_TIME`	Convert to internal time
`LIB$CVT_VECTIM`	Converts vector time format to system time
`LIB$CVTF_FROM_INTERNAL_TIME`	Converts floating-point internal time to standard format
`LIB$CVTF_TO_INTERNAL_TIME`	Converts standard time to floating-point internal time
`LIB$CVTS_FROM_INTERNAL_TIME`	Converts string-formatted internal time to standard
`LIB$CVTS_TO_INTERNAL_TIME`	Converts standard time to string-formatted internal time
`LIB$DATE_TIME`	Get current date and time
`LIB$DAY`	Get day value
`LIB$DAY_OF_WEEK`	Get day of the week
`LIB$DELETE_FILE`	Delete a file
`LIB$DELETE_LOGICAL`	Delete logical name
`LIB$DELETE_SYMBOL`	Delete a symbol
`LIB$DELETE_VM_ZONE`	Delete VM zone
`LIB$DELETE_VM_ZONE_64`	Deletes a 64-bit virtual memory zone
`LIB$DIGIT_SEP`	Format digit separators
`LIB$DISABLE_CTRL`	Disable control characters
`LIB$DO_COMMAND`	Execute a command
`LIB$DOWN_SCROLL`	Scrolls the display downwards
`LIB$EDIV`	Performs extended division on large integers
`LIB$EMUL`	Performs extended multiplication
`LIB$ENABLE_CTRL`	Enable control characters
`LIB$ERASE_LINE`	Erase line on display
`LIB$ERASE_PAGE`	Erase page on display
`LIB$ESTABLISH`	Set up error handler
`LIB$EXTV`	Extend vector operation
`LIB$EXTZV`	Extend zero vector
`LIB$FFC`	Find first character
`LIB$FFS`	Find first set bit
`LIB$FILE_SCAN`	Scans files for specified patterns
`LIB$FILE_SCAN_END`	Ends a file scanning operation
`LIB$FIND_FILE`	Find file in directory
`LIB$FIND_FILE_END`	End file search
`LIB$FIND_IMAGE_SYMBOL`	Find symbol in image
`LIB$FIND_VM_ZONE`	Locates a virtual memory zone
`LIB$FIND_VM_ZONE_64`	Locates a 64-bit virtual memory zone
`LIB$FORMAT_DATE_TIME`	Format date and time
`LIB$FREE_DATE_TIME_CONTEXT`	Releases memory allocated for date-time processing
`LIB$FREE_EF`	Free event flag
`LIB$FREE_LUN`	Free logical unit number
`LIB$FREE_TIMER`	Free timer resource
`LIB$FREE_VM`	Free virtual memory
`LIB$FREE_VM_64`	Releases 64-bit virtual memory
`LIB$FREE_VM_PAGE`	Frees a virtual memory page
`LIB$FREE_VM_PAGE_64`	Frees a 64-bit virtual memory page
`LIB$GET_COMMAND`	Retrieves the current command input
`LIB$GET_COMMON`	Get common block data
`LIB$GET_EF`	Get event flag
`LIB$GET_FOREIGN`	Get foreign command
`LIB$GET_HOSTNAME`	Retrieves the system's hostname
`LIB$GET_INPUT`	Get input from user
`LIB$GET_LOGICAL`	Get logical name
`LIB$GET_LUN`	Get logical unit number
`LIB$GET_SYMBOL`	Get symbol value
`LIB$GET_VM`	Get virtual memory
`LIB$GET_VM_64`	Allocates 64-bit virtual memory
`LIB$GET_VM_PAGE`	Allocates a virtual memory page
`LIB$GET_VM_PAGE_64`	Allocates a 64-bit virtual memory page
`LIB$GETDVI`	Get device information
`LIB$GETJPI`	Get job process info
`LIB$GETQUI`	Retrieves queue information synchronously
`LIB$GETSYI`	Get system info
`LIB$INDEX`	Find index in string
`LIB$INIT_DATE_TIME_CONTEXT`	Initialize date-time context
`LIB$INIT_TIMER`	Initialize timer
`LIB$INSERT_TREE`	Insert item in tree
`LIB$INSQHI`	Insert queue head
`LIB$INSQTI`	Insert queue tail
`LIB$INSV`	Insert bit field
`LIB$LEN`	Get string length
`LIB$LOCC`	Finds the first occurrence of a character in a string
`LIB$LOOKUP_TREE`	Lookup in tree structure
`LIB$MATCH_COND`	Match condition
`LIB$MATCHC`	Match characters
`LIB$MOVC3`	Move characters
`LIB$MOVC5`	Move characters with fill
`LIB$MOVTC`	Move and transform characters
`LIB$MULT_DELTA_TIME`	Multiplies delta time values
`LIB$MULTS_DELTA_TIME`	Multiplies scaled delta time values
`LIB$PUT_BUFFER`	Write to buffer
`LIB$PUT_COMMON`	Write to common block
`LIB$PUT_LINE`	Outputs a formatted line of text
`LIB$PUT_OUTPUT`	Write output
`LIB$PUT_SCREEN`	Write to screen
`LIB$RADIX_POINT`	Get radix point
`LIB$REMOVE_TREE`	Removes an entry from a balanced tree structure
`LIB$REMQHI`	Remove queue head
`LIB$REMQTI`	Remove queue tail
`LIB$RENAME_FILE`	Rename a file
`LIB$RESET_VM_ZONE`	Resets a virtual memory zone
`LIB$RESET_VM_ZONE_64`	Resets a 64-bit virtual memory zone
`LIB$REVERT`	Revert to previous state
`LIB$RUN_PROGRAM`	Run a program
`LIB$SCANC`	Scan for characters
`LIB$SCOPY_DXDX`	Copy descriptor data
`LIB$SCOPY_R_DX`	Copies a descriptor-based string with right justification
`LIB$SCREEN_INFO`	Get screen info
`LIB$SET_BUFFER`	Set buffer contents
`LIB$SET_CURSOR`	Set cursor position
`LIB$SET_LOGICAL`	Set logical name
`LIB$SET_SCROLL`	Configures display scrolling settings
`LIB$SET_SYMBOL`	Set symbol value
`LIB$SFREE1_DD`	Frees a dynamically allocated descriptor
`LIB$SGET1_DD`	Retrieves a dynamically allocated descriptor
`LIB$SHOW_TIMER`	Displays system timer settings
`LIB$SHOW_TIMER_`	Displays system timer settings (alternative version)
`LIB$SHOW_VM`	Displays virtual memory details
`LIB$SHOW_VM_ZONE`	Displays information about a virtual memory zone
`LIB$SHOW_VM_ZONE_64`	Displays information about a 64-bit virtual memory zone
`LIB$SIG_TO_RET`	Converts a signal code to a return status
`LIB$SIG_TO_STOP`	Converts a signal to a process stop action
`LIB$SIGNAL`	Send signal
`LIB$SKPC`	Skip characters
`LIB$SPANC`	Span characters
`LIB$SPAWN`	Spawn subprocess
`LIB$STAT_TIMER`	Retrieves statistics for system timers
`LIB$STAT_VM`	Retrieves virtual memory statistics
`LIB$STOP`	Stop execution
`LIB$SUB_TIMES`	Subtract time values
`LIB$SUBX`	Subtract values
`LIB$SYS_ASCTIM`	Convert time to ASCII
`LIB$SYS_FAO`	Format output message
`LIB$SYS_FAOL`	Format output
`LIB$SYS_GETMSG`	Get system message
`LIB$SYS_TRNLOG`	Translate logical name
`LIB$TRA_ASC_EBC`	Translate ASCII to EBCDIC
`LIB$TRA_EBC_ASC`	Translate EBCDIC to ASCII
`LIB$TRIM_FILESPEC`	Trims a file specification string
`LIB$WAIT`	Wait for event

Implementation status

The overwhelming majority of LIB$ routines are fully implemented and exercised. A small number of advanced virtual-memory options are partially covered, and a set of rarely used routines is not yet implemented. The table summarises the state of each area so a migration can be scoped accurately.

Capability area	Status	Notes
Core string, arithmetic, tree, queue, time, symbol, file and screen routines	live	Full implementations, built into the VX runtime library.
CRC checksums and character translation	live	`LIB$CRC`, `LIB$CRC_TABLE`, and the ASCII and EBCDIC translation routines.
Basic virtual-memory allocation and zones	live	`LIB$GET_VM`, `LIB$FREE_VM`, and standard zone create, delete, find and reset.
Advanced VM-zone options and 64-bit high-address handling	partial	Custom zone algorithms, alignment, page limits, user get and free-page callbacks, and full 64-bit quadword address handling are being completed.
Signal-handler dispatch for `LIB$STOP` and `LIB$SIG_TO_RET`	partial	Signalling works; some handler-unwind paths are being finalised.
Rarely used routines (for example `LIB$VERIFY_VM_ZONE`, `LIB$CREATE_USER_VM_ZONE`)	not yet implemented	A set of low-usage entry points is declared but not yet implemented. Sector7 prioritises these on demand as migrations require them.

Migration sizing. When scoping a port, check your application's actual LIB$ call inventory against this matrix. Anything in the "not yet implemented" set that your code depends on can be prioritised as part of the engagement.

Quick reference

Key facts

Item	Value
Public entry points	Over 150 `LIB$` routines
Delivery	Linked into the application via `libvxrt.a`
Platforms	x86 and ARM Linux, through VX/RT
Success test	Odd condition code (`status & 1`), not equality
String passing	By descriptor; 32-bit and 64-bit layouts both accepted
Descriptor classes	Static (1), Dynamic (2), Varying (11), Scaled decimal (9)
Time base	64-bit quadword, 100-ns ticks from the 1858-11-17 epoch

Name forms

LIB$INDEX

lib$index

LIB_D_INDEX

Fortran thunk

String and character routines

LIB$INDEX

LIB$LEN

LIB$LOCC

LIB$MATCHC

LIB$SCANC

LIB$SKPC

LIB$SPANC

LIB$MOVC3

LIB$MOVC5

LIB$MOVTC

LIB$SCOPY_DXDX

LIB$ANALYZE_SDESC

Date and time routines

LIB$DATE_TIME

LIB$DAY

LIB$DAY_OF_WEEK

LIB$ADD_TIMES

LIB$SUB_TIMES

LIB$MULT_DELTA_TIME

LIB$CVT_DTB

LIB$FORMAT_DATE_TIME

Virtual-memory routines

LIB$GET_VM

LIB$FREE_VM

LIB$GET_VM_PAGE

LIB$CREATE_VM_ZONE

LIB$DELETE_VM_ZONE

LIB$FIND_VM_ZONE

LIB$RESET_VM_ZONE

LIB$STAT_VM

System and process routines

LIB$GETDVI

LIB$GETJPI

LIB$GETSYI

LIB$SPAWN

LIB$RUN_PROGRAM

LIB$DO_COMMAND

LIB$GET_SYMBOL

LIB$SYS_FAO

On this page

Architecture and linkage

Link model

Naming, linkage and calling conventions

Condition-code convention

Quadwords and VMS time

Routine groups

VX/LIB$ callable routines

Implementation status

Quick reference

Key facts

Name forms

String and character routines

Date and time routines

Virtual-memory routines

System and process routines

Frequently Asked Questions

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

Free Code Assessment

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

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.

Which OpenVMS LIB$ functions does VX/LIB$ support?

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

Does VX/LIB$ maintain OpenVMS compatibility on Linux?

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

How does VX/LIB$ handle memory management operations?

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.

What string and character processing capabilities does VX/LIB$ offer?

VX/LIB$ provides extensive string manipulation functions including LIB$INDEX for finding substrings, LIB$LEN for length calculations, and character operations like LIB$MOVC3 and LIB$SCANC. It also supports string descriptor analysis through LIB$ANALYZE_SDESC and advanced pattern matching capabilities.

Organizations like Telstra have successfully utilized similar string processing functions during their OpenVMS to Linux migrations, maintaining application functionality while modernizing their infrastructure.

Can VX/LIB$ integrate with other VX tools?

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

What time and date functions are available in VX/LIB$?

VX/LIB$ includes comprehensive time management functions such as LIB$DATE_TIME for current timestamps, LIB$CVT_DTB for date-to-binary conversion, and LIB$ADD_TIMES for time arithmetic. Additional capabilities include LIB$DAY_OF_WEEK calculations and LIB$FORMAT_DATE_TIME for custom formatting requirements.

What are the key advantages of using VX/LIB$ for OpenVMS migration?

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.

What is VX/LIB$?

VX/LIB$ is a call-compatible implementation of the OpenVMS LIB$ general-purpose utility routines for x86 and ARM Linux. It lets OpenVMS applications keep using LIB$ string, math, time, and system routines while running on Linux, preserving existing logic and execution behavior.

How many LIB$ routines does VX/LIB$ implement?

VX/LIB$ implements over 150 callable LIB$ routines, spanning string handling, integer and extended arithmetic, date and time conversion, virtual-memory management, descriptor operations, screen and terminal control, queues, balanced trees, and system utilities.

Which CPU architectures and operating systems does VX/LIB$ run on?

VX/LIB$ targets x86 and ARM Linux. It integrates with VX/RT to provide the full OpenVMS LIB$ utility functionality on those platforms.

Do I have to modify my application code to use VX/LIB$?

No major modifications are required. VX/LIB$ maintains OpenVMS application logic and is call-compatible with the LIB$ APIs, so applications that rely on LIB$ routines can be migrated without rewriting their calling logic.

Does VX/LIB$ handle OpenVMS virtual-memory zone management?

Yes. The routine set includes virtual-memory zone management, including creating, deleting, finding, resetting, and reporting zones, in both 32-bit and 64-bit forms, for example LIB$CREATE_VM_ZONE and LIB$CREATE_VM_ZONE_64, LIB$GET_VM and LIB$GET_VM_64, and LIB$FREE_VM and LIB$FREE_VM_64.

What date and time capabilities are included?

VX/LIB$ covers current date and time (LIB$DATE_TIME), time arithmetic (LIB$ADD_TIMES, LIB$SUB_TIMES, LIB$MULT_DELTA_TIME), conversions to and from the system internal time format, day-of-week calculation (LIB$DAY_OF_WEEK), and formatting (LIB$FORMAT_DATE_TIME).

Can VX/LIB$ perform checksums and character translation?

Yes. It includes CRC checksum routines (LIB$CRC, LIB$CRC_TABLE) and character-translation utilities, including ASCII and EBCDIC conversion (LIB$TRA_ASC_EBC, LIB$TRA_EBC_ASC), alongside the broader string routines such as LIB$INDEX, LIB$LEN, LIB$MATCHC, and LIB$SCANC.

How does VX/LIB$ fit into the wider VX toolset?

VX/LIB$ integrates with VX/RT, the VX runtime, to deliver OpenVMS LIB$ utility services as part of a broader OpenVMS-compatibility environment on x86 and ARM Linux, so LIB$-dependent applications migrate alongside the rest of a VX-based port.

Transform Your Legacy Software Today!

Get In Touch

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