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.
Why Kittine
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.
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.
Leptos is fine-grained reactive: signals update exactly the DOM nodes that depend on them, no diffing pass, no virtual tree. Kittine's <{signal}> >> value syntax compiles straight down to that model — the reactivity is real, not simulated.
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
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.
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
Every .kitty file goes through the exact same compiler. What differs downstream is what builds and serves the Rust it emits.
Ecosystem
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.
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.
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.
TextMate-grammar syntax highlighting for .kitty files. No language server yet — that's next, not pretended to already exist.
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.
97 tests covering every language construct through full codegen, plus real integration tests that compile multi-file Kittine programs end to end via the actual CLI, not mocks.
fmt is a real formatter: it reparses its own output and refuses to write unless the AST matches the original exactly, and it won't touch a file with // comments (the lexer discards them, so there's nothing to preserve) unless told to. lint catches unused imports, params and hold bindings, plus duplicate field/variant/param names that would fail cargo build once generated — caught before it gets there.
kittine.toml/kittine.lock plus kittine-compiler add/install/publish, backed by a real hosted registry with no server of its own — just an index/[name].json per package on kittine-registry, with tarballs as GitHub Release assets. install sha256-verifies every download. Exact-version dependencies only for now — no semver ranges, no transitive resolution yet.
A litter/breed name, optionally []-suffixed, is a real prop/purr param or return type — DocEntry[] entries is a real Vec<DocEntry>. A closure literal, |param| expr, lowers to a real Rust closure — the missing piece a real .filter()/.map() needs. And pounce> now works as an expression too, not just a statement — return (pounce> result Ok(v) >> v Err(e) >> 0) unwraps a Result-shaped value and returns it in one step. See it live: the language reference page's search box is real, data-backed filtering built from exactly these three features.
Roadmap
Shipped is marked shipped; anything still genuinely planned is listed here instead of pretended away.
A getting-started guide and a filterable, searchable language + CLI reference. Topic filtering is a real reactive data-filter attribute, the same pattern as the code-comparison tabs; free-text search is real too now — a litter-typed array of doc entries, filtered by a real .filter(|e| ..) closure, rendered as a reactive Leptos <For>, re-filtering on every keystroke. No hand-written JavaScript.
Compiling a .kitty snippet to real Rust in the browser was genuinely buildable — kittine-compiler's single-file path has no filesystem dependency — and now it's shipped: try it on the Playground page, the actual compiler running as WebAssembly, client-side. Actually running the result still needs a sandboxed rustc backend, which is real infrastructure, not a page — that part is still not built.
/sitemap.xml and /robots.txt cover every real route. /feed.xml is a real RSS feed of the Updates page, condensed from the language repo's own CHANGELOG.md.
Real npm / crates.io numbers, once there's a public release to count. Kittine has no versioned release yet — see Updates — so this card stays honest rather than showing a placeholder number.
Install
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 watchFull walkthroughs for both targets are available in the repo's docs/GETTING_STARTED.md and docs/SSR.md.
Partners
Custom digital builds. Tailored to you.
Kittine's design partner and the studio behind this site's brand system. Builds By Buchanan works on custom software and digital product builds — Kittine is one of those builds, built out in the open as a real language rather than a demo.