SmallBASIC

A calculator that got out of hand

SmallBASIC begins with a complaint. In March 2000 a Greek programmer named Nicholas Christopoulos bought a Palm IIIx and discovered that Palm OS, for all its elegance, shipped without what he considered a serious calculator. His solution was not to write a calculator. It was to write a BASIC.

“Couple of months ago (Mar 2K), I bought a Palm IIIx and I was really disappointed (I was expecting to include a serious calculator program). That is why I made (for PalmOS 3.3, I tested) BASIC with graphics, something between QBASIC and GWBASIC (For my opinion, Basic is a super-calculator).”

That message, posted to the project’s first homepage and preserved in the Internet Archive alongside a Greek translation, is the founding document of a language that has now outlived Palm OS, SourceForge’s Subversion service, the Franklin eBookMan, the Nokia 770 and several of its own GUI toolkits. The “Small” in the name refers to the hardware, not the ambition.

Version 0.5.3 was ready by May 2000; the SourceForge project was registered on 9 March 2001; source files still carry the header Copyright(C) 2000 Nicholas Christopoulos. Some secondary accounts - including the Learn X in Y Minutes page written by Warren-Smith - date the project to late 1999, but the author’s own words, the guide on his own site and the oldest surviving ChangeLog entry all point to 2000.

Design philosophy: a super-calculator, honestly labelled

What makes SmallBASIC unusual among hobby BASICs is how precisely its author scoped it. The 2001 homepage carried a description that most language authors would never write about their own work:

“SmallBASIC is a simple computer language, targeting on simplicity, mathematics and graphics. Its a tool for novices, for non-IT scientists, for simple and ‘silly’ algorithms. SmallBASIC IS NOT A DEVELOPER TOOL FOR PROFESSIONAL PROGRAMMERS (there are no data-types, no binary output, no QB compatibility, no low-level access, etc).”

Everything that follows in the project’s history is consistent with that statement. There is no compiler producing standalone binaries, no static typing, no attempt at QBasic bytecode compatibility. What there is instead is an unusually rich standard library for the things the target audience actually does: arithmetic, plotting, and pushing pixels around.

The mathematics library is the giveaway. SmallBASIC has matrix literals and matrix arithmetic as language-level constructs, and, as Warren-Smith’s ‘About SmallBASIC’ article lists them, built-in functions for matrices, unit conversion, trigonometry, logarithms, statistics (SUMSQ, STATSPREADS), equations (LINEQN, DIFFEQN) and 2D and 3D transformations. Solving a three-variable system is a two-line program:

1
2
3
4

A = [ 5, -2, 3; -2, 7, 5; 3, 5, 6]
B = [ -2; 7; 9]
C = LinEqn(A, B)
? "[x;y;z] = "; C

Charting is similarly built in rather than bolted on:

1
2

dat = [5, 6, 3, 7, 10]
chart LINECHART, dat, 3, 20, 17, xmax, ymax

This is a language designed by someone who wanted a better calculator and understood that a better calculator is a small programming language with graphics.

Portability as an architectural commitment

The single most consequential decision in SmallBASIC’s history was made early, at version 0.5.6 in the first months of 2001, when Christopoulos restructured the interpreter so that everything platform-specific lived behind a driver interface. The core - scanner, pseudo-compiler, bytecode runner, standard library - is portable C. Each target supplies its own device layer for display, input, sound and file access.

Within months of that change the project had back ends for Palm OS, Linux over SVGAlib, Linux over SDL, the Linux framebuffer, Win32 and DOS through DJGPP. Over the following two decades the list of drivers turned over almost completely - Helio/VT-OS, the Franklin eBookMan, the Nokia 770’s GTK, FLTK, SDL2, SDL3, Android’s NDK, Emscripten, Teensy bare metal - while the core changed comparatively little. The 2012 GitHub migration retired a decade of dead ports in one commit, and the architecture absorbed it without drama.

That same design is why the graphics engine could fall back to ASCII output on text-only devices, and why the interpreter has been able to reach targets as different as a Franklin eBookMan reader and a WebAssembly sandbox in a browser tab.

