UBASIC

UBASIC is what happens when a working number theorist decides that the computer on his desk should be able to do arithmetic properly, and writes the whole interpreter in assembly language himself. It is a line-numbered, thoroughly ordinary-looking BASIC for MS-DOS in which PRINT 23^45 prints all sixty-two digits, POINT 21 sets the fractional part of every fixed-point number to a hundred-odd decimal places, and PRMDIV, KRO, MOB and EUL are built-in functions rather than a library you have to find. Between the late 1980s and the late 1990s it was, for a large number of mathematicians, simply how you computed on a personal computer.

The catalogue entry that brings most people here spells it “UBasic” and dates it to 1988. The spelling the author used is UBASIC, and originally UBASIC86 - the “86” for the Intel 8086 family in the NEC PC-9801 it was born on. The year needs a footnote too, and the footnote is in Kida’s own hand.

Origins: two years before anyone heard of it

Yuji Kida is a number theorist known for work on Iwasawa invariants of algebraic number fields and later for factoring cyclotomic numbers with the number field sieve. He is usually described as a Rikkyo University man, and by the time UBASIC had a home page that is what he was - but he only moved to Rikkyo in 1991. Through the years UBASIC was actually written he was at Kanazawa University, and Kanazawa is the affiliation printed on the article that first announced it. In late 1988 he published a five-page article in Sugaku, the journal of the Mathematical Society of Japan, under the title “UBASIC, a personal-computer programming language for calculating with large numbers easily” (vol. 40 no. 4, pages 344-348; J-STAGE records the issue date as 14 November 1988). It is the earliest datable record of the language, and it is also the best account of why it exists.

Kida’s complaint, in the opening section, is that mathematicians had by then acquired personal computers and stopped using them to compute. Word processing, yes; arithmetic, no. Part of the reason was that mathematics had less need of computation than it once had, but the larger part, he argued, was that the machines and their software did not fit what mathematicians actually wanted. The concrete example he gives is exactly the one his language solves: current software approximates numbers to a precision assumed to be enough, which is useless for integer work where the last digit has to be right, and hopeless if you want a thousand digits of pi. Anyone who has written a 1,000-digit pi program from a BASIC primer, he notes drily, will remember how tiresome it was.

The available alternatives he dismisses one by one. Computer algebra on a mainframe is a high threshold for people who only came to computing because personal computers made it approachable, and you lose the thing that makes BASIC comfortable - moving the cursor to a line, changing it, running it again. Systems like REDUCE had begun to run on personal computers, but on the machines people actually owned the memory was far too tight and the price too high to recommend to anyone. Using a computer algebra system purely for numerical work felt, he wrote, like overkill. And bignum arithmetic in LISP raised the obvious objection: why should someone who wants to do arithmetic have to learn all those incomprehensible parentheses first?

What was wanted was a compact, fast language that did nothing but numbers, and that is what UBASIC was. By the time of the article the interpreter had been running for a full two years - which puts its first working version at around 1986 - and already had users in the United States, Britain and Germany. The first commercially published manual, two years later still, is for version 8.1.

He was aware of one precedent. In France, he notes, a system of this kind had been built as early as 1979 as a project of the CNRS, elegantly named ISABELLE, introduced to Japanese readers by Kenji Nagasaka in bit magazine in July 1982. He mentions it as something that existed, not as a model; the United States, Britain and Germany, he adds, had nothing of the sort, probably because American networks put a terminal everywhere and made mainframe computer algebra easy to reach.

Design philosophy: BASIC because BASIC

Kida’s own introductory blurb for the language, reproduced in 1996 on a page maintained by Aiichi Yamasaki at Kyoto University, is unusually candid about why the syntax is what it is:

UBASIC86 is a language made out of that requirement. Its form conforms to ordinary BASIC so that anyone can use it. BASIC is, as the specialists point out, a language with bad habits and real problems, but for non-specialists the fact that it is easy to learn and, once learnt, never forgotten - is there enough in it to forget? - is worth more than anything. And for those of us who only write short programs, its defects do not come up much. Of course there is also my own convenience: it is easy to build a language like this.

That is the whole philosophy. The novelty is not in the language; it is in the number system underneath it, and in the decision to make that number system the default rather than an add-on. Three consequences follow.

No floating point, on purpose. The 1988 language had fixed-point decimals only. Kida’s stated reasons: floating point is a nuisance to implement; his own calculations never produce exponents like Planck’s constant or Avogadro’s number, so fixed point suffices; and convergence tests and error estimates in series computations are simpler without it. He then asks the question that settles it - what would you actually use a floating-point number with a 1,000-digit mantissa for?

