BlitzMax

BlitzMax is what Mark Sibly built when he decided that the BASIC dialect behind Blitz3D had gone as far as it could. The classic Blitz language was superb for your first thousand lines and awkward by your ten-thousandth: no classes, no inheritance, no module system, no way to carve a large program into pieces that did not know about each other. BlitzMax, first released for Mac OS X in December 2004, keeps the thing that made Blitz worth using — a graphics and audio command set built into the language, so a window with a sprite in it is three lines away — and puts a real language underneath it.

It is worth being precise about the relationship, because old forum threads are not: BlitzMax is not a new version of BlitzBasic. It is a separate language and a separate compiler, sharing family resemblance and a vendor. Code does not port across without work, and notably BlitzMax never had Blitz3D’s built-in 3D engine, which is why a substantial part of the Blitz3D community simply never followed Sibly across.

History and Origins

Blitz Research Ltd was Sibly’s one-man company in Auckland, founded in 2000 to bring his Amiga-era Blitz BASIC compiler to Windows. That line — BlitzBasic in 2000, Blitz3D in 2001, BlitzPlus in 2003 — was successful on its own terms and structurally stuck. It was Windows-only, it compiled through hand-written x86 assembly generation, its 3D layer was built on DirectX 7, and its type system stopped at records with a built-in linked list.

BlitzMax was the answer to all four problems at once, and it started on the platform the earlier products had never touched. Version 1.00 shipped on 10 December 2004 for Mac OS X, with the Win32 release dated 11 May 2005 in the official version notes and the Linux compiler reported as arriving the same month. That ordering was deliberate signalling: this was the cross-platform Blitz, and it proved it by being born somewhere other than Windows.

The changes ran deep. The type system gained classes, inheritance, abstract and final types, methods and interfaces-by-convention. The command set was reorganised into modules — BRL.* for Blitz Research’s own libraries, Pub.* for wrapped third-party C code — that you could read, modify and recompile, since all of the standard modules shipped as source. The graphics layer, Max2D, was reshaped around OpenGL so it could work identically across the three platforms, with a Direct3D driver added from v1.10 and made the Windows default. And strings became Unicode internally, using 16-bit characters, giving BlitzMax markedly better non-ASCII handling than the earlier Blitz dialects — though the release notes show Unicode support being repeatedly revised well into the 1.3x series.

Design Philosophy

Keep the on-ramp, remove the ceiling. The core bet is that you should not have to choose between a language that gets you drawing in five minutes and a language you can build a 50,000-line game in. Graphics 800,600 still works with no imports, no build configuration and no initialisation ritual. But when the project grows, there are classes to put behind it, modules to split it into, and a garbage collector so that object lifetimes stop being your problem.

Compile to native code, everywhere. BlitzMax produces real executables for each target — not bytecode, not an interpreter, and (in the original implementation) not a wrapper around someone else’s runtime. The practical claim BlitzMax made was never that it matched hand-tuned C, and no published benchmark suite establishes where it actually landed; drawing calls run in the modules’ native routines, while arithmetic written in BlitzMax itself was generally reported by users to trail well-optimised C. The claim was that the language was fast enough that your game design, not your compiler, set the limits — and shipping commercial titles like the Eschalon trilogy on three platforms from one source tree is at least consistent with that.

Optional strictness. BlitzMax lets you choose your own discipline per file. Plain mode behaves like BASIC always did, Strict requires variables to be declared, and SuperStrict additionally requires every declaration to state its type. It is a small feature with an outsized effect: the same language serves a beginner typing x = 5 and a team that wants the compiler to catch a typo in a field name.

Ship the source. Every standard module came as readable BlitzMax and C source. This was unusual for a commercial product in 2004, and it is the single reason BlitzMax survived its vendor: when Blitz Research stopped, the community already knew the code.

Key Features

Types with real object orientation. The classic Blitz Type record grows into a class, with Extends, Method, Function, Abstract, Final and Super:

SuperStrict

Type TEntity Abstract
	Field x:Double, y:Double

	Method Update() Abstract

	Method Draw()
		DrawRect(x, y, 8, 8)
	End Method
End Type

Type TBullet Extends TEntity
	Field dy:Double = -8

	Method Update()
		y :+ dy
	End Method
End Type

Local b:TEntity = New TBullet
b.x = 320 ; b.y = 240
b.Update()

Note the modern touches: :Type suffixes instead of BASIC sigils, . for field access instead of Blitz3D’s backslash, and compound assignment (:+, :*).

A module system with Framework. Import pulls in a module; Framework says only pull in this module and what it depends on, which is how you keep a small program’s executable small:

SuperStrict
Framework BRL.GLMax2D
Import BRL.PNGLoader

Garbage collection. From v1.12 onward, object memory is collected automatically. The earlier Blitz model — an explicit FlushMem at the top of your main loop — was retired, which is one of the more visible discontinuities between old and new BlitzMax code you will find in forum archives.

Reflection. Added in v1.26 (2007), BRL.Reflection lets a running program enumerate types, fields and methods and invoke them by name. It is the machinery behind BlitzMax’s generic serialisation and scripting bridges, and a genuinely uncommon capability in this corner of the language world.

Threads and Lua. Threading arrived through BRL.Threads in v1.32, with threaded builds switching to the Boehm-Demers-Weiser collector — thread-safe, and by Blitz Research’s own note a little slower than the standard GC. Lua bindings had been contributed as community modules earlier and were folded in as Pub.Lua, with a higher-level BRL.MaxLua added in the same 1.32 release, letting games embed a scripting layer — the combination TVTower uses.

