Chipmunk BASIC

Chipmunk BASIC is a freeware interpreter for the BASIC programming language, and it is unapologetic about what it is. Its own documentation calls it “an old-fashioned interpreter for the BASIC programming language” - you get a > prompt in a terminal window, you type numbered lines, and you type run. There is no project scaffolding, no build system, no package manager. It is the experience of a 1980s home computer, delivered as a small download that still runs natively on an Apple Silicon Mac.

That combination - a genuinely vintage interface over a genuinely maintained implementation - is what makes it interesting. Chipmunk BASIC is not an emulator and not a museum piece. It is a program written in Pascal at Caltech in the 1980s, machine-translated to C in 1990, ported to the Macintosh in 1992, and updated for Apple’s M1 processors around 2020, by which point almost nothing else in the personal computing world had survived that particular gauntlet unbroken.

History and Origins

Caltech, the HP 9836, and a name

Chipmunk BASIC is named after a computer it no longer runs on. Chipmunk was Hewlett-Packard’s code name for the 9836 workstation, machines that filled Caltech’s computing clusters, and the Chipmunk Tools - a CAD suite developed at Caltech and written in HP Pascal - carried the same name. Dave Gillespie wrote a BASIC interpreter in Pascal, basic.p, for that environment.

Exactly when is not recorded. The documentation that shipped with it carries a 1989 Gillespie copyright notice and the title Chipmunk BASIC 1.0, and the p2c examples directory that later distributed it describes its contents as programs “culled from various places around the Caltech C.S. educational lab”. That is as precise as the primary sources get, and this page will not invent a date they do not give.

p2c, March 1990

The interpreter’s escape from campus came as a side effect of a different problem: translating a large body of HP Pascal into something portable. Gillespie built p2c, a Pascal-to-C translator handling HP Pascal among many other dialects, and basic.p traveled in the distribution as one of the example programs - listed there, in the README’s own phrasing, as “an interpreter for the Basic language, just for kicks!”. Nicholson’s account describes it as one of the translator’s test input files.

In March 1990, p2c was posted to Usenet - Nicholson’s readme recalls comp.source.misc, while the surviving archived posting is in comp.sources.unix. The Basic interpreter went with it. Everything that follows descends from the C that came out the other side of that translator.

Ron Nicholson and the Macintosh, 1992

The version the world actually used was built by Ron Nicholson, of HotPaw Productions. His summary of his own contribution, in the reference manual’s credits, is characteristically terse: he added file I/O and graphics and did the Unix, Macintosh and PowerMac ports, over the span 1990 to November 1997. Wikipedia dates the public Macintosh release to 1992.

It landed at the right moment. The Mac of the early 1990s had no BASIC in the box - Apple had shipped Applesoft on the II and MacBASIC was famously killed before release - and commercial options cost money. A free, capable, immediately usable BASIC filled a real gap, and it spread the way Mac freeware spread then: through Info-Mac, the FTP-and-Usenet archive that served as the platform’s distribution network before the web. Nicholson ported the interpreter first to a Mac 512KE, then to a PowerMac 7100, and posted the PowerPC build to Info-Mac on March 15, 1994 - by his own account, the day after the first Power Macintosh went on sale.

Design Philosophy

Old-fashioned on purpose

Most BASIC revivals try to modernize the language into respectability - structured control flow, no line numbers, an IDE. Chipmunk BASIC keeps the line numbers. In its console mode they are required; only when you write programs in an external editor do they become optional. The prompt-and-run loop is the product, not a limitation to be engineered away.

The argument for this is pedagogical and it is not a weak one. A beginner who types 10 print "hi" and then run has, in two lines, encountered program storage, program execution, statements, and the distinction between the two - with no file, no compiler, and no toolchain in the way. That is a very short path from nothing to a running program, and it is the path that got a generation into programming in the first place.

One maintainer, many decades

The other design decision is invisible in the syntax: Chipmunk BASIC is a single-maintainer project sustained across thirty-plus years. That shows up as conservatism. Features accumulate slowly, old builds are never deleted, and the archive still offers a build for 68k Macs running System 6 next to one for Apple Silicon. The project is explicit that its Cocoa rewrite is a trade rather than a straight upgrade - it states plainly that many Mac-specific features from the older Carbon and PowerPC versions are missing or broken in the Cocoa port. Saying so out loud, rather than quietly dropping the old downloads, is the whole ethos in one gesture.

Free, but not open in the usual sense

The licensing is of its era: free for educational and personal use, distributed without warranty. That is freeware rather than free software as the term is now understood, and it is worth being precise about the difference. The ancestor - Gillespie’s Pascal implementation - is described as public domain; the modern Chipmunk BASIC is Nicholson’s freeware.

Key Features

Types and variables

The type system is BASIC’s traditional one, encoded in the variable name:

Variable names may be up to 31 significant characters, must start with a letter, and are case insensitive. Arrays are declared with DIM and support a maximum of four dimensions. The manual is candid about the seams: arithmetic on integer variables is done in floating point anyway, and integer arrays are limited to one dimension.

Statements

The statement vocabulary is what you would expect, plus rather more than you would expect:

1
2
3
4
5
6
7
8
9

10 rem control flow
20 if x > 0 then print "positive" else print "not"
30 for i = 1 to 10 : print i : next i
40 while a < 100 : a = a * 2 : wend
50 gosub 1000
60 select case k
70 case 1 : print "one"
80 case else : print "other"
90 end select

IF/THEN/ELSE/ENDIF, FOR/NEXT, WHILE/WEND, SELECT/CASE, GOSUB/RETURN and GOTO cover control flow. DIM, READ, DATA and RESTORE cover static data. INPUT, PRINT, OPEN, CLOSE, GET and PUT cover I/O, with seeking and byte-level access available on files.

