Blitz3D

Blitz3D is the answer to a question most languages duck: what if 3D graphics were part of the language? Not a library you install, not an SDK with an initialisation ritual and a build system to configure — keywords, sitting in the same manual as For and If, documented the same way, compiled by the same one-button IDE. Released in 2001 by New Zealand developer Mark Sibly through his company Blitz Research Ltd, it took the Windows BASIC compiler he had shipped the year before and bolted a complete DirectX 7 scene graph onto the side of it.

The result was a language in which a beginner could get a lit, textured, rotating object on screen before losing interest — and then, crucially, keep going. Blitz3D shipped commercial games, freeware phenomena and a generation of first projects, and its native model format ended up embedded in engines that have nothing to do with BASIC at all.

History and Origins

The Blitz lineage begins on the Commodore Amiga, where Sibly’s original Blitz BASIC and the Acid Software-published Blitz BASIC 2 (around 1993) proved that a compiled BASIC could produce commercial action games — Acid’s own Skidmarks, and, most famously, the Amiga Blitz program by Andy Davidson that Team17 turned into Worms.

In October 2000 Sibly founded Blitz Research Ltd in Auckland and brought the idea to Windows as BlitzBasic, published by Idigicon — a 2D compiler with graphics, audio, file I/O and networking built into the language. Blitz3D followed in 2001. It was not a separate language: it was the same compiler and the same dialect with a 3D runtime added, which is why the two products share a single version history. That history, shipped with the compiler as versions.txt, records V1.62 with the terse note “Final Blitz3D Release build!” — the point at which the 3D product went gold. The release month is not documented in sources that survive: versions.txt carries no dates at all, and contemporary coverage records only the year.

By April 2002 the Blitz Research site was selling Blitz3D as a roughly 25 MB download for $129.99 USD through Guildhall Leisure, listing requirements of Windows 95/98/2000, DirectX 7, 32 MB of RAM (64 MB recommended), a 200 MHz CPU (400 MHz recommended) and a DirectX-compatible 3D accelerator. Against the six-figure licence fees attached to professional middleware of the period, that price is the whole strategic argument for the product.

Blitz Research’s attention moved on soon enough. BlitzPlus arrived in February 2003, and BlitzMax — a genuinely new, object-oriented, cross-platform language — landed in December 2004 for Mac OS X, with Windows and Linux following in May 2005. Blitz3D settled into a long maintenance tail, picking up compatibility fixes as Windows moved underneath it: kludges for NVIDIA sprite crashes on Windows 7, a DirectDraw SetAppCompatData workaround for slow fullscreen frame rates on Windows 8.

Design Philosophy

Zero distance to the screen

Most 3D programming begins with a page of setup. Blitz3D begins with Graphics3D. The command set — CreateCamera, CreateLight, LoadMesh, PositionEntity, RenderWorld, Flip — is language vocabulary. There is no context creation, no device enumeration, no shader pipeline to construct before the first triangle appears, and no external dependency to install beyond DirectX itself, which Windows already had.

An entity system, not a graphics API

The 3D model is deliberately not a thin wrapper over Direct3D. Blitz3D presents a scene graph of entities: meshes, cameras, lights, pivots, sprites and terrains are all entities, all manipulated by the same family of commands. PositionEntity, RotateEntity, ScaleEntity, EntityParent, EntityColor and EntityTexture work on anything. Parenting is a single call. Collision is configured by assigning entities to collision types and letting UpdateWorld resolve them, rather than by writing intersection tests.

This is the feature that actually explains Blitz3D’s reach. A beginner does not need to know what a transform matrix is to attach a turret to a tank, and an intermediate programmer gets a hierarchy that behaves the way they expect. The cost is that you work the way the engine works — there is no dropping below the entity layer to hand-roll a renderer.

Compile, don’t interpret

Blitz3D compiles to a standalone Windows executable rather than running source through an interpreter. How fast the result runs depends almost entirely on where the program spends its time: code inside the built-in rendering and blitting commands is executing the engine’s own native routines, so it performs like the C++ it is, while arithmetic-heavy loops written in Blitz3D itself will not match carefully optimised C. The honest claim is not that Blitz3D was as fast as C++ — it is that for the class of game people were making in 2001, the limiting factor was the design rather than the language.

A small language, on purpose

There are no classes, no inheritance, no exceptions, no generics, no modules. There are variables with BASIC type suffixes, arrays, Type records with Field members, functions, Include files, and integer handles for engine objects. Banks provide raw memory when it is needed. That minimalism is a genuine liability past a few thousand lines — Blitz3D codebases tend toward long files and global state — and it is precisely the gap BlitzMax was built to fill.

Key Features

A complete 3D program, with no imports and no setup boilerplate:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

