DiNGS Game Basic

DiNGS Game Basic was a shareware BASIC for writing 2D games on Windows, sold from Germany by a one-man operation called Dream Design at 40 EUR (50 US$ outside Europe) for the full licence. It compiled to standalone .exe files through GNU GCC, drew everything through OpenGL, shipped with a beginner’s tutorial and a pile of playable sample games with source, and had a small showroom of user-made titles. Its most unusual feature is not technical: in March 2002 its author announced that the language was finished, froze the code, and moved on to build its 3D successor. That successor became GLBasic, which is still offered commercially - which makes DiNGS the rarely-preserved first draft of a commercial language that outlived it by more than two decades.

History and Origins

DiNGS was the work of Gernot Frisch, whose German site Dream Design (dream-d-sign.de) is first archived in October 2000. The site’s other content explains where the language came from: alongside DiNGS it hosted a set of Frisch’s own QBasic games - Magicgal, Quirk, Splash, Triptris, Dr. Borotnics - and blit.bas, an assembly-accelerated sprite blitting library for QBasic’s SCREEN 13 co-credited to Andrew L. Ayers. DiNGS is what happens when someone who has spent years fighting QBasic’s graphics limits decides to write the tool they wanted instead.

Dating the first release precisely is not possible from surviving material. The archived product pages and news items only reach back to mid-2001, by which point DiNGS is already a mature, stable, commercially sold product; the copy distributed by the WinWorld software archive is labelled “DiNGS Game Basic Development Kit 5.10522” and dated 2001. Dream Design’s version numbers appear to encode a build date after the major number - the companion utility ClipMagic is versioned 4.10129 in the same era - which would read 5.10522 as a major version 5 built on May 22, 2001. Reaching a fifth major version by mid-2001 implies development beginning around 1999-2000, and the GLBasic version history’s description of its own v1.2 as “the DiNGS Game Basic sequel” places DiNGS earlier still. Around 2000 is the honest answer; anything more precise would be a guess.

The sales pitch, preserved almost identically in German and English on the site, is worth quoting because it frames the whole design:

Why no Game-Creator? With these packages only a clone of an existing game can be created. Not with DiNGS Game Basic, which is a fully significant programming language especially for games. Why not C++, Pascal or ASM? Well, these are great languages if known how to code. But how long will it take to get this knowledge?

That is the entire positioning in three sentences: more expressive than a click-together game maker, far less work than learning C++ and building an engine.

Design Philosophy

DiNGS is a plain structured BASIC wrapped around a game command set, with three commitments that show up everywhere in the surviving code.

One screen model, one flush. Drawing commands paint an off-screen buffer and SHOWSCREEN presents it; BLACKSCREEN clears. Frame rate, resolution and fullscreen mode are not code at all - they are project settings, stored in the header of the .src project file next to the executable name. A beginner never writes a window creation call, a double-buffer swap, or a frame limiter.

Numbered resources. Sprites, fonts and sounds are loaded against integer IDs you choose (LOADSPRITE name$, 3) and drawn by ID (SPRITE 3, x, y, frame). This is the same trade DarkBASIC and its relatives made: conceptually trivial, and a real source of bugs once a program grows.

Types get out of the way. Strings carry a trailing $ and everything else is numeric, and the two convert automatically in expressions, so PRINT "Level:"+gLevel, 0, 32 simply works. GLBasic inherited this behaviour and documents it as a headline feature.

Here is genuine DiNGS code, from the map editor sample Dream Design distributed with the language:

 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
28
29
30
31
32

DIM gBlockName$[100]
DIM gMap[100][100]

GOSUB Options
GOSUB SelectBlock

main:
	GOSUB ShowArea
	GOSUB MousePointer
	// Block that the mouse pointer is over
	bx=gMx/gBlockSize + gScreenX
	by=gMy/gBlockSize + gScreenY
	IF gMb1=1 THEN gMap[bx][by]=gCurrentBlock
	IF gMb2=1 THEN GOSUB SelectBlock

	// Left arrow
	IF KEY(203)=1
		gScreenX=gScreenX-1
		IF gScreenX<0 THEN gScreenX=0
	ENDIF

	PRINT "Level:"+gLevel, 0, 32
	SHOWSCREEN
GOTO main

// ------------------------------------------------------------- //
// -=#  MOUSEPOINTER  #=-
// ------------------------------------------------------------- //
SUB MousePointer:
 MOUSESTATE gMx, gMy, gMb1, gMb2
 PRINT "<=", gMx, gMy
ENDSUB // MOUSEPOINTER

Several things stand out. Comments are //, not REM or ' - a C-flavoured choice unusual in BASIC. Statements can be separated by ; on one line, so terse code like gLevel=gLevel+1; IF gLevel>99 THEN gLevel=0 is idiomatic. Arrays are declared with DIM and indexed with square brackets, including multi-dimensional ones. IF works both as a one-line THEN form and as a block ending in ENDIF, with WHILE/WEND and FOR/NEXT alongside. And the structure is transitional in a very 2001 way: SUB/ENDSUB procedures exist, but they are entered with GOSUB and mixed freely with bare labels and GOTO.

