BlitzPlus

BlitzPlus is the least famous member of the Blitz family and, in one narrow sense, the most ambitious. Its siblings were game languages: BlitzBasic drew 2D sprites, Blitz3D drew 3D ones. BlitzPlus asked what happened if the same compiler — the same one-button IDE, the same BASIC with C-flavoured functions and records — could also produce an ordinary Windows application, with menus, tree views, tabbed dialogs and an HTML control, and without any of the ceremony that building a native GUI usually required in 2003.

Released by Mark Sibly’s Blitz Research Ltd in February 2003 for USD$60, it succeeded the 2D BlitzBasic product and sat alongside Blitz3D rather than replacing it. It was never the flagship — BlitzMax arrived less than two years later and took the company’s attention — but the GUI model it introduced, an event-driven system of Gadgets, was good enough that Blitz Research sold it a second time, ported into BlitzMax as the commercial MaxGUI module.

History and Origins

The Blitz lineage runs from the Commodore Amiga, where Sibly’s Blitz BASIC and the Acid Software-published Blitz BASIC 2 proved a compiled BASIC could ship commercial action games, to Auckland, where Mark Sibly’s Blitz Research Ltd brought the idea to Windows as BlitzBasic, published by Idigicon in October 2000. Blitz3D followed in 2001 with a DirectX 7 scene graph bolted onto the same dialect.

That left the 2D product stranded. Blitz3D got the engineering attention; BlitzBasic was the cheaper, older thing you bought if you did not need 3D. BlitzPlus is the answer to that, and the company’s own press release — datelined Auckland, New Zealand, 13 February 2003 — describes it in exactly those terms:

In the time honoured tradition of home computer programming, BlitzPlus provides a friendly integrated program editor with a smart fast BASIC compiler sporting 90 new GUI commands, increased compatbility with legacy Windows machines running NT4.0 and some smart new improvements ‘under the hood’ for increased creative control.

Three things in that sentence are the whole product. Ninety new GUI commands is the headline feature. Compatibility with legacy Windows is the strategic bet: where Blitz3D demanded DirectX 7 and a 3D accelerator, a BlitzPlus executable was advertised as running on anything from Windows 95 or NT 4 upward, because its renderer was pure 2D blitting rather than textured quads on a 3D card. And “under the hood” covers the graphics-driver rework that eventually gave BlitzPlus a choice of DirectDraw, GDI and experimental OpenGL back ends.

A month later, on 12 March 2003, Blitz Research announced it had become the sole official distributor of its own products, ending third-party retail. The shop page from that period is a fair snapshot of the company: Blitz3D at $100, BlitzPlus at $60, the Maplet modeller at $25, all download-only, all through a shareware payment processor.

Design Philosophy

The whole GUI is handles and one event loop

BlitzPlus has no forms designer, no visual inheritance, no resource compiler, no message map. A window is an integer. A button is an integer. You create gadgets with CreateWindow, CreateButton, CreateTextField, CreateTreeView; you call WaitEvent(); you compare its return value against an event constant and EventSource() against your gadget handles. That is the entire model, and it is small enough to hold in your head.

Here is the shape, taken from the documentation’s own example for CreateButton:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

; first, let's create a window
WinHandle = CreateWindow("Dessert Menu", 0, 0, 400, 250)

; now create some buttons
OptionButton1 = CreateButton("Apple Pie",   50, 10,  300, 40, WinHandle, 3)
OptionButton2 = CreateButton("Cheesecake",  50, 40,  300, 40, WinHandle, 3)
Checkbox      = CreateButton("With Cream",  50, 70,  300, 40, WinHandle, 2)
ExitButton    = CreateButton("Place Order", 50, 120, 300, 40, WinHandle)

; now loop and deal with events as they arise
Repeat
    If WaitEvent() = $401 Then
        If EventSource() = ExitButton Then Exit
    End If
Forever

msg$ = "You selected "
If ButtonState(OptionButton1) Then
    msg$ = msg$ + "Apple Pie "
ElseIf ButtonState(OptionButton2) Then
    msg$ = msg$ + "Cheesecake "
