No Description

K. Lange 9f6160092e Fix up math.nan is math.nan (should be False); explain nan boxing bit masks 6 months ago
.github 7c05a4a299 Create codeql-analysis.yml 7 months ago
bench 391ee73d48 Try to make the benchmark suite more fair on instance variables 1 year ago
docs 07e04b001c Scan new src/modules/ directory for Doxygen stuff 1 year ago
modules 14db828233 Fix an oversight in the UTF-32 endian sniffing. (#18) 7 months ago
src 9f6160092e Fix up math.nan is math.nan (should be False); explain nan boxing bit masks 6 months ago
test 3733c996bc Fix assignments to single complex assignment targets (trailing commas) 1 year ago
tools 444cb28d06 Drop krk_callSimple 1 year ago
.gitattributes 11f78e62bb Concede defeat the language identification battle; we're _A_ Python? 1 year ago
.gitignore 40dcc7e4ea Ignore .lo files 1 year ago
LICENSE 8d6561831b Accede fully to MIT for license terms 1 year ago
Makefile 300d64495f Relocate modules to resolve a build annoyance. 1 year ago 900e8fb487 Invert debugging-related build flags 1 year ago 9f21628c53 Just post an issue report, please. 7 months ago
test.krk da2f4802c5 Update wcwidth implementation for Windows and add a binding library 6 months ago


Kuroko is a dynamic, bytecode-compiled programming language and a dialect of Python. The syntax features indentation-driven blocks, familiar keywords, and explicit variable declaration with block scoping. The runtime interpreter includes a tracing garbage collector, multithreading support without a global lock, and support for single-step debugging and bytecode disassembly. The full interpreter and compiler can be built on Unix-like platforms to a shared library of around 500K and is easy to embed and extend with a clean C API and limited libc footprint. Kuroko has been successfully built for a wide range of targets, including Linux, ToaruOS, WebAssembly, macOS (including M1 ARM devices), and Windows (with mingw64).

Build Kuroko

On most platforms, make is sufficient to build in the standard configuration which will produce both REPL binary (kuroko) with the compiler and interpreter included, as well as both a static (libkuroko.a) and shared library version ( that can be used for embedding.

Additional build configurations are available with the following options:

  • KRK_DISABLE_RLINE=1: Do not build with support for the rich syntax-highlighted line editor.
  • KRK_DISABLE_DEBUG=1: Do not build support for disassembly. Not recommended, as it does not offer any visible improvement in performance.
  • KRK_DISABLE_DOCS=1: Do not include documentation strings for builtins. Can reduce the library size by around 100KB depending on other configuration options.


To build for Windows, it is recommended that a Unix-like host environment be used with the MingW64 toolchain:

CC=x86_64-w64-mingw32-gcc make


WASM builds can be built from kuroko-lang/kuroko-wasm-repl.

Kuroko can be built with the Asyncify option and as a worker.

Fully Static

Normally, the main interpreter binary statically links with the VM library, but is otherwise built as a dynamic executable and links to shared libraries for libc, pthreads, and so on. To build a fully static binary, adding -static to CFLAGS and building only the kuroko target should suffice.

Whether a static build supports importing C extension modules depends on the specifics of your target platform.

Extend and Embed Kuroko

Kuroko is easy to embed in a host application or extend with C modules. Please see the documentation on our website for further information.

Learn Kuroko

If you already know Python, adapting to Kuroko is a breeze.

If you want to get started, try the interactive tutorial.

Supported Functionality

Kuroko supports a wide range of functionality and syntax expected from a Python implementation, and this list is by no means exhaustive:

  • Iteration loops with for
  • list, dict and set comprehensions with chained for expressions and if conditions.
  • Generator expressions and generator functions with yield and yield from.
  • Context managers and with.
  • Exceptions and try/except/finally.
  • Complex assignment targets.
  • Classes with inheritance, general attributes, methods (including static and class methods)
  • Decorators, both for classes and functions.
  • Type hints and other uses of function annotations.
  • Unicode strings.
  • Debugger hooks and instruction stepping.
  • Multithreading.
  • C extension modules.

Python Compatibility

Kuroko aims for wide compatibility with Python 3.x and supports most syntax features and a growing collection of standard library functions. The most notable difference between Kuroko and standard Python is explicit variable declaration and the use of the let keyword. Many Python snippets can be ported to Kuroko with only the addition of declaration statements. Some syntax features remain unimplemented, however:

async for, async with, asyncio module

Kuroko does not support the async for/async with constructs, and does not have a asyncio module. They are planned for a future release.


Kuroko iterables do not use the __next__() method, but rather are called normally. This allows iteration objects to be implemented as simple functions. If you are porting code which has a different use of __call__() than __next__() it will likely be necessary to change the implementation. Kuroko also doesn't have a StopIteration exception; iterators return themselves to signal they are exhausted (if you need an iterator to return itself, consider boxing it in a tuple).


Kuroko provides only single inheritance. When porting from Python, mix-in classes and other uses of multiple inheritance may need to be redesigned.


The scoping system in Kuroko makes the global and nonlocal keywords unnecessary and they are not supported.

Walrus Operator

Kuroko has generalized assignment expressions, so skip the walrus and assign whatever you like (some additional parenthesis wrapping may be necessary to disambiguate assignments).