Exactness where BASIC was sloppy. He singles out the square root SQR, which in UBASIC returns exactly the nearest value from below, against ordinary BASICs where the square root of the square of a number in the hundreds might not come back as the number you started with. Integer powers are likewise exact, where a conventional BASIC implements ^ through EXP and LOG and cannot avoid error.

The remainder is free. Alongside the four arithmetic operations, UBASIC provides remainder and exact integer power, and after an integer division the remainder is already sitting in a system variable - no need to compute it again. As Kida notes, this is used constantly in number theory.

The language

In the 1988 version, the numeric ceiling was a little over 5,500 decimal digits, for both integers and the fractional parts of fixed-point numbers, the latter set by the POINT command. Variables came in three flavours - 16-bit short variables, long variables whose length the programmer specifies up to the maximum, and fixed-maximum special variables - each with an array form, with no 64 KB limit on a single array. Number-theoretic functions were in the box: gcd, the Kronecker symbol KRO, the Moebius function MOB, Euler’s totient EUL, and PRMDIV for trial division.

The article is equally frank about what was wrong, closing with a list of things that had to be improved: only two characters allowed in a variable name (“two generations behind the state of the art even in the personal computer world”), no local variables, no function subroutines, no way to pass arguments to a subroutine. All of these were fixed in the version 8 line, which is the UBASIC most people encountered: local variables and parameters passed by value or by name, subroutines and user functions passable as parameters themselves, exact rational arithmetic, complex numbers, strings, and single-variable polynomials with complex, rational or mod-p coefficients. By 1993 the practical limits, as quoted by chemists at Kida’s own university, were 2,600 digits for integers and reals and 1,300 for complex and rational numbers; Kida’s own download page described the language as suited to integers up to 2,700 digits.

Here is the flavour, taken from the 1988 article - a naive series for e, summing 1/n! until the term underflows the declared precision:

1
2
3
4
5
6

20 E=0:W=1:N=0
30 E=E+W
40 N=N+1
50 W=W/N
60 if W>0 then goto 30
70 print E

With POINT set to 21 words - 101 decimal digits - this printed e to a hundred places. Kida records the run as taking 0.07 seconds including the time to display the result, on an 80286 at 16 MHz, and then points out that you did not need the program anyway, because EXP is built in.

The interactive side was as important as the language. UBASIC’s editor could cross-reference the lines that call a given line or mention a given variable, renumber, rename variables, append programs, trace, single-step and time sections to the millisecond, and redefine function keys. FREEZE wrote a running program and its data to a file and MELT brought it back, which for computations measured in days mattered a great deal - as did the plain fact that in an interpreter you can edit a program mid-run and resume it with GOTO without losing what you have accumulated.

Under the hood: assembly, all of it

The version 9 sources, released to the public domain on GitHub in December 2022 by a user who had asked Kida for them in 2014, settle the question of how UBASIC was built. There are 41 files and about 1.14 MB of them, and they are x86 assembly without exception: FLOAT.ASM, POLYNOMI.ASM, RATIONAL.ASM, COMPLEX.ASM for the numeric tower, MAINLP.ASM, JUMP.ASM, COMPILE.ASM, FORMULIN.ASM for the interpreter, EMA32.ASM for extended memory, vga16.asm and graph.asm for graphics, FREZMELT.ASM for freeze and melt. The person who published them adds a note that Kida had been planning a newer version in C or C++, but that he had never seen it.

This is also why UBASIC exists in so many builds. Each release came in seven flavours - DOS/V in 16- and 32-bit, Fujitsu FMR in 16- and 32-bit, NEC PC-98 in 16- and 32-bit, and a CGA build for the HP 200LX palmtop - and the 16 and 32 in those labels refer to the width of the multiplication engine, not to the host processor. The download page listed each of them at between about 103 KB and 111 KB, depending on build and release.

Release history and the long decline

Kida’s download page, preserved in the Wayback Machine, is the release log: version 8.8c on 15 April 1998, 8.8e on 14 December 1999, and 8.8f on 8 October 2000, which turned out to be the end. Between the last two came the add-ons the factoring crowd wanted - PPMP, a multiple-polynomial quadratic sieve, v3.6 on 24 December 1999, and a number field sieve program v1.8 on 31 January 2000, the latter requiring the never-released version 9.