Else
    msg$ = msg$ + "Nothing "
End If
If ButtonState(Checkbox) Then msg$ = msg$ + "with cream"
Notify msg$
End

Compare that with what a native Win32 application, an MFC project or even a Visual Basic 6 form required in 2003 and the appeal is obvious. The cost is equally obvious: raw hexadecimal event IDs, a flat namespace of integers, and no structural help whatsoever once the program grows past a few dozen gadgets. The community filled the first gap with constant files and the second with GUIde, a visual form editor written in BlitzPlus that generated the CreateGadget calls for you.

Blitting, not texturing

Blitz3D’s 2D commands drew through the 3D pipeline. BlitzPlus went the other way. Its product page put the reasoning plainly: the engine is “based on ‘pure’ 2D blitting operations, as opposed to faked 3D ones”, which gives “pixel-perfect graphics” and compatibility “with virtually all graphics cards, 2D or 3D”. The same page claimed the engine could perform “thousands of blitting operations per second” — a vendor statement with no published benchmark, no stated hardware and no baseline behind it, so it is best read as marketing rather than as a measurement.

What is verifiable from the source tree is the architecture that claim rests on: BlitzPlus ships separate graphics drivers for DirectDraw, Windows GDI and OpenGL, selectable at runtime through CountGfxDrivers and SetGfxDriver. A program that cannot get DirectDraw can still put pixels on screen.

Two worlds, one language

The command reference is split down the middle: roughly 368 documented 2D/system commands — graphics, images, sound, banks, files, TCP/IP, maths, string handling — and about 145 GUI commands in the shipped help, comfortably justifying the “over 500 commands” on the box. The bridge between them is the canvas gadget: a drawing surface that lives inside a window like any other gadget, rendered to with the ordinary 2D commands and presented with FlipCanvas. A BlitzPlus program can therefore be a game in a fullscreen Graphics mode, a conventional tool with menus and list boxes, or a tool with a realtime viewport embedded in it — which is exactly what a level editor is.

A small language, on purpose

