UniBasic

UniBasic is the procedural programming language of the UniData MultiValue database, created by Unidata, Inc. of Denver, Colorado in the mid-1980s. A member of the Pick/BASIC family, UniBasic combines the approachable syntax of BASIC with language-level operations on the nested, multivalued records that define the Pick data model. For four decades it has been the workhorse language behind vertical business applications — most visibly the Ellucian Colleague ERP used throughout higher education — and it remains actively maintained today as part of Rocket Software’s U2 product family.

Naming note: This page covers the UniBasic of the UniData database (today Rocket UniData). An unrelated business BASIC also named UniBasic, from Dynamic Concepts, Inc., dates from the same era and serves a similar business-application market but is a distinct language with a separate lineage.

History & Origins

The Pick Heritage

UniBasic descends from the Pick system, the pioneering MultiValue database environment developed by Dick Pick in the late 1960s at TRW. Pick organized data as hashed files of delimited records in which a single field could hold multiple values — a “NoSQL” design decades before the term existed — and included DATA/BASIC (Pick/BASIC), a BASIC dialect whose native data structure was the dynamic array mirroring that record format. The combination proved remarkably productive for business data processing, and through the 1970s and 1980s an entire industry of Pick-compatible platforms emerged.

Unidata, Inc.

Unidata, Inc. was founded in Denver, Colorado in the mid-1980s — most sources cite 1985, while some company directories list 1986 — to bring the Pick data model to standard Unix operating systems rather than a proprietary Pick machine. The resulting UniData database paired Pick-style hashed files and query tools with a BASIC-family language, UniBasic, and was designed from the start for embedding inside vertical software applications: independent software vendors wrote packaged accounting, distribution, and administrative systems in UniBasic and shipped them with UniData underneath.

The strategy worked. By June 1997, when Unidata announced a technology alliance with Microsoft, the company described itself as a worldwide manufacturer of data management solutions with roughly 400 value-added resellers and more than 500,000 end users.

The Corporate Odyssey

Few languages have changed corporate hands as many times as UniBasic while remaining essentially the same product:

The 1998 merger was notable for what it did not do: VMark’s UniVerse and Unidata’s UniData were direct competitors, yet Ardent — and every owner since — kept both databases and both BASIC dialects (UniVerse BASIC and UniBasic) alive as separate products, because each carried an installed base of applications too valuable to disrupt. That decision is why UniBasic still exists as a distinct language today.

Design Philosophy

The Data Model Is the Language

UniBasic’s defining idea, inherited from Pick/BASIC, is that the language’s core data structure — the dynamic array — is the same structure the database stores. A UniData record is a single delimited string in which attribute marks separate fields, value marks separate multiple values within a field, and subvalue marks nest further still. UniBasic reads such a record into a variable with one 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 object-relational mapping layer, no cursor, and no impedance mismatch — the program manipulates records in exactly the shape the database keeps them.

Pragmatism over Purity

Like other Business BASIC descendants, UniBasic is unapologetically practical. Variables are dynamically typed and freely convert between strings and numbers; a rich library of intrinsic functions (ICONV/OCONV for input and output conversions of dates, times, and formatted numbers, DCOUNT for counting delimited values, LOCATE for searching dynamic arrays) targets the everyday chores of business data processing. Programs are compiled with the BASIC command into object code executed by the UniData runtime, and they interoperate directly with the environment’s query language (UniQuery) and command environment (ECL).

Key Features

• Dynamic arrays — variable-length, delimiter-structured strings addressed with <field, value, subvalue> syntax, mirroring UniData records exactly
• Native MultiValue file I/O — OPEN, READ, WRITE, READU/WRITEU with record-level locking against hashed database files
• Conversion processing — ICONV and OCONV apply the same conversion codes used by the query language for dates, times, and masked numeric formats
• Select lists — programs consume lists of record IDs produced by database queries, the idiomatic MultiValue batch-processing pattern
• External subroutines and common blocks — CALL and named COMMON support large modular applications built from thousands of compiled programs
• Environment integration — EXECUTE runs ECL commands and queries from within a program, capturing their output
• Modern connectivity — current releases expose UniBasic logic to the outside world through UniObjects, ODBC/JDBC, REST services, and interoperate with the Python runtime that ships in UniData 8.3.x

Code Example

A small UniBasic program showing the signature dynamic-array syntax — 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 'CUSTOMER' TO CUST.FILE ELSE STOP 'Cannot open CUSTOMER 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 name; field 3 holds every order number the customer has ever placed, as multiple values in one field — the MultiValue answer to what a relational design would model as a joined orders table.

Evolution

UniBasic’s evolution has been one of steady modernization around a stable core. Under Unidata and Ardent, the platform gained SQL access, ODBC connectivity, and client APIs so UniBasic applications could participate in client/server architectures. The IBM years brought the U2 branding, web-enablement tooling, and continued platform ports. Since 2009, Rocket Software has kept the platform current: UniData 8.2.2 arrived in September 2020, 8.2.4 in August 2022, and UniData 8.3.1 in February 2024, upgrading to OpenSSL 3.0 and bundling Python 3.11 alongside UniBasic so shops can mix the two languages against the same database. Rocket also ships an MV BASIC extension for Visual Studio Code, giving a 1980s language syntax highlighting, code completion, and modern editor tooling.

Through all of it, backward compatibility has been the prime directive: UniBasic source written against UniData in the early 1990s generally still compiles and runs on current releases.

Current Status

UniBasic is a living commercial language. Rocket UniData is actively sold and supported on Unix, Linux, and Windows servers, and the surrounding MultiValue community — user groups, the Rocket community forum, and specialist consultancies — continues to maintain and extend UniBasic codebases. The single most visible deployment is Ellucian Colleague, the higher-education ERP whose application layer is built in UniBasic and the Envision toolset on UniData; administrators and developers at hundreds of institutions still work with UniBasic code daily. There is no official Docker image — UniData is a licensed commercial product installed through Rocket’s platform-specific installers rather than distributed as a public container.

Why UniBasic Matters

UniBasic demonstrates the extraordinary durability of the MultiValue model. The Pick data paradigm it embodies — schema-light, nested, string-delimited records manipulated in a language built for exactly that shape — anticipated by decades the document databases of the NoSQL era. And as a business proposition, UniBasic is a case study in software longevity: a language from a small Denver company that survived a merger, three acquisitions, and the rise and fall of entire industry paradigms, because the applications written in it were too valuable to rewrite. For the historian, it is a direct living link to Dick Pick’s 1960s design; for thousands of businesses and universities, it is simply the language their systems run on — quietly, reliably, four decades on.