BlitzBasic

BlitzBasic is what happens when someone decides the fastest path from “I want to make a game” to “here is my game” should be a single language, a single compiler, and no libraries to install. Devised by New Zealand developer Mark Sibly, it is a BASIC dialect in which Graphics, LoadImage, DrawImage, PlaySound, and Flip are not an SDK you bolt on — they are keywords. You type a dozen lines, press a key, and a window opens with a sprite in it. Then you press another key and get a standalone Windows .exe you can give to a friend.

That premise had already proved itself once, on the Commodore Amiga, where Blitz BASIC and its successor Blitz BASIC 2 produced commercial games fast enough to review well against assembler-written competition. In October 2000 Sibly founded Blitz Research Ltd in Auckland and brought the idea to Windows. The Windows line — BlitzBasic in 2000, Blitz3D in 2001, BlitzPlus in 2003 — became the entry point into game programming for a very large number of people during the decade before Unity, GameMaker’s ascendancy, and the modern engine era made that path routine.

History and Origins

The Blitz story starts on the Amiga, a machine whose custom chips rewarded programmers who understood the hardware and punished everyone else. BASIC on the Amiga generally meant AmigaBASIC or AMOS: interpreted, comfortable, and not fast enough for a commercial action game. Sibly’s Blitz BASIC took the other route — compile the BASIC, and expose the hardware the Amiga was actually good at.

The original was published by Memory and Storage Technology in the early 1990s, with Blitz BASIC 2 following around 1993 through Acid Software, a New Zealand Amiga publisher. Acid did not merely sell the compiler; they built games with it. Skidmarks (1993) is reported to have been about 95% Blitz BASIC, with hand-written assembler reserved for the parts that genuinely needed it, and Roadkill and Super Skidmarks followed. For a language associated in most people’s minds with 10 PRINT, shipping boxed, well-reviewed Amiga racers was a serious credential.

The most famous thing to come out of Amiga Blitz was not Acid’s, though. A teenager named Andy Davidson wrote a game called Total Wormage in Blitz BASIC and entered it in a programming competition run by Amiga Format, where it did not place. He showed it at the ECTS trade show in September 1994 instead, and Team17 co-founder Martyn Brown offered to publish it. It became Worms, released by Team17 in 1995, and then a franchise that has outlived the Amiga, the Blitz compilers, and Sibly himself.

When the Amiga collapsed as a commercial platform, the Blitz BASIC 2 sources were released to the community, and Amiga development continued under the name AmiBlitz — which, remarkably, is still maintained. Sibly meanwhile moved to Windows. BlitzBasic, sometimes called Blitz Basic 2D, was released in October 2000 through the UK publisher Idigicon, with a built-in API for 2D graphics and audio. Blitz3D followed in 2001, wrapping DirectX 7 in an entity-based command set, and BlitzPlus arrived in February 2003 with limited native Windows control support so the language could also produce ordinary desktop applications.

Design Philosophy

The organising principle is zero distance to the screen. Most languages treat graphics as a library problem: pick an API, install it, configure a build system, learn its initialisation ritual, and only then draw a rectangle. Blitz treats graphics as a language problem. The commands are in the manual next to For and If, they are documented the same way, and there is no build configuration because there is no build system — there is a compiler with a Run button.

A second commitment is compile, don’t interpret. Blitz compiles to a native Windows executable rather than running your source through an interpreter, which is what allowed BASIC-language games to hold their own against contemporaries written in C on the same hardware. Any comparison of that sort depends heavily on what the program spends its time doing — code that lives inside the built-in blitting and rendering commands is effectively running the engine’s native routines, while tight arithmetic loops written in Blitz itself will not match well-optimised C. The relevant claim is not that Blitz was as fast as C; it is that it was fast enough that the ceiling on your game was your design rather than your language.

Third, the language stays deliberately small. There are no classes, no inheritance, no generics, no exceptions, no garbage-collected object graph to reason about. There are variables, arrays, Type records, functions, and the built-in command set. This is a real cost when a project grows past a certain size — Blitz codebases tend toward long files and global state — and it is precisely why Sibly eventually built BlitzMax with object orientation and modules. But for the first ten thousand lines of a hobbyist’s programming life, the absence of ceremony is the whole point.

Key Features

Type suffixes and simple declarations. Blitz uses classic BASIC sigils: % for integer, # for float, $ for string, with untagged variables defaulting to integer.

1
2
3

name$ = "Player One"
score% = 0
speed# = 1.5

Graphics as keywords. A complete 2D program needs no imports and no setup boilerplate:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Graphics 640, 480, 16, 1
img = LoadImage("ship.png")

While Not KeyHit(1)          ; 1 = Escape
    Cls
    DrawImage img, MouseX(), MouseY()
    Flip
Wend

EndGraphics
End

User-defined Types as built-in linked lists. This is the feature Blitz programmers remember most fondly. A Type is a record, and every type maintains its own list that you traverse with For ... = Each:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Type Bullet
    Field x#, y#
    Field dx#, dy#
End Type

; spawn one
b.Bullet = New Bullet
b\x = 320 : b\y = 240 : b\dy = -8

; update them all
For b.Bullet = Each Bullet
    b\x = b\x + b\dx
    b\y = b\y + b\dy
    If b\y < 0 Then Delete b
Next

New, Delete, Each, First, Last, Before, After — an entity list, which is exactly what a game loop wants, provided by the language with no data-structure code to write. The backslash field-access operator is a Blitz signature.

Banks for raw memory. CreateBank, PeekByte, PokeInt and friends give you an untyped byte buffer for file formats, network packets, or pixel data — an escape hatch for the times the safe abstractions get in the way.

