KonsolScript

KonsolScript is a free scripting language for writing 2D games. Mj Mendoza IV started it in the Philippines in 2005. Its syntax follows C: curly-brace functions, for and while loops, and a main() entry point. Its library is grouped into colon-qualified namespaces such as Screen:, Draw:, Sound: and Konsol:. Scripts in .ks files were compiled to .konsl bytecode, which ran on one of the project’s own engines: FreeKE first, then Quixie, on Windows and GNU/Linux. Together with an editor and level tools, the language made up KAGE, a do-it-yourself 2D game development kit. Its users were mostly hobbyists and students. KonsolScript is a small, well-documented example of something common in the 2000s: a game language built mainly by one developer, offered as free software, and kept alive for years by a small volunteer community.

History & Origins

Beginnings (2005-2006)

Mendoza gave the history himself in a November 2008 anniversary post on the project blog. The exact date was not recorded, but “the first official build was compiled sometime around November 2005”. File timestamps put the first lines of engine code in early August of that year. A year later the “4 years old” post dated the anniversary from KonsolScript’s first “Hello World”. The encyclopedia’s catalogue lists 2003, but nothing found supports that. The author, the project’s copyright line (“2005-”) and secondary sources such as Rosetta Code and PLDB all give 2005.

The project’s Rosetta Code description says KonsolScript was distributed as freeware at first and released as free software on SourceForge in April 2006. SourceForge records the project’s registration as 7 April 2006. In August 2006 a “FreeKE Framework 0.2” appeared in its file area. FreeKE, published under Mendoza’s Krixware label, was the original engine. That name ran through every release until 2009.

FreeKE, Quixie and KAGE (2007-2009)

In September 2007 work began on a second engine called Quixie (pronounced “quick-see”). It was written in FreeBASIC and at first targeted GNU/Linux. Its Launchpad PPA described it in February 2008 as having most KonsolScript commands implemented but still “under development”. Later posts call Quixie the FreeBASIC port of FreeKE. FreeKE itself, judging by its published 0.2.27 source archive, was a Visual Basic 6 program that drew through DirectX 7, which explains why it was tied to Windows.

The FreeKE line kept moving. Version 0.1.90 in January 2008 shipped with a set of companion tools: the KonsolScript Editor (KSE 1.2.49), MapBuilder 0.1.82, EntityBuilder 0.1.20 and BMP2KS 0.1.42, a converter from bitmaps to KonsolScript data. The 0.2 series (0.2.15, 0.2.20, 0.2.25) followed through 2008. FreeKE 0.2.27, uploaded in March 2009, was the last FreeKE build. By the 0.4 era the downloads page reportedly offered FreeKE only “to support old games” and pointed new projects at Quixie.

Mendoza’s 2008 retrospective credits a handful of online collaborators: Veredus, Ionix, Podgod, Hero and Rags, “who’s faces I have never seen”. It also credits testers at two colleges in Nueva Vizcaya province. Hero designed the mascot, Ki-si (later spelled Kisi), a ninja pig.

Quixie takes over (2010-2012)

The project tried to grow in 2010. Brian Matheson, introduced on the blog as “a hacker from Washington, United States”, took over as maintainer of the KonsolScript Editor in January. In February the team posted an idea list for Google Summer of Code 2010, describing KAGE as Quixie, KonsolScript, the editor and MapBuilder. According to a later update to that post, KonsolScript, “along with 245 other organizations, was not accepted”. Quixie build 100402 (April 2010) added WAV, MP3 and OGG playback through DJ Peters’s FBSound library. In May a community installer for Arch Linux became the official package for that platform.

From the 0.3 series onward, Quixie was the official engine on both Windows and GNU/Linux. The 0.3 series ran to six builds in 2011: two pre-releases in January and May, then four public releases between July and November. The last of them, 0.3.111117, came out on what the blog called KonsolScript’s sixth anniversary. In January 2012 “KonsolScript 0.4 is out!” announced v0.4.120110. The post was frank that 0.4 was not a big improvement over 0.3. A month later v0.4.120210 shipped with a Windows installer, an i386 Debian package and a tarball. It is still the “latest” download on SourceForge.

Afterwards (2012-2020)

Around the same time the team was building a game of its own, Smack!, starring Kisi. They briefly discussed funding it by selling Smack! mugs, after the Blender Foundation’s pre-sold DVDs. After 2012 the blog slows down, and the focus moves to Kage Studio, a vector 2D animation program. In September 2018 the blog announced a beta of Quixie 0.5.0, described as a C++ port of the 0.4 engine. No 0.5 build appears in the SourceForge file area. Kage Studio reached early beta in January 2020. The project’s SVN history ends with Kage Studio commits in February 2020.

