Bywater BASIC

Bywater BASIC — almost always written bwBASIC — is not a new BASIC. It is an implementation of BASIC, written in portable C, whose entire reason for existing is that you should be able to type bwbasic on any machine with a C compiler and get a working BASIC prompt. It implements a large superset of the ANSI Standard for Minimal BASIC (X3.60-1978) and a significant subset of the ANSI Standard for Full BASIC (X3.113-1987), and in its modern incarnation it can impersonate roughly two dozen historical dialects on request.

It is also the BASIC with the best origin story in the business, and the story is a lie.

History and Origins

Open the bwBASIC man page — still shipped by Debian and Ubuntu — and you are told that the program was begun in 1982 by Verda Spell of Beaumont, Texas, who was writing it in C on an Osborne I running CP/M. Her work, the documentation explains, was cut short in the summer of 1986 when she was thrown from a Beaumont-to-Port Arthur commuter train. Her grandson, Ted A. Campbell, later found the source files on a CP/M diskette in her knitting bag, and revised and released them.

None of this happened. Campbell — reportedly a historian and theologian by profession — has since acknowledged that the grandmother was invented, putting it bluntly in a public comment: the material about his grandmother was, in his words, nonsense that “made for a good story.” It is one of the more durable pieces of software folklore precisely because it was placed in the documentation rather than in a joke file: it has been faithfully reproduced by packagers, man page mirrors, and encyclopedias for over thirty years, and it still catches people out.

What is verifiable is the release history. Version 1.10 circulated on shareware archives with documentation dated 1 November 1992, presented as a superset of ANSI Minimal BASIC written in ANSI C with shell facilities layered on top. Version 2.10, dated 11 October 1993, is the release most people mean when they say bwBASIC — it broadened coverage into Full BASIC territory, and it is the version that Unix and Linux distributions carried for years. Campbell stopped work on the project in 1993.

The project then went through the classic open-source relay. Jon B. Volkoff released version 2.20 in November 1995 and patch levels over roughly the following two years. The code was placed on SourceForge in 2002, where 2.10 was posted in March of that year. From 2008 Paul Edwards picked it up, shipping 2.30, 2.40, 2.50, 2.60, and 2.61 between 2008 and 2014, with a distinct interest in making the C compile everywhere including mainframes. Then, in 2015, Howard Wulf (AF5NE) rewrote it.

Design Philosophy

Three commitments run through the whole project.

Portability over performance. The documentation is explicit that bwBASIC favours conceptual clarity in its C source over speed, and it declines to implement anything that cannot be done portably — no PEEK, no POKE, no hardware port access, no printer-specific control commands. This is a real and deliberate trade: bwBASIC is widely described as slow relative to other BASIC interpreters, including in the project’s own user feedback. It is worth being precise about what that means, since no published benchmark with a stated methodology exists: the observation comes from user reports rather than measured comparisons, and it reflects an interpreter that walks its source representation rather than compiling to bytecode. Anyone choosing an interpreter on speed grounds should measure their own workload rather than trust either the reputation or a bare number.

Standards, not vendors. Most BASIC implementations chase compatibility with a specific popular product — usually some flavour of Microsoft BASIC. bwBASIC anchors itself to the ANSI standards first, and treats vendor dialects as configurable deviations from that baseline. This is an unusual position for a BASIC and it explains a lot about the language’s shape.

BASIC as a shell. The original design had an idea largely absent from other BASICs: shell commands could be typed straight at the BASIC prompt, and the interpreter would pass them to the system. bwBASIC was pitched not just as a language but as an interactive environment — a BASIC-flavoured shell where the distinction between “running a program” and “running a command” was deliberately thin.

Key Features

The core language is unsurprising, which is the point:

1
2
3
4
5
6

10 REM Classic line-numbered BASIC works as expected
20 LET N = 5
30 FOR I = 1 TO N
40   PRINT "Line"; I
50 NEXT I
60 END

Modern releases accept unnumbered, structured code as well:

1
2
3
4
5
6
7
8

OPTION VERSION "BYWATER"

INPUT "Name: ", NAME$
IF LEN(NAME$) = 0 THEN
  PRINT "No name given."
ELSE
  PRINT "Hello, "; NAME$
END IF

The genuinely distinctive feature is OPTION VERSION. The version 3.20 documentation lists roughly two dozen selectable dialects: BYWATER, BYWATER-2, CALL/360, CBASIC-II, DARTMOUTH, ECMA-55, ECMA-116, GCOS, HAARDT, HANDBOOK1, HANDBOOK2, HEATH, MARK-I, MARK-II, MBASIC, PDP-8, PDP-11, RBASIC, RSTS-11, SYSTEM/360, SYSTEM/370, TRS-80, VINTAGE, and XBASIC. Selecting one changes which keywords exist, how the interpreter treats syntax and errors, and which behaviours it emulates — so a single binary can be a Dartmouth BASIC in one session and a TRS-80 BASIC in the next.