Max2D, and the deliberate absence of Max3D. The 2D API is complete and familiar: SetGraphicsDriver, LoadImage, DrawImage, SetBlend, SetRotation, Flip. There is no official 3D. Sibly worked on a Max3D project that never shipped as a finished product, and the gap was filled by the community’s MiniB3D and later OpenB3D. This is the most common reason a Blitz3D user gave for staying put.

MaxGUI and MaxIDE. MaxGUI is a cross-platform native-widget module — Win32 on Windows, Cocoa on macOS, FLTK on Linux — so BlitzMax could write ordinary desktop applications, not only games. MaxIDE, the bundled editor, is itself written in BlitzMax using MaxGUI, which was the point.

Extern for C interop. Declaring external C functions is a first-class part of the language, and it is how Pub.* wraps things like FreeType, OpenAL, zlib and ENet. The extensive third-party module ecosystem — SDL, SQLite, wxWidgets, Cairo, database drivers — is almost all built on Extern.

Evolution

The official arc bends around Monkey, announced in 2011. Monkey X reused a great deal of BlitzMax’s syntax but generated source for other languages and platforms rather than compiling directly, chasing mobile and web targets that BlitzMax’s native-compilation model could not reach. Sibly’s attention went there, and BlitzMax updates thinned out into maintenance — Lion compatibility, Xcode compatibility, toolchain refreshes — until the release under the zlib licence in September 2015 drew a line under the commercial product.

What happened next is more interesting than most post-vendor stories. BlitzMax NG, driven principally by Bruce A. Henderson, re-engineered the compiler’s back end so that bcc emits C and lets GCC or Clang do code generation. That one change unstuck everything the original architecture had pinned down: 64-bit builds, ARM and AArch64, Apple Silicon, Raspberry Pi, and further targets including Android and Emscripten in varying states of completeness. It also added language features the official compiler never had. NG is not bit-compatible with legacy BlitzMax — code sometimes needs adjusting, particularly around string and pointer types — but it is where the language actually lives now, and it was still publishing weekly builds in 2026.

Mark Sibly died in early December 2024. The tributes came from Amiga veterans, from indie developers whose first shipped game was a Blitz project, and from BASIC enthusiasts who regarded the Blitz line as the last serious commercial BASIC compiler. Three languages in eleven years — BlitzBasic, BlitzMax, Monkey — each built to solve the previous one’s structural problem, is an unusually honest engineering record for a one-person company.

Current Relevance

BlitzMax is dormant as a commercial product and quietly alive as an open-source one. Nobody is starting a studio on it in 2026, and the honest recommendation for a new cross-platform 2D game is Godot, LÖVE, raylib or MonoGame. But the specific things BlitzMax still offers are real:

• The toolchain is free, open and maintained. Legacy BlitzMax is on GitHub under the zlib licence; BlitzMax NG ships builds for Windows, Linux x64, macOS x64 and arm64, and both 32- and 64-bit Raspberry Pi.
• It runs on Apple Silicon and ARM SBCs. A language whose original compiler emitted 32-bit x86 assembly now targets AArch64, because the community rebuilt the back end rather than let the platform list decay.
• Large open-source codebases exist to learn from. TVTower in particular is a substantial, actively developed BlitzMax project you can read end to end.
• The module ecosystem is unusually broad for a language this size — SDL, raylib bindings, SQLite, networking, physics — much of it maintained inside the bmx-ng organisation.
• Legacy code still compiles. Studios and hobbyists sitting on decade-old BlitzMax projects can keep building them, which is not something most abandoned commercial languages can say.

The realistic profile of a BlitzMax user today is someone maintaining an existing project, someone who wants a compiled, statically typed, batteries-included language for 2D games without adopting an engine, or someone in the retro-development scene who simply likes it.

Why It Matters

BlitzMax is the clearest case in the BASIC family of a language growing up without losing its manners. Almost every attempt to make BASIC serious has done it by making BASIC unrecognisable, or by bolting an IDE and a framework onto it and hoping. BlitzMax added classes, modules, garbage collection, reflection, threads and Unicode, and you can still open a graphics window and draw a sprite in three lines. That combination — trivially approachable at the surface, structurally sound underneath — is rarer than it sounds, and it is what a lot of modern “beginner-friendly but real” language design is still reaching for.

It also made an argument about cross-platform development that landed early. In 2004, shipping a small commercial game simultaneously on Windows, Mac and Linux meant either a lot of C++ and a lot of porting or not bothering. BlitzMax’s answer was one source tree and three native compilers, and the Eschalon trilogy is proof it worked for a real studio with real deadlines. The mainstream solution that eventually won — a big cross-platform engine — is a different shape entirely, but BlitzMax got to the destination first with a fraction of the machinery.

And it is a case study in why open-sourcing matters more than it seems at the time. Blitz Research released BlitzMax under the zlib licence in 2015, roughly when the commercial product stopped mattering. Eleven years later, that decision is the only reason the language runs on Apple Silicon, on 64-bit Linux, and on Raspberry Pi hardware that did not exist when Sibly wrote the compiler. The vendor stopped; the language did not. Most hobbyist languages of the 2000s took their compilers with them into the dark, and BlitzMax’s continued existence is a direct consequence of one licence choice made on the way out.