The function library runs from the ordinary - abs, sgn, int, sqr, rnd, sin, cos, atn, log, log10, exp - through the string set that every BASIC programmer has muscle memory for: mid$, left$, right$, str$, chr$ and case conversion.

Objects in a line-numbered BASIC

The genuinely surprising part is that this line-numbered interpreter grew an object system, and grew it early: the manual’s change log records class definitions arriving in v3.2.8, with notes on experimental OOP extensions dating to 1996. TYPE defines structured records; CLASS defines classes with single inheritance - the reference manual’s phrasing is that “classes inherit members from superclasses (single inheritance)”. Instances are created with dim VAR as new CLASSNAME and members reached through dot notation.

Finding dim obj as new Shape a few lines away from a GOSUB is a fair summary of what this language is: an artifact with thirty years of sediment in it, where nothing was ever removed to make room for what came later.

Beyond the language core

The extensions are where a Unix sensibility shows through the retro-computing surface. MAT statements provide matrix arithmetic; the interpreter offers FFTs (fn fft1), sockets, pipes, fork, shell command execution via system$(), and key-value database storage via sdbm - the project’s own description of the Linux build lists exactly this set, and notes it has even been used for web CGI. The Macintosh builds went considerably further, adding color graphics, a sprite engine, QuickTime MIDI and other sound, MacinTalk speech synthesis, AppleScript support and serial port I/O; the readme’s version history records beta support for Bluetooth LE appearing in the 2016 release.

Graphics

Cross-platform graphics are deliberately minimal: moveto, lineto, color setting and text rendering, with a scrn() function for reading pixels. The Mac-specific set adds oval and rectangle drawing and window sizing. On Linux, graphics are described as limited X11 support - a caveat the project states plainly rather than glossing over.

Evolution

The version numbering tells the story compactly. The 3.5.x line served the classic Mac era (3.5.6, dated August 1998, for System 6 on 68k; 3.5.7, dated May 2000, for System 7). The 3.6.x line ran through the 2000s and 2010s, reaching 3.6.3(b7) for Mac OS 9 Classic in April 2007, with the reference manual covering 3.6.6 internally dated August 2007, and 3.6.5 builds serving as the Windows (January 2011) and Linux/x86 ports. The current Linux x86-64 and Raspberry Pi builds carry 3.6.7 and 3.6.8 numbers.

Modern macOS releases use a different scheme - 1.368.2210, 1.368.2202, 1.367.2627 - whose middle component appears to encode the familiar 3.6.8 and 3.6.7 lines, an inference the project does not spell out. The readme reinforces it by writing one release as “Version 3.6.7(b6.0) = 1.367.2601”.

What that sequence records is four Macintosh instruction set architectures survived in one codebase: 68k, PowerPC, Intel and ARM. Apple Silicon support arrived in version 1.368.2202, which the readme credits with adding native M1 support and which the download page dates to November 2020.

Current Relevance

The current macOS release is version 1.368.2210, published November 11, 2022, which the project describes as tested with macOS 13 Ventura and on M1 Macs as well as older x86-64 Macs. According to the project’s home page, builds are also offered for Linux x86-64 (3.6.7b5 beta), the Raspberry Pi in both 32-bit and 64-bit ARM form, and MS Windows 2000/XP (3.6.5b6), with the page passing along user reports of the Windows build working under 64-bit Windows 8. Beyond what that page states, no compatibility claim here should be assumed - these are one maintainer’s builds and one maintainer’s testing, not a vendor support matrix.

The Raspberry Pi support is the most telling item on that list. A cheap single-board computer that boots to a prompt and invites a beginner to type something is, functionally, the machine BASIC was designed for, arriving forty years late. Chipmunk BASIC did not have to change to fit it - and the Pi is where the most recent activity shows: the 64-bit ARM build, version 3.6.8b307 beta, is dated February 9, 2024.

The language is best described as dormant rather than dead: releases are years apart, but this is a maintained, downloadable, natively-compiled interpreter that still starts on current hardware, with a reference manual published by MacTech, a community pocket manual on Wikibooks, a four-chapter tutorial contributed by Thomas L. Ferrell, and an entry in gotBASIC.com’s catalogue of living BASICs.

Why It Matters

Chipmunk BASIC’s significance is not linguistic. It contributed no new ideas to programming language design; it is a competent traditional BASIC with an unusually large extension set bolted on over time.

Its significance is as an object lesson in software longevity. Trace the chain: a Pascal program written for HP workstations at Caltech in the 1980s, machine-translated to C in 1990 as one of a translator’s test inputs, ported to the Macintosh in 1992, carried through the PowerPC transition in 1994, the Intel transition, Carbon to Cocoa around 2015-2016, and the Apple Silicon transition - then rebuilt for an inexpensive ARM single-board computer and a Windows PC along the way, all by one person giving it away for free. Very little commercial software has that record. Almost no hobby software does.

There is a second lesson in the lineage. The interpreter survived at all because it was useful as an example - a nontrivial program worth shipping with a translation tool. Software often outlives its purpose by being convenient to carry, and Chipmunk BASIC is one of the cleaner illustrations of that: it was preserved as a demonstration of something else, and once preserved, it turned out to be worth having on its own terms.

Finally, it stands for a defensible position on how programming should be introduced. The prompt-and-run loop it preserves is not nostalgia for its own sake. It is the shortest known distance between a person who has never programmed and a program that runs, and Chipmunk BASIC has spent three decades declining to lengthen it.