KimL

KimL is a small esoteric programming language with an unusually tidy organizing idea: the entire language is method calls. There are no keywords for printing, assignment, or branching - instead, every statement invokes a method on one of five predefined pseudo-objects, in the form group.method some arguments. Input and output go through io, variables through var, an unbounded stack through stack, a 128-cell memory tape through tape, and all control flow through ctrl. Hello World is a single such invocation:

io.out "Hello World!\n"

Created in 2009 by Alexander Đặng Nhật Anh - a student at the time, known as alexanderdna on the Esolang wiki - KimL went through three specifications and three complete implementations in under two years, culminating in a C++ compiler and virtual machine released as version 1.0 on SourceForge in July 2011. Then it stopped. The language has been dormant for some fifteen years, but unlike many one-person esolangs it left behind a complete specification, an MIT-licensed implementation, and even a documented calling convention.

A note on the record: the encyclopedia’s master list dates KimL to 2003 and files it as a web markup language. The surviving primary sources - the Esolang wiki article and the SourceForge project - contradict both points. The language dates from 2009, and it is an imperative esoteric language with no markup syntax and no web component. This page follows the sources.

History and origins

KimL belongs to a recognizable tradition: the language a programmer invents in order to learn how languages are made. Its author was explicit about this - the SourceForge project description reads, in full, “an esoteric programming language whose compiler and virtual machine were made for learning purpose.”

The language was, in the Esolang wiki’s words, “firstly developed and implemented in 2009,” and the naming scheme for its specifications tells the story of its development on its own. The first specification is Specification 09.12 (year 2009, month 12), implemented as an interpreter in Visual Basic .NET. Specification 10.07 followed in July 2010, with a fresh implementation in Visual C#. The third and final revision, Specification 11.01 of January 2011, was accompanied by the most ambitious implementation: a compiler and virtual machine written in C++, replacing interpretation with compiled execution on a purpose-built VM. Three implementations in three languages in roughly fourteen months is the profile of someone deliberately climbing the compiler-construction learning curve - which was, by the author’s own account, the whole point.

The C++ implementation was registered on SourceForge on February 25, 2011 under the MIT license, and version 1.0 - a source archive of roughly 31 kilobytes - was released on July 26, 2011. It is the project’s only release. The author, who also created the esoteric languages ILYC and TS#, documented KimL thoroughly on the Esolang wiki, and the origin of the name itself goes unexplained in everything that survives.

Design philosophy

Most esoteric languages get their strangeness from minimalism (Brainfuck’s eight commands) or obfuscation (Malbolge, INTERCAL). KimL’s strangeness is organizational: it takes the familiar machinery of a simple imperative language and refactors all of it into a uniform object-method syntax. The result reads like a program talking to a small crew of specialists:

• io performs input and output - io.in reads user input with type conversion, io.out writes expressions as strings.
• var manages named variables - var.decl declares (with optional initialization), var.set assigns, var.del removes a variable entirely.
• stack manipulates the k-stack, an unbounded stack that holds values of any type, with push, pop, peek, swap, and clear.
• tape drives a 128-cell array with a movable pointer - read, write, next, prev (both circular), and move to jump the pointer to a computed position.
• ctrl owns control flow - ctrl.goto for unconditional or conditional jumps to labels, ctrl.call and ctrl.return for subroutines, ctrl.end to halt.

There is no if statement, no while loop, no function definition syntax. Structured programming is rebuilt the assembly-language way, from labels, conditional jumps, and a calling convention - while expressions, by contrast, are entirely conventional, with arithmetic, comparison, and logical operators plus a library of built-in functions. The language is simultaneously higher-level than Brainfuck (real variables, strings, floating point, math functions) and lower-level than BASIC (no structured control flow at all). That deliberate mismatch is where its esoteric character lives.

Key features

Three types, loosely held

KimL programs work with three data types: int (32-bit integers), real (64-bit floating point), and string (8-bit character strings, implemented atop C++ std::string). Conversion among them is pervasive and forgiving - a failed conversion yields a default value rather than an error. Dedicated conversion operators exist in the expression language: @ converts to integer and # converts to real, alongside ^ for exponentiation and & for string concatenation.

Two memories: the k-stack and the tape

A running program has two storage structures beyond named variables. The k-stack is an unbounded stack accepting any type, used both for scratch work and for passing arguments. The tape is a fixed array of 128 cells with a pointer, moved circularly with tape.next and tape.prev or repositioned arbitrarily with tape.move - a clear cousin of the Turing-machine tape found across esolang designs, though here each cell holds a full typed value rather than a byte. Introspection functions (_stack, _tape, _pop, _peek) let expressions examine both structures directly.

A real expression language

Where control flow is austere, expressions are generous. The built-in function library covers mathematics (sqrt, sin, cos, tan, asin, acos, atan), string handling in a BASIC-flavored style (chr, asc, len, left, mid, right), and an iif conditional function. Strings support the usual escape sequences (\n, \r, \t, \\, \"), and the language is case-sensitive throughout.

A documented calling convention

Unusually for a hobby esolang, KimL specifies how subroutines should be called: arguments are pushed onto the k-stack right to left, the return value is stored at tape position 0, and the callee is responsible for cleaning arguments off the stack. ctrl.call records the return address and ctrl.return jumps back. It is a miniature of the cdecl-era conventions its author was presumably studying - the language as a whole functions as a scale model of systems programming concerns.

Compiler and virtual machine

The final implementation is not an interpreter but a compiler targeting a bespoke virtual machine, both written in C++ and distributed under the MIT license. The Esolang article records successful builds on Microsoft Windows XP using Visual C++ 2008 Express and on Ubuntu Linux using GCC (the article cites GCC 3.4.2).

Evolution and dormancy

KimL’s entire evolution spans December 2009 to July 2011: three specifications, each named for its year and month, each with a new implementation in a new language - Visual Basic .NET, then Visual C#, then C++. After the 1.0 release on July 26, 2011, the record simply stops. No further releases, specification revisions, or announcements are known, and the project has been dormant for roughly fifteen years. A GitHub repository at alexanderdna/KimL, described in surviving search-engine records as “the compiler and virtual machine for the KimL programming language,” no longer resolves - a small archaeological reminder that even the recent past erodes. The SourceForge project, its 1.0 source archive, and the Esolang wiki article remain the language’s surviving record.

Current relevance

Nobody writes KimL today, and there is no evidence anyone beyond its author ever did. Its relevance is as a well-preserved specimen of a common but rarely documented genre: the compiler-learning language. Thousands of programmers have built a small language to teach themselves parsing and code generation; very few wrote a specification, versioned it, published an MIT-licensed implementation, and left a complete reference on a public wiki. Because Đặng did, KimL is still fully understandable - and, given a C++ compiler, quite possibly still buildable - a decade and a half after its author moved on.

Why it matters

KimL earns its encyclopedia entry on three counts. First, it is an honest artifact of how programming languages are actually learned - not in the seminar room but through iterative, self-directed reimplementation, visible here in three implementations across roughly fourteen months. Second, its design makes a genuinely interesting esoteric move: uniform object-method syntax over an unstructured, label-and-goto core, yielding a language at once friendlier and more primitive than the BASICs it superficially resembles. Third, it is a case study in digital preservation: of its three homes, one (the GitHub mirror) has already vanished, while the two that remain - SourceForge and the Esolang wiki - are the only reasons this page can be written at all. For the code archaeologist, KimL is a reminder that the difference between a language that can be studied and one that is lost forever is often nothing more than a single well-written wiki page.