DarkBASIC Professional

DarkBASIC Professional is a BASIC dialect built for one purpose: letting someone who has never opened a DirectX header put a textured, lit, moving 3D object on screen before losing interest. Released in 2002 by The Game Creators as the successor to their 2000 product DarkBASIC, it paired a conventional structured BASIC with a command library of what marketing materials described as more than a thousand game-oriented statements - make object cube, load image, play sound, set camera to follow - and a compiler that turned the whole thing into a standalone Windows executable. For roughly a decade it was one of the most common ways a hobbyist with a Windows PC and no C++ ever got a 3D game running, and when its commercial life ended, its publisher released the source under the MIT license rather than let it disappear.

History and Origins

Dark Basic Software Limited was incorporated in England on March 24, 1999 by Lee Bamber and Richard Vanner; the company later traded as The Game Creators. Their first product, DarkBASIC, arrived in 2000. It is generally described as standing in the tradition of AMOS on the Amiga and STOS before it - BASICs whose selling point was not the language but the built-in commands for sprites, sound and screen handling that made a home computer feel programmable for games. DarkBASIC’s contribution was to do the same for Microsoft’s DirectX, then at version 7, on the PC.

The original had a structural weakness. Its IDE, debugger and runtime were built around an interpreter, and the “compiled” executable it produced was, in effect, the program bundled with a copy of the interpreter. That was fine for 2D sprite games and simple 3D, but it was widely held to limit performance and it made the product hard to extend. No published head-to-head benchmarks between the two products appear to survive, so the size of the gap is a matter of contemporary claim rather than measurement.

DarkBASIC Professional, released in 2002, was a ground-up replacement rather than an upgrade - so much so that the two were sold side by side and the older product acquired the retroactive name “DarkBASIC Classic”. The Professional compiler produced a real executable, the engine was rebuilt against a newer DirectX generation (contemporary sources describe it as originally targeting DirectX 8.1 and later updated to DirectX 9.0c), and the command set was made extensible through a plugin mechanism. The two products were not source-compatible in any general sense; a substantial amount of Classic code needed rework to move across.

Design Philosophy

The design assumption behind DarkBASIC Professional is that the hard part of game programming for a beginner is not control flow - it is the enormous amount of setup ceremony between “I want a cube on screen” and a cube on screen. The language’s answer is that essentially everything is a global command with a plain-English name and a numeric handle:

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

sync on
sync rate 60

make object cube 1, 10
position object 1, 0, 0, 0
position camera 0, 10, -40
point camera 0, 0, 0

do
    yrotate object 1, object angle y(1) + 1
    sync
loop

Three things in that fragment are characteristic. First, objects, images, sounds and sprites are identified by integers you choose yourself rather than by variables holding references - object 1 is object 1 for the life of the program, which is conceptually simple and, in a large program, a genuine source of bugs. Second, sync on plus an explicit sync in the loop is the whole of the frame model: the engine stops auto-updating the display, and each sync presents a frame. Third, the multi-word command names (object angle y, point camera) read as English rather than as an API, which is exactly the trade the product was making.

The BASIC itself is unremarkable by design, and that is the point. It has if/then/else/endif, for/next, while/endwhile, repeat/until, do/loop, gosub, user-defined functions with function/endfunction, arrays, and user-defined types. Typing is static but weak, with the traditional BASIC sigils - a trailing $ for strings, # for floats - alongside explicit declarations. Nothing in the language asks the programmer to learn a new idea; all the novelty is in the command library.

Key Features

Native compilation with bundled plugins. The most significant technical change over Classic. The DarkBASIC Professional compiler emits an executable rather than shipping an interpreter, and it scans the program to decide which command DLLs are actually needed, bundling those into the output. The result is a single distributable .exe with no runtime installation step for the end user, and it was the basis of the marketing claim that Professional outperformed its interpreted predecessor - a claim that was not, as far as the surviving material shows, backed by published benchmarks.

Plugins as ordinary DLLs. A plugin is a DLL carrying an embedded string resource that describes the routines it implements; the compiler reads that description to resolve the new commands at compile time. This was unusually open for a beginner-oriented tool, and it produced a real third-party market - physics wrappers, GUI libraries, extended networking, advanced rendering packs - as well as a route for competent users to drop into C++ when the built-in commands ran out.

