Yabasic

Yabasic - short for “Yet Another BASIC” - is a free, open-source BASIC interpreter for Unix and Windows created by German programmer Marc-Oliver Ihm in 1995. It occupies a curious place in programming history: a small hobbyist language, written by a single author and never commercially promoted, that ended up bundled with millions of PlayStation 2 consoles across Europe. Deliberately traditional in flavor, Yabasic accepts classic unstructured BASIC written with goto and gosub while also offering structured loops, subroutines with local variables, libraries with their own namespaces, and simple cross-platform graphics. More than thirty years after its first release it is still maintained, with new versions appearing as recently as July 2026.

History and Origins

Marc-Oliver Ihm began writing Yabasic around May 1995. The first release was minimal even by the standards of tiny interpreters - it initially lacked arrays and loops - but it grew quickly. In the summer of 1996 version 2.0 brought a native Win32 port, establishing the dual Unix/Windows support that has defined the project ever since. A steady stream of releases followed, adding features such as color text output, graphics, and printing, and in the summer of 1999 version 2.57 introduced subroutines and libraries, transforming Yabasic from a toy into a language capable of structured, modular programs.

The name is self-deprecating by design. By the mid-1990s BASIC dialects were legion, and Ihm’s “yet another” framing signaled modest ambitions: a clean, small, free BASIC that ran the same way on a Linux box and a Windows PC. That portability, unusual among hobbyist BASICs of the time, turned out to be the project’s defining strength.

The PlayStation 2 Connection

Yabasic’s most remarkable chapter came courtesy of Sony. Beginning in 2000, the demo disc packed in with PAL-region PlayStation 2 consoles included an official port of Yabasic, complete with an on-screen editor. Owners of a brand-new PS2 in Europe or Australia could boot the disc and write BASIC programs on their game console - an echo of the 8-bit home computers of the 1980s, which booted straight into BASIC.

The reason was reportedly less nostalgic than fiscal. At the time, Sony was arguing that the PlayStation 2 should be classified as a home computer rather than a games console, which would have reduced European import duties, and bundling a programming language with every console supported the claim that the machine was programmable by its owners. Whatever the motivation, the result was extraordinary distribution: for roughly the first three years of the PS2’s life, every PAL console shipped with a Yabasic interpreter, making it one of the most widely distributed BASIC implementations of its era. NTSC regions never received the Yabasic disc, instead getting a separate product called BASIC Studio.

The story gained a coda in 2019, when security researcher CTurt published “Hacking the PS2 with Yabasic,” showing that the demo-disc interpreter could be exploited to run arbitrary homebrew code on unmodified PAL consoles. A pack-in curiosity that had been ignored for nearly two decades suddenly became a preservation-friendly entry point for the PS2 homebrew community.

Design Philosophy

Yabasic aims to be a BASIC in the traditional sense - approachable, forgiving, and immediate - while quietly supporting the habits of structured programming. Its documentation and design reflect a few consistent principles:

• Backward-looking compatibility of spirit: goto and gosub still work (jump targets are named labels rather than classic line numbers), so old-style unstructured programs feel at home.
• Structure without ceremony: for, while, repeat, and switch constructs, plus named subroutines with parameters, local variables, and return values, let programs grow beyond spaghetti without adopting a new paradigm.
• Portability: the same program text runs on Unix and Windows, including its graphics and printing commands.
• Smallness: the interpreter is a single compact C program built with flex and bison, easy to compile and easy to embed in unusual places - as the PS2 port demonstrated.

Key Features

A flavor of the language:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

rem Yabasic accepts classic BASIC style...
print "Hello, World!"

rem ...and structured programming with subroutines
sub square(x)
    return x * x
end sub

for i = 1 to 5
    print i, " squared is ", square(i)
next i

Notable capabilities include:

• String and numeric types by sigil: as in classic BASIC, name$ is a string and count is a number, with a rich set of string functions (mid$, instr, and, as of version 2.92.0 in 2026, replace$).
• Simple graphics and printing: programs can open a window, draw lines, circles, rectangles, and text, and send output to a printer, with the same commands working on Unix and Windows.
• Libraries and namespaces: code can be split into libraries that are imported with their own namespaces, keeping larger programs organized.
• Bound executables: a Yabasic program can be bundled together with the interpreter into a single self-running program for distribution.
• Foreign function interface: recent versions can call functions in C libraries, extending the language beyond its built-in command set.
• Console conveniences: modern releases added console colors, cursor positioning, and peeks for querying the environment - small touches aimed at the language’s core audience of script writers and tinkerers.

The yab Fork and Haiku

Around 2006, developer Jan Bungeroth of Team Maui forked Yabasic to create yab, a version extended with native GUI commands for BeOS and ZETA, and later for the open-source BeOS successor Haiku. Where stock Yabasic offers simple line graphics, yab exposes buttons, list views, menus, and other native interface widgets, making it a practical tool for building real desktop applications. The fork has passed through several maintainers and now lives in the HaikuArchives project, supported by tutorials and documentation from the German BeSly knowledge base. For a niche operating system with a small developer pool, an approachable BASIC with native GUI bindings has proven genuinely useful - and it remains Yabasic’s most significant descendant.

Evolution and Current Status

Yabasic’s development history has an unusual arc: intense activity in the late 1990s and early 2000s, a long quiet period - the project’s own history notes minimal development from 2006 to 2013 - and then a revival that began with compatibility bugfixes in January 2014. In September 2016, with version 2.77.1, Ihm placed the language under the MIT License and moved development to GitHub, explicitly inviting contributions. (An earlier, unrelated attempt by outside developers to build an unofficial “Yabasic 3” had been abandoned years before.) Since then the project has seen steady maintenance and modest feature growth: a rebuilt toolchain with version 2.90.0 in 2021, console and input improvements through the 2.91.x series in 2025, and new string functions in the 2.92.x releases of July 2026.

The official interpreter supports Unix/Linux and Windows, per the project’s own documentation; the PlayStation 2 port was a historical artifact of the demo discs, and Haiku support comes via the third-party yab fork rather than the mainline project. There is no official Docker image, but the interpreter builds from source with a conventional ./configure && make on Unix-like systems.

Why It Matters

Yabasic matters for two reasons that have little to do with each other. As a language, it is a well-crafted example of the 1990s free-software BASIC: small, portable, faithful to the interactive spirit of the original Dartmouth tradition while accommodating structured code. It kept a corner of BASIC culture alive on Linux at a time when the language’s commercial center of gravity had moved entirely to Visual Basic on Windows.

As an artifact, its PlayStation 2 story is one of computing history’s stranger footnotes. A one-person hobby project became, through a corporate tax argument, the pack-in programming environment for one of the best-selling consoles ever made - and then, two decades later, the key that unlocked that console for homebrew. Few languages this small have had a second act that large. That Yabasic’s author is still shipping releases in 2026, thirty-one years after the first version, only adds to its charm: it is a living piece of code archaeology.