The site’s own bug notices give a sense of the maintenance rhythm: a FOR-NEXT bug documented on 13 July 1997, a page on running under Windows NT 3.51 and 4.0 dated 20 October 1996, and a cheerful admission on 1 January 2000 that the language everyone had assumed was immune to the millennium problem in fact printed the date as “20 0/ 1/ 1”, a missing zero, fixed nine months later in 8.8f. There was also a benchmark page comparing UBASIC across the processors of the day, whose title grew with each revision - “P5, P6, K6, PII, Celeron and K6-2” in November 1998, “P5, P6, Celeron, K6-2, MII, K6-III, PIII and Athlon” a year later, and “PIII, K7, Coppermine and Thunderbird” by November 2000 - which is the kind of thing an author only does when people are running his software on everything.

The last sign of life is a short page of 5 April 2010 on running UBASIC under Windows Vista and 7: add kb16 jp,932,key01.sys to the end of windows\system32\autoexec.nt to get the Japanese keyboard layout back, prefix the command with command/c to keep the display in Japanese, and, for 64-bit Windows, install a virtualisation layer - because 64-bit editions of Windows dropped the 16-bit subsystem UBASIC depends on. That is the wall UBASIC hit, and it is a hardware-and-OS wall rather than a mathematical one.

Reception outside Japan

UBASIC travelled early. The 1988 article already reports confirmed users in the United States, Britain and Germany. Distribution abroad was by anonymous FTP, with separate Japanese and international (IBM PC) builds, and the international builds were picked up by the general MS-DOS mirrors - Simtel carried a ubasic directory for years. In May/June 1989 Walter D. Neumann reviewed it for the Notices of the American Mathematical Society under the title “UBASIC: A public-domain Basic for mathematics” (volume 36, number 5, pages 557-559), returning to it with “UBASIC Update” in the March 1991 Notices (volume 38, number 3, pages 196-197) - the kind of notice that put a Japanese freeware interpreter on the desk of number theorists worldwide.

Its most visible legacy outside Japan is APRT-CLE. Implementing the Adleman-Pomerance-Rumely primality test in the Cohen-Lenstra formulation published in Mathematics of Computation in 1987, it made rigorous primality proofs of several-hundred-digit numbers a thing you did on a PC while doing something else. Dubner and Granlund’s 2000 survey is a fair snapshot of how it was used in practice: everything below about 800 digits proved with APRT-CLE, whose upper test limit they give as about 830 digits, and everything above it handed to Tony Forbes’s VFYPR, itself an extension of the UBASIC program. VFYPR, they report on Forbes’s own authority, ran about twice as fast and could reach 1600 digits; a 1200-digit test cost roughly 40 hours on a Pentium/500, and 1200 digits is where they stopped, for want of machine time rather than headroom.

Running UBASIC today

There is no Docker image, and a container would not help: UBASIC is a real-mode MS-DOS program. The realistic routes are DOSBox or a DOS virtual machine, or a 32-bit Windows installation, where it still runs in a command prompt with the workarounds from Kida’s 2010 page. Kida’s own site stopped answering years ago, but the Japanese software archive Vector still carries DOS/V and English IBM-PC builds, in 16- and 32-bit, along with the help file and the sample programs - uploaded by Kida himself, under the handle ykida, and dated in Vector’s listing to 7 January 1999 - and the version 9 assembly sources are on GitHub in the public domain for anyone who wants to see how it was done, or to finish the C rewrite Kida never shipped.

Modern practice has, in fairness, moved on. PARI/GP, which arrived from Bordeaux in the same era and did not stop, occupies the niche UBASIC was built for, and Primo and open-source APR-CL and ECPP implementations long ago passed the ranges APRT-CLE could reach. UBASIC’s presence in today’s code-sharing culture is correspondingly thin: Rosetta Code has a UBASIC category with exactly one task in it, the Haversine formula.

Why it matters

UBASIC is the strongest counter-example to the assumption that a domain-specific computing environment has to be a new language. Kida changed nothing about BASIC that a 1980s hobbyist would notice, and changed everything about the numbers underneath it, and the result was a tool that people who had never programmed at all could use “with roughly the ease of a calculator” - his phrase - to compute class numbers and Hecke polynomials. Familiar syntax was the delivery mechanism; exact arithmetic was the product.

It is also a reminder of how much one person could still build alone in that era, and how completely a platform can take a language down with it. A single mathematician wrote a multiple-precision arithmetic engine, an interpreter, a full-screen editor and a graphics library in x86 assembly, gave them away, and supported them for the better part of two decades. What ended UBASIC was not a better BASIC or a lost argument about language design. It was Microsoft removing the 16-bit subsystem from 64-bit Windows.