UniVerse Basic

UniVerse Basic (styled UniVerse BASIC in Rocket Software’s documentation, and often just “MV BASIC” or “U2 Basic” in the community) is the procedural programming language of the UniVerse MultiValue database. Created by VMark Software in the mid-1980s as part of the first Pick-style environment delivered as a software layer on Unix, it pairs approachable BASIC syntax with language-level operations on the nested, multivalued records of the Pick data model. Four decades and four changes of corporate ownership later, it remains a living commercial language: Rocket Software shipped UniVerse 14.2.1 in November 2025 with new BASIC-level exception handling and JSON features, and applications written in UniVerse BASIC still run order entry, inventory, and accounting for businesses around the world.

Naming note: UniVerse Basic should not be confused with UniBasic, the closely related but distinct BASIC dialect of the sibling UniData database. The two languages have been stablemates since the 1998 VMark–Unidata merger and share the Pick/BASIC heritage, but they evolved separately and retain separate compilers, manuals, and quirks.

History & Origins

The Pick Heritage

UniVerse Basic descends from the Pick system, whose roots go back to 1965, when Don Nelson and Dick Pick began work at TRW on the Generalized Information Retrieval Language System (GIRLS) for a US Army helicopter inventory project. The technology became commercial in 1973 as the Microdata Reality Operating System, and in 1975 Ken Simms of Pick Systems gave the platform its programming language: an implementation of Dartmouth BASIC extended with terminal and database operations, known as Data/BASIC and later Pick/BASIC. Its central innovation was making the language’s native data structure — the dynamic array — the same delimited-string format the database stored, so programs manipulated records in exactly the shape the system kept them.

Through the late 1970s and 1980s the Pick design spread across an industry of compatible implementations, each with its own BASIC dialect. One of the most important was INFORMATION, written in 1979 by Devcom for Prime minicomputers and sold to Prime Computer as Prime INFORMATION; its INFO/BASIC variant would figure prominently in UniVerse’s later history.

VMark and the Software Pick

VMark Software, founded in 1984 in Massachusetts, took the step that defined UniVerse: instead of building a Pick machine or a licensed port of the Pick operating system, VMark implemented the MultiValue environment as a native application on top of Unix (and later Windows). UniVerse — brought to market around 1985, though some references date the first release to 1987 — was also the first implementation designed to emulate other members of the Pick family, including Microdata’s Reality and Prime INFORMATION. That emulation strategy is baked into the language itself: UniVerse accounts run in compatibility “flavors,” and UniVerse BASIC adjusts its behavior — default file-handling semantics, statement variants, intrinsic quirks — to match the dialect an application was originally written for.

The strategy made UniVerse a consolidation point for the fragmenting Pick market. After VMark acquired the rights to Prime INFORMATION and its successor PI/open, UniVerse shipped a PI/open flavor with source-level INFO/BASIC compatibility (reportedly in release 8.3, together with an INFO/BASIC decompiler), and the Prime INFORMATION user base migrated to UniVerse as Prime’s hardware business wound down.

The Corporate Odyssey

Like its sibling UniBasic, UniVerse Basic has survived a remarkable chain of ownership while remaining essentially the same language:

At every transition, the installed base of UniVerse BASIC applications was too valuable to disrupt, so each new owner kept the language alive and compatible — the quiet economic force behind most of the durable languages in this encyclopedia.

Design Philosophy

The Data Model Is the Language

UniVerse Basic’s defining idea, inherited from Pick/BASIC, is that the language’s core data structure is the database’s storage format. A UniVerse record is a single delimited string: attribute marks separate fields, value marks separate multiple values within a field, and subvalue marks nest a third level. UniVerse BASIC reads a whole record into a variable with one READ statement and addresses any piece of it with angle-bracket extraction — REC<3,2> is the second value of the third field. There is no mapping layer and no impedance mismatch between program and database.

Compatibility as a First-Class Concern

What most distinguishes UniVerse Basic from other Pick-family BASICs is its flavor system. Because UniVerse was built to absorb applications from Reality, Prime INFORMATION, and other Pick variants, the compiler and runtime support account-level flavors and per-program $OPTIONS directives that switch dialect behavior. A program written for a Microdata machine in 1980 and a program written natively for UniVerse can run side by side, each getting the semantics its original platform promised. Backward compatibility is treated as close to absolute: decades-old source generally still compiles and runs on current releases.

Key Features