Graphics3D 800, 600, 0, 2
SetBuffer BackBuffer()

camera = CreateCamera()
PositionEntity camera, 0, 0, -5

light = CreateLight()
RotateEntity light, 45, 45, 0

cube = CreateCube()
EntityColor cube, 220, 60, 60

While Not KeyHit(1)
    TurnEntity cube, 0.2, 0.3, 0.1
    RenderWorld
    Flip
Wend

End

Records and typed variables use the classic BASIC sigils, with untagged names defaulting to integer:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Type Enemy
    Field entity
    Field health%
    Field speed#
    Field name$
End Type

For e.Enemy = Each Enemy
    MoveEntity e\entity, 0, 0, e\speed
Next

The 3D feature list advertised on the Blitz Research site in 2002 gives a fair picture of what the engine actually did:

Two further pieces matter more in retrospect than they did at the time. The first is render tweening, which decouples the physics/logic rate from the display rate — a fairly sophisticated idea to hand a beginner as a single command. The second is the .b3d file format, Blitz3D’s own binary mesh-and-animation container, whose specification Blitz Research published openly on its website. That decision is the reason the format is still alive.

Evolution

Blitz3D’s version history runs from the shared 2D compiler line through the 3D releases into the 2010s and then, unexpectedly, back to life:

• V1.62 (2001) — the build shipped as the retail Blitz3D release.
• V1.63–V1.99 (dates unrecorded — versions.txt numbers releases but never dates them) — steady engine work: orthographic camera projection, CopyMesh, normals preserved from .X and .b3d files, non-managed textures, MD2 support restored, FMOD-based audio refinements.
• V1.100–V1.108b (also undated, but the Windows 7 and 8 workarounds place them from roughly 2010 onward) — largely compatibility repair as Windows changed: workarounds for NVIDIA sprite crashes on Windows 7, a DirectDraw fix for Windows 8 fullscreen performance, a DirectInput startup fix.
• 3 August 2014 — Blitz3D is open-sourced under the zlib/libpng licence and made free of charge, following BlitzPlus on 28 April. The C++ source, built around MSVC 6.0, FreeImage 2.41 and the FMOD 3.75 API, goes up on GitHub. BlitzMax follows in September 2015.
• December 2020 — the last commit lands on the GitHub repository, repointing the README at the prebuilt free download; the repository is archived read-only at some later point, on a date GitHub does not publish.
• 2024 — after announcing his new LibSGD library on 28 February, Sibly returns to Blitz3D. V1.111 (13 April) adds UTF-8 load/save support and editor fixes; V1.115 (18 June) swaps the ageing FMOD dependency for the SoLoud audio engine, and Blitz3Dx95-V1.109 (24 June) is a Windows 95-compatible build with FMOD removed; V1.117 (19 August) adds a Dialect command, described as the first significant language addition in about two decades; V1.118 (4 September) adds /* */ block comments.
• December 2024 — Mark Sibly dies in early December. V1.118 is the last release.

Current Relevance

Blitz3D is a dormant language with an unusually persistent afterlife. The compiler is free, open source, and still runs on modern Windows; the 2024 releases fixed real problems and added real features, which is not something most twenty-three-year-old game compilers can claim. Nobody is starting a commercial 3D project in it today — the DirectX 7 fixed-function pipeline underneath it predates programmable shaders, and the language has no path to any platform that is not Windows.

What survives is threefold. SCP – Containment Breach is still played, still modded, and still open source, which means Blitz3D source code is being read and edited by people who have never installed the compiler. The .b3d format is embedded in Luanti (formerly Minetest) and in Irrlicht’s animated-mesh loader, so Blitz3D’s file layout is quietly being parsed by software that never knew its origin. And the community that formed around blitzbasic.com dispersed into the rest of the industry, carrying the habit of thinking about games as a loop that updates a world and renders it.

Why It Matters

Blitz3D’s historical significance is not technical. Its renderer was conventional for 2001 and obsolete by 2005; its language design is 1980s BASIC with records bolted on. What it did was collapse the cost of entry to 3D game programming at a specific and important moment — after 3D had become the default expectation for games, and before Unity, Unreal’s free tiers, Godot and the modern engine landscape made that accessible by other means. For most of a decade, if you were fifteen and wanted to make a 3D game, this was a realistic option in a way nothing else at $129.99 was.

It also stands as an argument about language design that the industry has since half-accepted. Putting the domain in the language — rather than in a library behind a package manager — produces a wildly shorter path from intention to running program. That is the same argument made by Processing, by PICO-8, by p5.js, and by every game framework that advertises “draw a sprite in five lines”. Blitz3D made it first, for 3D, in a language everybody had already been told not to take seriously.