The language is BlitzBasic’s, unchanged in essentials: BASIC type suffixes (%, #, $), Type records with Field members accessed through the backslash operator, functions, Include files, Goto and Gosub still present for the traditionalists, and banks for raw memory. The vendor described it as a “BASIC/C hybrid”. There are no classes, no inheritance, no exceptions, no modules. That ceiling is precisely what BlitzMax was created to raise.

1
2
3
4
5
6
7
8
9

Type Task
    Field title$
    Field done%
    Field priority#
End Type

For t.Task = Each Task
    If Not t\done Then AddGadgetItem list, t\title$
Next

Key Features

That last row matters more than it looks. QueryObject is the escape hatch — it hands you the real Win32 handle, so anything the Gadget system did not wrap could still be reached through the Windows API via a userlib.

Evolution

BlitzPlus’s own versions.txt runs from V1.10, marked “Initial release version!”, to V1.47, and — exactly like Blitz3D’s — it never dates a single release. The arc is nonetheless legible from the content:

• V1.10–V1.11 — the initial release and immediate fixes.
• V1.20 — a “major internal rearrangement”: the three image memory policies (managed, dynamic, scratch) arrive, scaled windowed Graphics is removed in favour of canvases, and the runtime splits into release and debug DLLs.
• V1.26 — the alternate graphics drivers (OpenGL and a DIB/GDI driver, reached through CountGfxDrivers/SetGfxDriver) and QueryObject, which hands back the underlying Win32 HWND and is described in the notes as “intentionally ugly to remind users they’re going ‘outside’ of Blitz”.
• V1.34, flagged “Public Release!” — the roll-up of everything since the last public build: settable gadget fonts, text area formatting, mouse enter/exit events, icon strips for list boxes, combo boxes and tabbers, hot keys, plus the QueryObject and OpenGL/native driver work from the interim releases, which the notes honestly describe as “highly experimental”.
• V1.39 — the HTML view grows up: navigation and context-menu style flags, HtmlViewCurrentURL, HtmlViewStatus and HtmlViewRun for executing JavaScript in the embedded browser; tree view nodes gain icons; FMOD is updated to 3.72.
• V1.40–V1.43 — Windows catching up with the compiler: a fix for Data Execution Prevention under Windows XP Service Pack 2, and a second DEP fix in the linker.
• V1.47 — the last entry, fixing an End command that raised a “Wrong Thread” error on 64-bit Vista, and an out-of-range return from rand().

Meanwhile the product itself was being quietly superseded. BlitzMax shipped in December 2004 for Mac OS X, with Windows and Linux in May 2005, and by November 2005 Blitz Research was selling MaxGUI as a $25 BlitzMax module — sold, in the company’s own words, on the fact that it “provides many of the same easy to use Gadget based commands found in BlitzPlus”. BlitzPlus users were being shown the door politely, with their vocabulary carried across.

The last acts were archival. In late April 2014 Blitz Research posted “BlitzPlus Source Code Released” and put the C++ source out under the zlib/libpng licence — the site news item is stamped 29 April, although the release is commonly dated 28 April. Blitz3D followed roughly three months later, on 3 August. In September 2017 the source reappeared as blitzplus_msvc2017, retargeted from the original MSVC 6-era project to Visual Studio Community 2017, with a README pointing anyone who would rather not build it at the prebuilt download.

Current Relevance

BlitzPlus is dormant, and more thoroughly so than Blitz3D. Blitz3D got a genuine revival in 2024, with UTF-8 support, an FMOD-to-SoLoud audio swap and the first new language keyword in two decades; BlitzPlus got none of that, and Mark Sibly’s death in December 2024 closed the possibility. As of September 2026 the Blitz Research itch.io profile lists Blitz3D, Monkey 2, Monkey X and Skirmish — but no BlitzPlus page, so the open-source repository is now the primary route to the compiler.

What remains alive is smaller and more specific:

• The source builds, from a 2017 Visual Studio project, under a permissive licence, with the whole runtime — compiler, linker, IDE, debugger, graphics drivers — in the tree. As a compact, complete, readable example of how a commercial BASIC compiler and its Windows runtime were actually put together, it is unusually good reading.
• Tooling still appears. B3DDecomp, a decompiler for Blitz3D and BlitzPlus executables, was still receiving commits in January 2026.
• Community code collections such as the blitzplusexamples repository were still being updated in December 2024.
• And the gadget vocabulary persists wherever BlitzMax and MaxGUI code does: CreateWindow, CreateButton, SetGadgetText, WaitEvent, EventSource are BlitzPlus names that a BlitzMax programmer writes without knowing it.

Nobody should start a new desktop application in BlitzPlus. It targets a Windows GUI that Microsoft has reskinned three times since, it has no path off Windows, and the underlying language has no way to organise a large program. But the compiler targeted plain Win32 and DirectDraw, so BlitzPlus executables built in 2004 are generally reported to still run on current Windows — a claim much of its 2003 competition cannot make.

Why It Matters

BlitzPlus is a small, clear argument about where a GUI belongs. In 2003 the mainstream answers were a visual designer generating code you did not read (Visual Basic, Delphi), or a framework demanding a class hierarchy and a message map before it would draw a button (MFC, and soon WinForms). BlitzPlus said: it is twenty commands and a loop. You create things, you wait for events, you ask which thing the event came from. A teenager who had learned the language to make a Breakout clone could write a working tool with a tree view and a file requester the same afternoon, and never once meet a WndProc.

That idea did not die with the product. Immediate-mode and handle-based UI toolkits have since become respectable — the industry spent twenty years discovering that the retained-mode, designer-generated, class-hierarchy approach is not the only serious option. BlitzPlus reached the same conclusion for pragmatic reasons in a BASIC dialect sold for sixty dollars, and Blitz Research thought enough of it to rebuild it for three operating systems under a different name.

It also completes the picture of what the Blitz family was actually for. Blitz3D is remembered because SCP – Containment Breach is famous. BlitzPlus is remembered by the people who used it to build the level editor, the sprite packer, the map converter and the launcher — the unglamorous software that surrounds a game and that nobody writes a retrospective about.