AppGameKit

AppGameKit (originally styled App Game Kit, usually shortened to AGK) is a game-development kit from The Game Creators, the British company behind DarkBASIC and DarkBASIC Professional. It keeps the approach of those earlier products: a simple BASIC-family language plus a large library of game commands. The difference is the target. DarkBASIC Professional was tied to Windows and DirectX, while AGK was built for a world of phones, tablets and app stores. You write the game once, the IDE compiles it to bytecode, and a small native “player” runs that bytecode on each platform. That BASIC layer is Tier 1, and its language is now called AppGameKit Script. Under it is Tier 2, the same engine as a C++ library, for developers who want native projects in Visual Studio or Xcode.

History and Origins

The Game Creators say they began building AGK in 2010. A holding page on appgamekit.com, archived in December 2010, announced “App Game Kit - Coming 2011”. It pitched the product as a “truly frictionless cross platform solution, removing the need to learn complex APIs”: a friendly IDE, a fast 2D engine native to each platform, resolution independence, built-in physics and “access to full source code”.

The company’s newsletter for August 2011 (issue 103) called it “AGK release month”. It set the release of the Community Edition for 15 August 2011, with pre-orders taken before that date. The launch feature list included:

• compilation for Windows, Mac, iOS, Samsung Bada and MeeGo
• both Tier 1 (BASIC) and Tier 2 (native C++ libraries)
• an OpenGL-based 2D engine with sprites, Box2D physics and particles
• input from touch, keyboard, mouse, accelerometer and joystick
• sound, music and simple networking through broadcast messages and shared variables

The newsletter promised Android “in the near future”. By the time of the V2 Kickstarter in mid-2013, the supported list had become iOS, Android, Windows, Mac and BlackBerry, with the OUYA console added as a stretch goal.

The 2011 date in the encyclopedia is therefore correct. A few earlier dates also exist: the kit was announced in 2010 and development started that year, but no public release was made before August 2011.

How It Works: Tiers, Bytecode and Players

The two-tier design is the main architectural idea in AGK.

Tier 1 is the BASIC. The IDE compiles a project to bytecode. The V2 Kickstarter page says that bytecode is then run “through special players that we have created for the support platforms (iOS, Android, Windows, Mac, Blackberry)”. While you develop, you install the AGK Player on a phone or tablet, press “Compile, Run and Broadcast” in the IDE, and the code and media go over Wi-Fi to every waiting device. Unchanged media is not re-sent. For release, the help system includes step-by-step guides to preparing a Tier 1 app for submission to each store.

Tier 2 is the same command set exposed as C++. Functions live in an agk:: namespace, such as agk::CreateSprite and agk::SetSpritePosition. You call them from a normal native project, which gives you the engine without the interpreter and lets you mix in any other C++ code.

The two tiers also meet through plugins. The AppGameKit Studio documentation describes Tier 1 plugins as DLLs on Windows, .so files on Linux and .dylib files on Mac. A plugin can be written in any language that can export such a library. A Commands.txt file maps each Tier 1 command name to the exported function symbols, and inside the plugin you can call the full agk:: API.

The Language

AppGameKit Script is a modern, structured BASIC. It is readable to anyone who knows DarkBASIC Professional, but it is cleaner and much more regular. Commands are ordinary function calls with parentheses, and a do/loop with Sync() drives the frame loop:

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

type playerType
    score as integer
    lives as integer
    name  as string
endtype

player as playerType
player.name  = "player 1"
player.lives = 3

CreateSprite(1, 0)
SetSpriteSize(1, 100, 100)
SetSpritePosition(1, 10, 100)
SetSpriteColor(1, 255, 0, 0, 255)

do
    print(player.name)
    print(player.score)
    sync()
loop

As in DarkBASIC, sprites, images and sounds are identified by integer IDs. The language itself is typed more strictly than older game BASICs:

