Kittine — a language that compiles to real Rust, in far less syntaxBuilt with Kittine — this page is compiled Kittine (.kitty) source, not hand-written HTML or a JavaScript framework.GitHubGet started

GitHubGet started<br>Close

Kittine<br>A language layered on top of Rust and Leptos, in far less syntax than Rust itself. Write .kitty, get back real #[component] Rust — then rustc, wasm-bindgen and cargo-leptos take it the rest of the way. No virtual JS runtime hiding underneath.<br>Get startedSee it next to raw RustView source<br>Compiles to real RustTargets Leptos 0.7One compiler, zero changes — CSR via Vite or SSR via cargo-leptosThis page is built with it

Why Kittine<br>The language is the point. The website is just proof.<br>01Language first<br>Every feature this site needed — logical operators, method calls, path-qualified expressions, plain local bindings, custom loop keys, re-exports — got designed, parsed, code-generated and tested inside the compiler before a single page used it. Nothing here is a workaround.

02Rust underneath, on purpose<br>Kittine doesn't reinvent a runtime, a package manager, or a build system. It reinvents the syntax you write and hands the rest to cargo, rustc, wasm-bindgen and Leptos — the same tools that already compile every other Rust web app on your machine.

03No virtual DOM tax<br>Leptos is fine-grained reactive: signals update exactly the DOM nodes that depend on them, no diffing pass, no virtual tree. Kittine's >> value syntax compiles straight down to that model — the reactivity is real, not simulated.

04Compiler-verified, not vibes-verified<br>Every construct on this page — the reactive counter you can click below, the install tabs, the code comparison toggle — was compiled by the real kittine-compiler binary, checked against real Leptos 0.7, and run through a real dev server before it shipped.

Kittine + Rust<br>The same counter, two syntaxes, one pipeline<br>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.<br>.kitty sourcegenerated Rust<br>func Counter() {<br>>> 0

return (<br>>> count + 1}><br>"Clicks: "

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

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.<br>Structs, enums, and pattern matching<br>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.<br>.kitty sourcegenerated Rust<br>breed Shape {<br>Circle(#n),<br>Square(#n),<br>Idle

pounce><br>Circle(r) >> craftr * 2><br>Square(s) >> crafts><br>else> craft#[derive(Clone, Debug)]<br>pub enum Shape {<br>Circle(f64),<br>Square(f64),<br>Idle,

match shape.get() {<br>Shape::Circle(r) => {<br>leptos::logging::log!("{}", (r.clone() * 2f64));<br>Shape::Square(s) => {<br>leptos::logging::log!("{}", s.clone());<br>_ => {<br>leptos::logging::log!("idle");<br>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 { value #t } compiles to a real Rust struct NamedHolder trait bound.

How it compiles<br>One source file, two real render targets<br>Every .kitty file goes through the exact same compiler. What differs downstream is what builds and serves the Rust it emits.<br>.kitty source

kittine-compiler

Leptos 0.7 Rust

rustc + wasm-bindgen

Vite dev server

Browser (CSR)

rustc + cargo-leptos

Axum server

Browser (SSR, HTML first)

Ecosystem<br>Everything a Kittine project actually ships with<br>availablekittine-compiler<br>The hand-written lexer, recursive-descent parser and code generator. A plain CLI: lex, parse, emit Rust. No syn crate, no intermediate AST magic — output stays readable enough to diff by eye.

availablevite-plugin-kittine<br>Hooks Vite's transform pipeline: compiles the touched .kitty file, runs cargo build --target wasm32-unknown-unknown, then wasm-bindgen --target web — all on save, with incremental rebuilds.

availableSSR via cargo-leptos<br>An alternative to the Vite pipeline for server-rendered pages: the identical compiler output, run through cargo-leptos and Axum instead, for real pre-rendered HTML and fast first paint.

availableVS Code extension<br>TextMate-grammar syntax highlighting for .kitty files. No language server yet — that's next, not pretended to already exist.

availableStructs, enums, pattern matching, traits<br>litter (structs) and breed (enums) declare real Rust types; pounce> pattern-matches a breed value; claw/bare .. for .. are a real trait system, with one type parameter per struct/enum optionally bounded by one. See it next to the generated Rust on the Rust & Leptos page.

availableTest suite<br>97 tests covering every language construct through full...