Design Philosophy

KonsolScript was meant to be easy to start with for people who wanted to make games, not study language design. A few choices show this:

• Familiar syntax. The language describes itself as “greatly inspired by C”. Anyone who has seen C, Java or JavaScript can read a KonsolScript loop.
• Games built in. Drawing, double-buffered screen output, keyboard state, images and sound are built into the language’s namespaces, not provided by add-on libraries. The basics tutorial points out that KonsolScript “handles a double buffer for you”.
• A complete kit. The language was never offered alone. It came with an engine, an editor, a map builder and asset converters, so a beginner could go from an idea to a playable demo without a C toolchain.
• Free and open. The project called itself “The Free and Open Game Programming Language”. It recruited contributors openly through its forums and blog.

Key Features

Namespaced built-ins

Standard functionality is reached through namespaces with a colon separator, such as Screen:PrintString, Screen:Render, Screen:GetFPS, Draw:Image, Array:GetLength and Konsol:Log. Declarations use the same style: Var:Number, Var:String, Array:New.

Hello World, the game way

The official tutorial’s first program prints into the back buffer and presents the frame until a key is pressed:

1
2
3
4
5
6
7

// HelloWorld - A traditional HelloWorld program in KonsolScript
function main() {
  while(lastpress == nochar) {
    Screen:PrintString("Hello World")
    Screen:Render()
  }
}

lastpress and nochar are built-in values for keyboard state. A second version uses the console header for text-mode output:

1
2
3
4
5

#include "console"
function main() {
  write("Hello World")
  end()
}

Explicitly typed variables and functions

Variables are declared with a type before use. Functions declare their parameter and return types:

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

function factorial(Number n):Number {
  Var:Number ret;
  if (n >= 0) {
    ret = 1;
    Var:Number i = 1;
    for (i = 1; i <= n; i++) {
      ret = ret * i;
    }
  } else {
    ret = 0;
  }
  return ret;
}

Arrays and user-defined types

Arrays are created with a fixed length and an element type. Compound types are declared with Var:Create:

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

Array:New array[3]:Number;

Var:Create(
  Point,
    Number x,
    Number y
)

function main() {
  Var:Number length;
  Array:GetLength(array, length)
  Konsol:Log(length)
  Var:Point point;
}

Note that Array:GetLength writes its result into the variable passed to it instead of returning it.

Compile-then-run

Source files (.ks) are compiled to .konsl files and run by the engine. On Windows a .konsl file could simply be double-clicked. On GNU/Linux it could be dragged onto the Quixie launcher. The FreeKE 0.1.90 release notes in January 2008 made the project’s one performance claim: compiling a 2 MB .ks file dropped from roughly 2 minutes to roughly 2 seconds compared with the previous FreeKE release, with programs starting in 1-3 seconds. That is the project’s own measurement of its compiler against its earlier version. It is not a comparison with any other language, and no test hardware was given.

Evolution

Current Relevance

As a game language, KonsolScript has been dormant since its last engine release in February 2012. English Wikipedia deleted its article twice, in January 2008 and January 2021, for lack of independent coverage. Most of the language’s record now sits on the project’s own blog, its SourceForge pages and a handful of Rosetta Code examples.

The name is in use again, though. By 2026 the project’s SourceForge page and website describe “KonsolScript” as an MIT-licensed, embeddable C++17 scripting runtime. It offers hot reloading of .ks scripts, a pre-execution “eval guard”, built-in JSON/CSV/regex modules, database and network plug-ins, and scripts that call large language model APIs. Web archive captures show the site still serving the old game-language blog in September 2025, so the relaunch is newer than that. No dated release, changelog or public source repository for the new runtime was found. That makes it hard to say how much of the 2005 language survives in it. The .ks extension and the Konsol: namespace carry over.

Why It Matters

KonsolScript never reached a wide audience. Its story is still a clear record of how hobbyist game languages lived in the 2000s. One developer, working with collaborators he knew only online, built a language, two engines and a toolchain on SourceForge. College students in a Philippine province tested it. A forum, a mascot and a run of fan-made demos kept it going. Like DarkBASIC, Blitz and the many small BASIC-family kits of the same years, it was meant to make game programming approachable. Unlike most of them, it chose C-style syntax, and it was given away under free-software licences (at first the project’s own Krixware GPL) for nearly its whole life.