Cut the bloat.
Keep the edge.

Installs into ~/.kama, no admin. Auto-detects a C compiler and falls back to a self-contained build that bundles zig cc, so kama build works with nothing else installed. Update any time with kama update. Prefer to build it yourself? Getting started has the manual and from-source paths.

To start something new: kama seed myapp writes a project — manifest, source file, .gitignore, README — and kama run builds and runs it. See Packages.

kama is not a reaction against the languages it came from — it is an attempt to keep the best of each without the part everyone works around.

What is not inherited is the ownership model. Every type names its kind, and what it owns follows from that — value, resource, view, enum, contract, intrinsic — and that one decision is what buys memory safety without a garbage collector and without a borrow checker, while leaving ordinary OOP intact. Read the type model →

import { core::println };

// A `value` owns nothing but its bytes, so it copies freely.
// The other kinds: `resource` owns and moves, `view` borrows, `contract` is a guarantee.
type value Steel
{
    public int32 carbon;

    // Construction is always a named constructor called on the type — no brace
    // literals, and `new` is only for the heap. The compiler checks that a
    // constructor sets every field, so a half-built value cannot escape one.
    public ctor make(int32 carbon)
    {
        this.carbon = carbon;
        return this;
    }
}

type enum ForgeError implements Error {
    TooFewFolds;

    public const fn string message() { return "a blade needs at least 8 folds"; }
}


// A `resource` owns something, so it moves instead of copying and its destructor
// runs at the end of the scope that owns it. No garbage collector, no pauses.
type resource Blade
{
    Steel steel;    // fields are private by default — a resource never exposes what it owns
    int32 folds;

    // The infallible constructor: nothing here can go wrong.
    public ctor make(Steel steel, int32 folds)
    {
        this.steel = steel;
        this.folds = folds;
    }

    // The fallible one returns a Result and fails *before* the blade exists,
    // so a half-forged Blade is not a thing that can be observed.
    public ctor Result<Blade, ForgeError> temper(Steel steel, int32 folds)
    {
        if (folds < 8)
        {
            return Result::Err(error: ForgeError::TooFewFolds);
        }

        println(s: "forging at ${folds} folds");
        return Result::Ok(value: Blade.make(steel: steel, folds: folds));
    }

    public fn int32 sharpness()
    {
        return this.folds * this.steel.carbon;
    }

    ~Blade() { }   // runs here, deterministically, when the owner goes out of scope
}

fn int32 main()
{
    Steel steel = Steel.make(carbon: 3);

    // `match` is exhaustive: handle every case, or it does not compile.
    // Each arm names the field it binds, exactly as a call names its arguments.
    return match (Blade.temper(steel: steel, folds: 14))
    {
        case Ok(value: blade): blade.sharpness();
        case Err(error: e):    1;
    };
}

This is not a mock-up: it is tests/site_sample.kama, compiled and run by the test suite on every build. Read the language tour for the rest of it.

kama compiles to C and is built by the same clang as the C baseline, so parity with C is the design rather than a discovery. These are all nine native workloads — no subset, no favourites — each panel scaled to its own slowest bar. Lower is better; times are medians in milliseconds.

Measured on Linux aarch64 in a pinned container, 2026-09-21 13:07 — every language must return the same checksum or the run fails. C#, Java, Lua and Python are in the data but off this graph: from 1.4× to over 1400× they would flatten the cluster above. See the full benchmark tables for every language, peak memory, binary size, compile time, the WebAssembly track, and the caveats that come with each.