3D as more keywords (Blitz3D). The 3D layer keeps the same philosophy. Entities are integer handles; you create them, position them, and render:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Graphics3D 800, 600, 32, 2
camera = CreateCamera()
light  = CreateLight()
cube   = CreateCube()
PositionEntity cube, 0, 0, 5

While Not KeyHit(1)
    TurnEntity cube, 0.5, 0.5, 0
    RenderWorld
    Flip
Wend

Meshes, textures, terrains, animation, collision, and picking all follow the same handle-and-verb pattern. Blitz3D targeted DirectX 7, which by the mid-2000s meant its shader story was essentially “there isn’t one” — the single most cited reason serious projects eventually left it.

Calling into DLLs. User library declaration files let Blitz code call external Windows DLLs, which is how the community added networking, extra file formats, physics, and effects the built-in command set lacked. A surprising amount of Blitz’s late capability came from third-party DLL wrappers rather than from Blitz Research.

Evolution

The Blitz family branches rather than upgrades, and the distinction matters when reading old forum threads.

BlitzMax is the pivotal fork. It answered the classic dialect’s real weakness — that large projects had no way to organise themselves — with classes, a module system, and cross-platform support, but it did so by being a different language. Plenty of Blitz3D users never followed, because BlitzMax had no equivalent of Blitz3D’s built-in 3D engine; the community filled that gap with third-party efforts such as the open-source MiniB3D. The result was a split: Blitz3D remained the 3D tool, BlitzMax became the 2D and cross-platform tool, and neither fully replaced the other. Monkey, from 2011, moved further still by generating code for other languages and platforms rather than emitting native executables directly.

Commercially, the Blitz products were of their time: boxed retail and paid downloads, sold to hobbyists, in a market that Unity’s free tier and the modern engine ecosystem would shortly reorganise. Blitz Research’s response was to open the archive. BlitzPlus was released under the zlib licence on 28 April 2014, Blitz3D on 3 August 2014, and BlitzMax on 21 September 2015, with the compilers made free to download. Blitz3D in particular kept receiving updates long after: version 1.118 was posted in September 2024, and community forks have continued to modernise it — replacing the old audio back end, improving Windows compatibility, and extending the compiler.

Mark Sibly died in early December 2024, after a period of ill health. The tributes came from three directions at once — Amiga veterans who remembered Blitz BASIC 2, indie developers whose first shipped game was a Blitz3D project, and BASIC enthusiasts who considered the Blitz line the last serious commercial BASIC compiler. That breadth is the measure of the work.

Current Relevance

BlitzBasic is dormant, and it is fair to call the classic dialect finished as a commercial product line. Nobody should start a new commercial 3D project in Blitz3D in 2026: a DirectX 7 renderer with no programmable shader pipeline, Windows-only output, and no object system is a poor foundation next to Godot, Unity, Unreal, or even a modern BASIC-family option like PureBasic.

What remains is genuinely alive, though, in a smaller way:

• The compilers are free and open source. Blitz3D, BlitzPlus, and BlitzMax are all on GitHub under the zlib licence, so the tools cannot simply vanish the way most commercial hobbyist languages of that era did.
• Community forks keep shipping. Blitz3D has seen continued releases and independent forks reworking its internals — unusual longevity for a language whose vendor wound down.
• SCP – Containment Breach keeps the source in circulation. A large modding community works in Blitz3D because the game they want to modify is written in it, which quietly recruits new Blitz programmers every year.
• AmiBlitz is actively maintained. New Amiga software is still written in a direct descendant of Blitz BASIC 2, more than thirty years on.
• Retro and jam scenes. Blitz turns up in Amiga game jams and retro-development circles, where its combination of period authenticity and low friction is exactly the appeal.

If you want the Blitz feeling on modern hardware, the honest recommendations are elsewhere — Godot for a full engine, raylib or LÖVE for the immediate draw-a-sprite loop, PureBasic or QB64 for a compiled BASIC. But if you are opening a decade-old .bb file, the compiler still runs, and it still produces an executable.

Why It Matters

Blitz BASIC is a case study in the value of removing steps. Every technical decision it made — commands in the language rather than in libraries, compilation to a single executable, an IDE with one meaningful button, type lists instead of a data-structures course — served one goal, which was shortening the distance between wanting to make a game and having one running. That is not a glamorous design objective, and it is one the industry has repeatedly rediscovered: it is what Flash offered, what GameMaker offers, what PICO-8 offers, and what every engine’s “your first game in ten minutes” tutorial is trying to fake.

It also demonstrated something about BASIC that the language’s reputation obscures. By 2000, BASIC was widely written off as a teaching toy, useful for learning and then to be abandoned. Blitz’s answer was a commercially sold, natively compiling BASIC that shipped real games — Worms on the Amiga, Platypus and SCP – Containment Breach on Windows, plus a long tail of shareware. The limitation was never the For loop and the Print statement; it was the runtime and the library situation, and Blitz fixed both.

The counter-lesson is equally clear, and Sibly clearly saw it: the simplicity that makes a language perfect for your first thousand lines becomes a liability at your fifty-thousandth. BlitzMax exists because Blitz3D users hit that wall. Monkey exists because BlitzMax was single-target in a world going multi-platform. Three languages in eleven years, each one solving the previous one’s structural problem, is an unusually candid engineering record for a one-person company.

Finally there is the human piece. Blitz Research was essentially one developer in Auckland who spent a quarter of a century making game programming reachable, and then gave the whole toolchain away rather than let it rot in a defunct storefront. A meaningful number of working developers today trace their careers to a Graphics 640,480 line typed into a Blitz IDE. That is a considerable legacy for a BASIC compiler from New Zealand.