The language itself

SmallBASIC deliberately accepts both halves of BASIC’s history. Line numbers, GOTO and GOSUB work, so a listing typed out of a 1982 magazine has a fair chance of running. But the modern syntax is fully structured:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func fib(n)
  if n < 2 then
    fib = n
  else
    fib = fib(n - 1) + fib(n - 2)
  fi
end

for i = 0 to 10
  ? i; " -> "; fib(i)
next i

Statements are terminated by newlines, with : available to put several on one line. Beyond the QBasic baseline, the language has picked up features that are unusual in this family:

The CHAIN statement in particular gives the language a self-modifying quality that would be at home in a Lisp:

1
2

code = "for i = 0 to 10: ? i: next i"
CHAIN code

Two maintainers, twenty-six years

Christopoulos drove the project through its formative years and committed for the last time on 2 January 2006. Chris Warren-Smith, whose first commits appear in April 2004, has maintained it ever since - an unbroken stewardship of more than two decades that is rare for a hobbyist language and is the main reason SmallBASIC is still installable today.

His involvement predates his commit access: the ChangeLog credits “Chris’s port” - the Franklin eBookMan target - to February 2002. His own account of what he used SmallBASIC for, in the 2007 “About SmallBASIC” article, is worth recording, because it is the opposite of a marketing claim:

“It was never really intended that SmallBASIC would be used to deliver code to a paying customer. However the console version can be a useful tool for building relatively complex scripts as part of your development process. For example I have used SmallBASIC to generate complicated SQL statements from an input properties file. I have also used it to create a Java database access layer code generator.”

Under his maintenance the project shed its dead platforms, moved to Git and GitHub in May 2012, gained an Android build in 2013, formalised a plugin system in 2018, dropped the leading zero from its version numbers in 2020, and reached the browser via WebAssembly in 2022. Joerg Siebenmorgen has been contributing since November 2021 and maintains the Raspberry Pi GPIO module separately.

Not to be confused with Microsoft Small Basic

There are two unrelated languages with nearly this name. SmallBASIC - one word, capital BASIC - is this project: begun in 2000, written in C, GPL-licensed, and community-maintained. Microsoft Small Basic - two words - is a separate .NET-based educational language released by Microsoft in 2008. They share an ancestor in the BASIC tradition and nothing else: no code, no syntax lineage, no authors, no organisation.

Where it stands in 2026

SmallBASIC is often catalogued as a dormant Palm-era curiosity. It is not. The SDL build reached Flathub in January 2026, 12.33 was released for Windows on 2 March 2026 and tagged for FreeBSD on 4 March; the ChangeLog records 12.34 on 28 April 2026; the tree bumped to 12.35 in August 2026 and commits have continued past that. The project’s own download page lists 12.35 on Google Play and 12.33 for Windows and Flatpak. The SDL back end moved to SDL 3.x in May 2025, the Android app is apparently the primary distribution channel, and the repository recorded more than a hundred commits in each of 2025 and 2026 to date.

The community is small - a Discourse forum, a Flathub package reporting roughly a couple of hundred installs a month, a handful of regular contributors - but it is continuous, which over twenty-six years is a rarer achievement than size.

Why it matters

SmallBASIC is a useful case study in what makes a small language survive. It had no institutional backing, no funding, no standardisation body and no killer application. What it had was a narrow, honestly stated purpose and an architecture that separated the language from the machine.

That separation is the whole story. Because the interpreter was portable C with swappable device drivers, SmallBASIC could follow the hardware wherever it went: from a Palm IIIx to a Nokia tablet to an Android phone to a browser to a Teensy board. Languages with far larger communities have died when their single target platform died. SmallBASIC has outlived at least six of its own.

It also preserves something genuinely useful. The BASIC that shipped with home computers - type a line, see a result, draw a circle without importing anything - largely disappeared from mainstream computing, and the modern replacements tend to demand a toolchain before they will print “Hello”. SmallBASIC still starts, still runs a one-line program, and still plots a chart with one statement, on hardware that did not exist when it was written.