Lopolith

A small, statically typed programming language.

Lopolith is compiled to portable bytecode, runs on a compact register VM, and is designed to be embedded: one process hosts an Engine of shared modules and one or more VMs, each with its own heap, while native code extends the language through ordinary shared libraries.

Hello, world

%simple com.example.Hello implements Main
    #import Std
    int run(int argc, String[] argv) Main@run {
        Std.print("Hello, world!\n")
        return 0
    }

Hello, world!

$ make && make libs
$ ./loth run -e com.example.Hello hello.loth
Hello, world!

What is in it

• Classes, interfaces, singletons, generic slots and exceptions — with a deliberately small surface area.
• Portable bytecode modules (.lothc) and a register VM with computed-goto dispatch.
• A non-moving mark-sweep GC; no -fwrapv (integer arithmetic is defined everywhere).
• Native plugins: a .so describes its classes; the VM validates it against the .loth declarations before binding.
• Shared-heap threads: STW GC with safepoints, synchronized, volatile, Lock, Cond, Thread.
• An embedding API: one Engine (shared read-only modules), many VMs (independent heaps), host threads supported.
• About 14k lines of C11 with a small POSIX portability layer.

Three tutorials

The documentation is organized as three independent tracks. Each one is a step-by-step tutorial with complete programs that are compiled and run on every change.

• 1. Using the language — from building the toolchain to classes, interfaces, generics, exceptions and threads. A small task-list program grows across the chapters.
• 2. Embedding the VM — host Lopolith from C: Engine/VM lifecycle, module loading, running entries, shared-heap and isolated-VM concurrency.
• 3. Writing native plugins — implement %native classes in C: the ABI, the GC root contract, exceptions, callbacks and multi-class libraries.