• Dynamic arrays — variable-length, delimiter-structured strings addressed with <field, value, subvalue> syntax, mirroring database records exactly, with intrinsics such as INSERT, DELETE, LOCATE, and DCOUNT for manipulating them
• Native MultiValue file I/O — OPEN, READ, WRITE, and locking variants (READU, WRITEU) operate directly on hashed database files with record-level locks
• Conversion processing — ICONV and OCONV apply the same conversion codes used by the RetrieVe query language for dates, times, and formatted numbers
• Select lists — programs consume lists of record IDs produced by RetrieVe queries, the idiomatic MultiValue batch-processing pattern
• Modular applications — CALL invokes separately compiled, cataloged subroutines sharing state through named COMMON, supporting systems built from thousands of programs
• Environment integration — EXECUTE runs any command from the UniVerse command environment inside a program and captures its output
• Compatibility flavors — account flavors and $OPTIONS switch dialect semantics for Pick, Reality, INFORMATION/PI:open, and native UniVerse behavior
• Modern extensions — current releases integrate with Python in both directions, expose BASIC subroutines as REST APIs through the MultiValue Integration Server, and (since UniVerse 14.2.1) add try/catch exception handling and native JSON manipulation via Dynamic Objects

Code Example

A small UniVerse BASIC program showing the signature dynamic-array style — reading a customer record and walking a multivalued list of order numbers:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

* List a customer's orders from a MultiValue record
OPEN 'CUSTOMERS' TO CUST.FILE ELSE STOP 'Cannot open CUSTOMERS file'

READ CUST.REC FROM CUST.FILE, '1001' THEN
   CUST.NAME = CUST.REC<1>
   ORDER.COUNT = DCOUNT(CUST.REC<3>, @VM)
   PRINT 'Customer: ':CUST.NAME
   FOR I = 1 TO ORDER.COUNT
      PRINT '   Order: ':CUST.REC<3,I>
   NEXT I
END ELSE
   PRINT 'Customer 1001 not found'
END

Field 1 of the record holds the customer’s name; field 3 holds every order number as multiple values within a single field — the MultiValue answer to what a relational schema would model as a joined orders table. The @VM system variable is the value-mark delimiter itself, available to programs as a first-class constant.

Evolution

UniVerse Basic’s evolution has been steady modernization around an intentionally stable core. The VMark years established the flavor system and absorbed the Prime INFORMATION world; they also produced an unexpected offshoot when VMark built the DataStage ETL tool on the UniVerse engine in 1996 — classic DataStage server jobs are written in a UniVerse BASIC dialect, which carried the language into data-warehouse projects far outside the Pick community. The Ardent and IBM eras added client/server APIs (UniObjects), ODBC/JDBC access, and web enablement.

Under Rocket Software the pace has continued: native Python integration was announced for the UniVerse 11.3 series in late 2016 and has shipped in every release since (UniVerse 12.2.1, released in June 2023, bundles Python 3.9), giving MultiValue shops a mainstream second language against the same data. Rocket also ships a free MV BASIC extension for Visual Studio Code and an AI-assisted MultiValue Developer Assistant for generating and explaining MV BASIC code. The UniVerse 14 generation — 14.2.1 arrived in November 2025 — brought the language its most significant syntax additions in years: a structured try/catch error-handling mechanism and native JSON support through Dynamic Objects.

Current Status

UniVerse Basic is a living commercial language. Rocket UniVerse is actively sold, supported, and enhanced on current Unix, Linux, and Windows server platforms per Rocket’s documentation, and a dedicated MultiValue community of user groups, forums, and specialist consultancies maintains substantial UniVerse BASIC codebases. The most visible deployment is Epicor Eclipse, the distribution ERP whose UniVerse BASIC business logic processes orders for electrical, plumbing, and HVAC wholesalers across North America. There is no official Docker image — UniVerse is a licensed commercial product installed through Rocket’s platform-specific installers rather than distributed as a public container.

Why UniVerse Basic Matters

UniVerse Basic is the language that proved the Pick world could outlive Pick machines. By reimplementing the MultiValue environment as portable software and absorbing rival dialects through its flavor system, UniVerse consolidated a fragmented 1980s minicomputer ecosystem onto commodity Unix — and its BASIC preserved, rather than obsoleted, the applications that ecosystem had produced. The data model it exposes so directly — schema-light, nested, delimiter-structured records — anticipated the document databases of the NoSQL era by decades. And its forty-year run through five owners, an ETL industry cameo via DataStage, and a present that includes Python interop, REST APIs, JSON objects, and AI-assisted tooling make it one of the clearest case studies in how business software actually endures: not by rewrites, but by a language that refuses to break its promises.