The same file shows the language’s charmingly blunt file I/O: PUTFILE name$, 1, gNumBlocks and GETFILE name$, 1, value read and write a numbered line of a text file, with GETFILE returning the sentinel string "NO_FILE" when the file is absent. There are no file handles.

Key Features

Dream Design’s own feature list, in the wording used on the site:

Two claims from that list deserve care. The performance claim (“incredibly fast”, and later “even faster thanks to internal optimization”) appears in marketing and news copy with no published benchmark - no measurement, baseline or test conditions survive, so it should be read as a vendor claim rather than a result. The compatibility claim is better supported, because it was a repeated and specific promise: games built with DiNGS were advertised as running on Windows NT 4, 2000 and XP, sound was routed through DirectX specifically so it would work on NT 4, and the networking commands were held back until they too worked there. In 2001, when a great many game-oriented BASICs assumed the Windows 9x line, that was a genuine differentiator.

Distribution was classic shareware. The full SDK - about 6 MB, “fully functional, all commands available” - was free to download, with a nag message in produced programs and the music functions locked. Registering for 40 EUR unlocked music playback and the right to redistribute and sell games without the shareware text. For anyone whose connection could not face 6 MB, Dream Design would post a CD for the cost of postage.

Evolution and the Deliberate Ending

The archived news page reads as a compressed portrait of a solo commercial language: bug fixes for 8-bit bitmap loading and BOXCOLL with negative coordinates, a summer competition run over the school holidays with a new language command as the prize, an apology that the forum broke while the author was on holiday, and a note that support requests filed in August would be answered in September.

Then, on March 23, 2002, an entry that almost no commercial language ever posts. It opens by asking whether readers have noticed that nothing new has arrived for a long time, answers “correct”, and announces a code freeze: no bugs have been found in DiNGS for a long time, it runs stably on all Win32 systems, and - in his words - they created what they wanted, a good, fast, simple programming language for 2D games. “A good moment to stop.” Support and bug fixes would continue; features would not. The 3D version already in development would be a new product under a new name rather than a replacement, so that both would be available, and registered DiNGS users were offered a cheap upgrade path to it.

One more entry followed, a fullscreen quickfix on October 10, 2002, and then the page stood still. It was still being served, unchanged, years later.

The 3D successor became GLBasic, whose published version history describes v1.2 as “the DiNGS Game Basic sequel”. The continuity is not just marketing: GLBasic kept the BASIC-with-a-game-command-set shape, kept automatic conversion between strings and numbers, and kept the compile-through-C++-and-GCC architecture, its “GPC” precompiler emitting C++ that GCC then builds. Where DiNGS was Windows-only and 2D, GLBasic went 3D and, over the following decade, cross-platform - documented targets over its life include Windows, Linux, macOS, iOS, Android and a series of handhelds - and it was later distributed on Steam. Dream Design’s website itself converted from a DiNGS site into a GLBasic site, which is why so little of the original survives.

Current Relevance

DiNGS Game Basic is dormant in the strictest sense: development ended by the author’s own decision in 2002, the product was superseded rather than abandoned, and it was never open-sourced. The compiler and IDE survive mainly through the WinWorld software archive’s copy of build 5.10522, and the language’s documentation, sample games and community showroom survive only as Internet Archive captures of dream-d-sign.de. Whether the 2001 toolchain still installs and builds on a current Windows release is not something any vendor documents, and no such claim should be made on its behalf.

Anyone drawn to what DiNGS offered should look at GLBasic, which is its direct descendant and, as of this writing, still commercially available. The interest in DiNGS itself is historical.

Why It Matters

DiNGS matters less as a language than as a specimen, for two reasons.

The first is that it is a well-preserved example of a category that has almost entirely vanished: the solo-authored, shareware-distributed, regionally-marketed game BASIC of the late 1990s and early 2000s. Blitz Basic and DarkBASIC are the survivors people remember; behind them stood dozens of smaller efforts sold for tens of euros by one person with a website, a forum, a summer competition and a CD-by-post option. Most left nothing. DiNGS left a news page, a showroom, a map editor’s full source and a feature list, which together make it possible to reconstruct not only what the language did but what running it as a business felt like.

The second is the ending. Software is almost never declared finished; products are abandoned, acquired, rewritten or left to rot, and the vocabulary for “this does what it should, so I am stopping” barely exists in the industry. DiNGS Game Basic’s author wrote that entry in March 2002, kept supporting the product, and spent the effort on a successor instead - a successor still being sold twenty years later. As endings for a small commercial language go, it is a considerably better one than most.