A broad DirectX-backed 3D and 2D feature set. Capabilities listed in the product’s own documentation and marketing include BSP level loading, vertex and pixel shaders, real-time stencil shadows and reflections, lights and matrices, terrain, multiple camera views, a particle system, polygon-level collision detection, bump, light and environment mapping, and multitexturing, alongside hardware-accelerated sprite commands built on Direct3D rather than on the older 2D paths.

Batteries beyond graphics. The command set covers sound and music, file and memblock access, multiplayer networking, basic 3D maths and vertex manipulation, and built-in queue and stack containers - enough that a complete game rarely needed anything outside the language.

Evolution

DarkBASIC Professional’s commercial arc looks less like a language’s evolution than a product line’s. Rather than growing the BASIC, The Game Creators grew outward from the engine: FPS Creator (2005) offered the same audience a drag-and-drop level builder with no code at all; Dark GDK (2007) exposed the DarkBASIC Professional engine as a C++ library for Visual Studio, letting the command set be used from a mainstream language; and AppGameKit (first released around 2011) carried the “simple scripting plus game command library” idea onto mobile and cross-platform targets, which is where the market had gone. GameGuru (announced in 2013 as FPS Creator Reloaded) and GameGuru MAX (early access March 2022, full release April 2023) continued the no-code branch.

The language itself was maintained through a long tail of patches and upgrades, including the move to DirectX 9.0c, but it remained a 32-bit, Windows-only, DirectX-bound product to the end - a limitation that became decisive as Windows game development moved to 64-bit toolchains and newer graphics APIs.

The last act was unusual and to the company’s credit. By The Game Creators’ own account, the company decided at the start of 2016 to open-source DarkBASIC Professional under the MIT license and hand it to the community, specifically to stop it becoming unsupported abandonware; FPS Creator was opened up around the same time. Two prebuilt binaries requiring no activation were posted to the GitHub releases page in February 2016 - the second, dated February 12, adding certificates so owners of previously purchased plugins could keep using them. Anyone building from source, however, meets the era head-on: the Visual Studio solution in the repository expects the Microsoft DirectX SDK from August 2007.

Current Relevance

DarkBASIC Professional is dormant rather than dead. There is no vendor development, but the MIT-licensed source is on GitHub with an active fork network, and compiled DarkBASIC Pro programs are generally reported to still run on current versions of Windows, since the legacy DirectX 9 end-user runtime remains separately installable. Microsoft does not document DarkBASIC Pro compatibility, so this should be treated as community experience rather than a supported configuration.

The most interesting activity is elsewhere. OpenDarkBASIC is a from-scratch reimplementation of the language and SDK: it parses DarkBASIC Pro source with FLEX and BISON into an AST and generates native machine code through LLVM, with a plugin-based runtime, optimization passes and AST visualisation tooling. Its stated goal is a cross-platform DarkBASIC that can either drive the original Windows-only DBP SDK or a clean reimplementation of it, and its README gives build instructions for Linux, Windows and macOS - with Windows builds producing a 32-bit DarkBASIC runtime alongside a 64-bit compiler for compatibility with the original SDK, while only 64-bit executables are built on macOS and Linux. That README is candid that the project is under heavy development and that attempts to compile the bundled example code will most likely fail, so it should be read as a serious in-progress preservation effort rather than a drop-in replacement.

For anyone starting a game today, the honest recommendation is Godot, Unity, or the company’s own AppGameKit lineage. DarkBASIC Professional’s remaining audience is people maintaining old projects, people reading the source to understand how a mid-2000s BASIC-to-native game compiler was actually built, and the preservation community.

Why It Matters

DarkBASIC Professional matters for two reasons that have little to do with the language design.

The first is pedagogical. It is a clean case study in a specific bargain: hide the API entirely, give every operation an English name, accept a globally-numbered resource model and weak typing, and in exchange let a beginner reach a rotating textured cube in six lines. That bargain produced a generation of hobbyist developers who learned loops, conditionals and functions because a spaceship moved when they got them right. The same bargain is visible in AMOS before it and in Godot’s GDScript, Roblox’s Luau and AppGameKit after it; DarkBASIC Pro is the DirectX-era instance of it, and one of the last built around a BASIC.

The second is preservation. Commercial languages usually die silently: the vendor stops selling, the activation servers go dark, and the tool becomes unusable long before it becomes uninteresting. DarkBASIC Professional’s publisher did the opposite - open-sourced the compiler, engine and IDE under a permissive license, shipped activation-free binaries, and issued certificates so paying plugin customers were not stranded on the way out. That decision is why OpenDarkBASIC can exist at all, and it is a better ending than most commercial development tools of its era received.