Kittine — a language that compiles to real Rust, in far less syntax

Why Kittine

The language is the point. The website is just proof.

Kittine + Rust

The same counter, two syntaxes, one pipeline

Nothing below is a mockup. The left panel is real Kittine source; the right panel is the literal Rust that kittine-compiler emits for it today — line for line, taken from this project's own example-ssr crate.

func Counter() {
    <{count}> >> 0

    return (
        <button onClick={<{count}> >> count + 1}>
            "Clicks: "
            <{count}>
        </button>
    )
}

#[component]
pub fn Counter() -> impl IntoView {
    let (count, set_count) = signal(0f64);
    view! {
        <button on:click=move |_| set_count.update(|n| *n += 1f64)>
            "Clicks: "
            {move || count.get()}
        </button>
    }
}

Toggling the tabs above is Kittine itself: one signal, one reactive data attribute, zero JavaScript — the same fine-grained reactivity model Leptos gives Rust, just with less punctuation.

Structs, enums, and pattern matching

Newer syntax, same pipeline: litter / breed declare real Rust structs and enums, and pounce> compiles straight to a real match — no new runtime concept, just less to type.

breed Shape {
    Circle(#n),
    Square(#n),
    Idle
}

pounce> <{shape}>
    Circle(r) >> craft<r * 2>
    Square(s) >> craft<s>
    else> craft<'idle'>

#[derive(Clone, Debug)]
pub enum Shape {
    Circle(f64),
    Square(f64),
    Idle,
}

match shape.get() {
    Shape::Circle(r) => {
        leptos::logging::log!("{}", (r.clone() * 2f64));
    }
    Shape::Square(s) => {
        leptos::logging::log!("{}", s.clone());
    }
    _ => {
        leptos::logging::log!("idle");
    }
}

A litter or breed can also carry one generic type parameter, optionally bounded by a claw — Kittine's term for a trait — the same way litter NamedHolder<#t: Named> { value #t } compiles to a real Rust struct NamedHolder<T: Named> trait bound.

How it compiles

One source file, two real render targets

Every .kitty file goes through the exact same compiler. What differs downstream is what builds and serves the Rust it emits.

Ecosystem

Everything a Kittine project actually ships with

Roadmap

What's not built yet

Shipped is marked shipped; anything still genuinely planned is listed here instead of pretended away.

Install

Get the toolchain running

Kittine is built from source. The steps below are the exact sequence used to build every example in this repo, for both CSR and SSR targets.

# 1. build the compiler
cd kittine-compiler && cargo build --release

# 2. install dependencies
npm install && npm run build:plugin

# 3. run the dev server
npm run dev

# 1. build the compiler
cd kittine-compiler && cargo build --release

# 2. install cargo-leptos
cargo install cargo-leptos

# 3. compile the .kitty sources to Rust
cargo run --quiet -- build ../example-ssr/src/App.kitty

# 4. run the SSR server
cd ../example-ssr && cargo leptos watch

Full walkthroughs for both targets are available in the repo's docs/GETTING_STARTED.md and docs/SSR.md.

Partners

Who's behind this