• Variables are integers by default. Floats and strings must be declared with as, for example shipSpeed as float = 0.47 or playerName as string = "player 1".
• User-defined types group fields with type … endtype and are accessed with a dot. They are records, not classes: AppGameKit Script has no methods, inheritance or constructors. The master list labels the language “Procedural, OOP”. That is accurate only if you count the C++ Tier 2; the BASIC itself is procedural.
• Functions can take types and arrays by value or by reference, using ref, as in function move(p ref as point).
• Arrays were reworked in V2. The new declaration form is myArray as integer[5], and the old DIM still works for backward compatibility. Arrays can be resized through .length and grown or shrunk with .insert() and .remove(). They can be sorted with .sort(), binary-searched with .find() (which needs ascending order), and converted to and from JSON with .toJSON() and .fromJSON(). They can also be saved to and loaded from a file, and they can be fields inside types.

One oddity is inherited from older BASICs: an array declared with size n has n + 1 elements, indexed 0 to n. .length returns n, so an empty array reports a length of -1. The official guide suggests beginners ignore index 0 at first so that the length matches the number of elements they use.

Evolution

The Kickstarter page set out a phased roadmap: 2D improvements and OUYA/Spine support in October 2013, IDE and compiler updates in December 2013, 3D in January 2014, physics in February 2014 and Windows Phone 8 in May 2014. The V2 release on Steam came in November 2014, later than that schedule. This article does not claim that every item on the roadmap shipped as described.

AppGameKit Studio keeps the same two tiers (the retirement notice for Classic says so) and the same script language, but everything around it was new. On Steam the Studio is described as an all-in-one workspace. It has live debugging with watch lists, an asset browser for images, 3D models and audio, editing and testing of both OpenGL and Vulkan shaders, and a drag-and-drop scene editor that previews layouts across device resolutions. Its Steam listing covers Windows and macOS, with 64-bit Windows 10 as the minimum Windows version.

Current Relevance

AppGameKit is still active, but it now runs on a much smaller scale. Its Steam news feed shows a pattern:

• April 2024: the Studio source and build instructions went onto GitHub, and the next update was built from that repository.
• 22 May 2024: AppGameKit Classic was taken off sale, after what the announcement called “a decade of providing support and updates”. Existing copies keep working, though the notice warns that exported apps will find it harder to meet future app-store requirements.
• May-June 2025: Dark Basic Software Limited acquired AGK Studio, GameGuru MAX and related IP from TheGameCreators.
• Through 2026: builds are increasingly credited to community contributors. The most recent at the time of writing is build 2026.08.06, which fixes IDE crashes and auto-indentation and moves to Google Billing 8.3.0.

The GitHub repositories are source-available, not open source. The Studio repository (AGKRepo) declares no open-source license, and the AGKClassic repository says outright that it “is NOT an open source project”. It allows you to compile Tier 2 for your own use under the EULA, but not to redistribute builds or use the code in a competing product. That is a real difference from DarkBASIC Professional, whose source the same company put on GitHub under the MIT license (the repository and its license file date from November 2015).

Most of the maintenance work is keeping up with the mobile stores. The current build notes cover Android API 35 targets, Google Billing library versions and iOS export fixes, because a cross-platform kit is only useful while its exported apps are still accepted by the stores it targets.

Why It Matters

AppGameKit is the point where the “BASIC plus a big game command library” tradition moved from home computers and desktop DirectX to the smartphone. It followed a line that runs from STOS and AMOS through DarkBASIC and DarkBASIC Professional. AGK kept the easy on-ramp of that tradition but changed two things. Tier 1 compiled to portable bytecode, so the same program could run on any device with a player. Tier 2 was the same engine as a plain C++ library, so hitting the limits of the BASIC did not mean switching engines.

Its Wi-Fi broadcast to on-device players was also a practical answer to a problem mobile beginners had in 2011: testing on real hardware without setting up a separate toolchain for each platform. Its language is less important than its workflow, and its fate shows how a small commercial tool survives: it moved to Steam, released its source under a restrictive license, changed owners, and now depends on community-contributed builds.