Around that sit the features added across the 3.x line:

The 3.20 documentation counts over 500 commands, functions, and operators across all supported dialects.

Evolution

The interpreter has had three distinct lives.

The Campbell era (1992–1993) produced a compact, standards-minded interpreter with an integrated shell, and then stopped. Two releases, roughly a year apart, and a documentation file with a fictional grandmother in it.

The maintenance era (1995–2014) kept the 2.x line alive without changing its character. Volkoff’s 2.20 and its patches, the move to SourceForge, and Edwards’ long series of releases from 2008 onward were about keeping the code building on as many systems as possible — including targets, like IBM mainframes under MVS and CMS, that few hobbyist language projects have ever bothered with.

The Wulf era (2015–2017) is where bwBASIC became something else. Version 3.00 was a complete redesign of the code. Version 3.10 turned the interpreter into a multi-dialect emulator. Version 3.20 rounded it out with virtual arrays, structured loops, and configurable punctuation. In three years the project went from “a portable ANSI BASIC” to “a portable ANSI BASIC that can also pretend to be almost any BASIC you have a listing for” — a genuinely different and more interesting product.

Then a seven-year silence, broken by version 3.30 in November 2024 and 3.40 in October 2025.

Current Relevance

bwBASIC is dormant in the ordinary sense: no active community, no roadmap, no ecosystem, a low-traffic SourceForge page, and years between releases. Nobody is building new systems on it. But dormant is not dead, and the two recent releases matter — a project that ships in 2024 and again in 2025 still has someone paying attention.

Where it remains genuinely useful:

• Retrocomputing and listing recovery. If you have a program listing from a 1979 magazine and want to see what it does, OPTION VERSION is a better starting point than an emulator plus a disk image plus a period operating system.
• Standards-conformant BASIC. For anyone who needs to check what ANSI Minimal BASIC or Full BASIC actually requires, an implementation written explicitly against those documents is worth more than a vendor product.
• A BASIC that builds almost anywhere. It is conservatively written portable C with no required external libraries, and the source tree ships build scripts for everything from IBM mainframes to 16-bit DOS compilers. If your target has a C compiler, you can probably have a BASIC on it by this afternoon.
• Casual scripting in familiar syntax. For someone whose first language was BASIC forty years ago, having bwbasic in the package manager is a low-friction way back in.

Where it is the wrong choice: anything needing graphics, sound, GUI, network access, speed, a package ecosystem, or an active support community. For those, QB64, FreeBASIC, PureBasic, or a modern language are the honest answers.

Why It Matters

bwBASIC is worth knowing about for three reasons that have little to do with each other.

It is a serious attempt at portable, standards-based BASIC. The BASIC world fragmented early and comprehensively; by the mid-1980s “BASIC” named a family of mutually incompatible products with a shared ancestor and little else. bwBASIC is one of the few implementations to start from the ANSI documents instead of from a competitor’s manual, and its refusal to implement unportable features — however inconvenient — is the same discipline that makes standards useful in the first place.

Its dialect-emulation system is a preservation tool. Treating historical BASIC dialects as selectable configurations of one interpreter is a genuinely good idea, and one that comparatively few language projects have pursued. Software preservation usually means preserving the machine; bwBASIC preserves the language instead, which is cheaper, more portable, and in many cases sufficient.

It is a model of long-form open-source stewardship. Campbell wrote it and left after two years. Volkoff, Edwards, and Wulf each carried it for a stretch, and Wulf’s redesign made it substantially more valuable than it had been. Thirty-three years after the first dated release, the code still compiles and still ships. That is what the GPL was for, and it is not a common outcome for a one-person hobby interpreter from 1992.

And, of course, there is Verda Spell — a grandmother who never existed, thrown from a train that never happened, whose knitting bag has been described as fact in Linux man pages shipped by Debian and Ubuntu for decades. Every field needs a story like that.

Sources

• Bywater BASIC Interpreter on SourceForge — official releases and version history
• README for bwBASIC version 3.20 — dialect list, changelog, and feature notes
• bwbasic(1) man page, Debian — the version 2.10 documentation and its origin story
• John-Titor/bwbasic on GitHub — historical archive of the source tree and build scripts
• Bywater BASIC — Virtually Fun — where the Verda Spell story is confirmed as fiction