zkl

zkl is a general-purpose object-oriented programming language created by Craig Durland and distributed through his ZenKinetic website. It is imperative at heart but borrows freely from other paradigms — functional and prototype-based among them — and it is curly-bracketed, dynamic, reflective, and threaded. The official description captures the mix precisely: the syntax strongly resembles C, while the data model is closer to Python and Smalltalk. Everything in zkl is an object — numbers, strings, functions, classes, even running threads — and the language builds in garbage collection, lists, dictionaries, preemptive threads, and fibers (continuations and co-routines). Its stated goals are rapid prototyping and programmer productivity; by its own documentation, program speed and the constraints of production-oriented programming “are not high on the needs list.” First published around 2008 and still updated as of its 1.15.0 release in October 2025, zkl is a striking example of a complete, thoroughly documented language built and maintained by a single person for nearly two decades.

History & Origins

zkl is the work of one programmer. The earliest copyright year in the reference manual is 2006, and the language’s public life began around March 2008, when the first edition of the manual appeared; new editions have tracked each release since. Durland published the manual as a paperback book, The zkl Programming Language: Reference Manual, in 2011, and has kept the free PDF version current ever since — the edition accompanying version 1.15.0 runs to 366 pages.

The manual opens with an epigraph credited to “Zander Kale” that doubles as the language’s mission statement:

zkl doesn’t attempt to boil the ocean, zkl doesn’t want to warm the ocean. zkl wants to make a nice cup of tea.

The name is pronounced “zee kay el” or “zee kale” — “or however you like,” the manual adds. The software is released under the OSI-approved zlib/libpng license, with the documentation under a Creative Commons license.

Release numbering has moved deliberately rather than dramatically: 1.1 and 1.3 in 2010, 1.5.2 and 1.6 in 2011, 1.7 in 2012, 1.10 and 1.12 in 2013, then a long tail of maintenance releases (1.12.21 in 2015, 1.12.38 in 2017, 1.14.1 in December 2018) leading to 1.15.0 in October 2025. Throughout, the implementation has remained a virtual machine written in ANSI C (C99) that, per the official downloads page, builds with clang or Microsoft Visual C on Linux, FreeBSD/PC-BSD, and Microsoft Windows (the same page notes that GCC has issues compiling the code).

Design Philosophy

zkl’s design reflects a handful of consistent choices:

• C on the surface, Smalltalk underneath. Braces, semicolons, and C-style control flow keep the syntax familiar, but every value is an object that responds to messages. Asking "string".dir() lists the methods and properties a string understands; (1).dir() does the same for an integer.
• The receiver decides. Operators dispatch polymorphically on the left-hand object, so 1 + "2" yields the integer 3 while "1" + 2 yields the string "12" — the object on the left coerces the one on the right.
• Uniform “look and feel” across core objects. Strings, lists, and files share stream-like interfaces, so the same foreach loop iterates characters of a string, items of a list, or lines of a file without changing shape.
• Concurrency is built in, not bolted on. Preemptive threads are a core feature — every class and function is threadable — alongside fibers, locks, events, semaphores, timers, and pipes for inter-thread communication.
• Productivity over performance. The documentation is candid that zkl trades the strong static checking of production languages for speed of development, positioning itself for prototyping and personal tooling.

The Language

Hello World is a one-liner in either message direction:

1
2

println("Hello world");   // or equivalently:
"Hello again".println();

There are no include files and no main(); even the compile step is invisible. Functions are declared with fcn, and the classic factorial looks close to its C counterpart while operating on zkl’s native 64-bit integers:

1
2
3
4
5

fcn fact(x){              // Input: x  output: x!
   if (x == 0) return(1);
   return( x * fact(x - 1) );
}
fact(5)  // → 120

Lists are heterogeneous, and the reflective object model makes types themselves easy to inspect:

1
2

L(1, "2", 3.4, L(5,"six"), self, fcn(x){ x + 1 }).apply("type")
// → L("Int","StringConst","Float","List","Class","Fcn")

Exception handling follows the Java/Python pattern with try, catch, and throw, and the runtime exposes its own machinery as objects: the compiler, parser, tokenizer, and assembler are all accessible from within the language, as are network sockets — the official examples include speaking HTTP to a web server directly from the REPL.

Threads and Fibers

Concurrency examples from the official documentation are strikingly compact. Launching a function on a new preemptive thread is a method call, and fibers (co-routines) are created and resumed through the VM object:

1
2
3
4
5

print(vm," "); fcn { println(vm) }.launch();
// → VM#6 VM#10077

var fiber = vm.createFiber(fcn { vm.yield(vm); "Fiber is done" });
fiber.resume();           // → "Fiber is done"

Key Features

Evolution

zkl’s evolution has been the steady refinement of a finished idea rather than a series of reinventions. The core language of the 2008 manual — objects everywhere, C-flavored syntax, built-in threading — is recognizably the language of today; successive releases have deepened the object library, the extension ecosystem, and the tooling. The project’s engineering discipline is notable for a solo effort: releases ship with a regression suite of more than 9,000 tests, Visual C project files targeting Windows 10/11, and makefiles for the Unix-family platforms.

The most visible chapter of zkl’s public life has played out on Rosetta Code, the wiki that collects solutions to common programming tasks in as many languages as possible. Beginning in the mid-2010s, zkl solutions accumulated at a remarkable pace, and the language’s category on the site had grown past 1,000 pages by mid-2026 — placing this one-person language among the most thoroughly represented on the site and providing, in aggregate, an enormous cookbook of idiomatic zkl.

Current Relevance

zkl remains a living project: the October 2025 release of version 1.15.0 brought a refreshed manual, current source packages, and updated build support for Windows 10/11 and modern Linux and BSD systems. There is no official Docker image, IDE, or package manager — the distribution model is the original one, a self-contained executable plus a PDF, downloaded from zenkinetic.com. Its community is small and centers on the ZenKinetic site, the author’s blog, and the Rosetta Code corpus.

That places zkl firmly in the category of personal languages that outlast most funded ones. It is not a language businesses adopt; it is a language a programmer reads — through an unusually good manual and a thousand worked examples — to see how far the “everything is an object, and threads are cheap” idea can be pushed with C syntax.

Why It Matters

zkl matters as an existence proof. A single developer designed a multi-paradigm language, implemented its virtual machine in portable C, documented it to book length, tested it with a nine-thousand-case suite, built an FFI ecosystem around real C libraries, and maintained all of it for nearly twenty years. Its blend of influences — C’s syntax, Python’s and Smalltalk’s data model, built-in preemptive threading at a time when most scripting languages had none — gives it a genuinely distinctive feel, and its receiver-decides operator polymorphism (1+"2" is 3; "1"+2 is "12") is a memorable design decision worth studying whichever side of it you come down on. For code archaeologists, zkl is a well-preserved, still-running specimen of the personal-language tradition: opinionated, complete, and documented well enough that anyone can dig in.