Laravel ergonomics,
compiled to a binary
.
A Rust + Svelte 5 framework for hyper-responsive desktop apps. A container, providers, middleware and a typed bridge — Laravel's feel — but native, binary, and without runtime overhead. The CLI is Ratatosk (rata).
One command,
a running app.
With Rust 1.94+ and Node installed, rata new scaffolds a Rust bin crate and a Svelte 5 frontend wired together over the typed bridge. Elyra is distributed as a tagged GitHub release rather than through crates.io or npm, so a new project depends on the tag — and rata new --elyra <path> points it at a local checkout when you are working on the framework itself.
# Install the Ratatosk CLI (from the repo — not yet on crates.io) $ cargo install --git https://github.com/kwhorne/elyra-framework ratatosk # Scaffold and run a desktop app $ rata new myapp $ cd myapp && rata dev ✓ Rust core + Svelte 5 UI, hot-reloading # Generate the typed TS bridge from your commands $ rata codegen
A real framework,
not a wrapper.
A dependency-injection container, a middleware pipeline, an event bus, a typed IPC bridge, an Active Record ORM, plus windows, tray and an updater — all in the Rust core, with a Svelte 5 crown.
Binary IPC
MessagePack over an elyra://localhost custom protocol — no JSON in the hot path, no per-call serialization tax.
Commands + middleware
#[command] async fn is dispatched through a middleware pipeline, resolved from a container with providers — the Laravel request lifecycle, in Rust.
Event bus
EventBus + channel() push from Rust to the frontend, batched per flush over a long-poll, so the UI thread never blocks.
Typed bridge
rata codegen turns specta types into TypeScript plus a typed api.* facade — call your Rust commands with full type safety.
Active Record ORM
One Database over SQLite/MySQL/Postgres, rata migrate migrations, and #[derive(Model)] with a query builder, relations and auto-hydration — plus joins, where_between / where_null / or_where_eq, count / sum / avg / exists, paginate, chunk, bulk update and delete, soft deletes, transactions, and a Schema builder that renders DDL per driver so migrations can be written in Rust.
Queue, Cache & Storage facades
An in-process background job Queue, a TTL-aware Cache, and a filesystem Storage disk — each with the same ergonomic surface as its Laravel counterpart. Plus a cache-backed RateLimiter (too_many_attempts / hit / attempt, self-expiring per key) and a Scheduler for recurring work — every / hourly / daily with async closures, bound through a provider.
The bridge is gated, not open
The IPC surface used to answer any origin: Access-Control-Allow-Origin: * went out on every response, including the routes for commands, the filesystem, the clipboard and process spawning. Production builds now send no CORS headers at all, every /__* request must carry a per-run token, and each route maps to a capability — with StoreClear, CacheFlush, StorageDelete and UpdaterInstall opt-in rather than granted. Sidecar spawn from the frontend is deny-by-default, shell.open refuses file: URLs and anything executable, a strict CSP is served by default, and request bodies are size- and depth-bounded so a 10 KB payload cannot overflow the stack.
Testable without a window
TestApp invokes commands through the real middleware pipeline with no window at all — invoke_ok, invoke_err, invoke_validation_errors, assert_emitted — and TestShell drives the actual /__* routing when you want to test the bridge itself rather than around it. Desktop code that can only be verified by clicking is how desktop code rots.
Log, Config & Secrets
A Log facade with levels, targets, a rotating file sink and log_path() for a “send us your log” button — every command dispatch is traced with its duration. Config merges elyra.toml, config/*.toml, .env and process env into one dotted-key map with ${VAR} expansion. And Secrets keeps tokens in the OS keychain — macOS Keychain, Windows Credential Manager, Linux Secret Service — instead of the clear-text settings file, with get_or_migrate_env to move off environment variables.
Validation, all the way to the form
Check command input against a rule string — “required|email|min:18” — and get a per-field error bag back. Return it with ? from a command and the frontend reads the structured errors through validationErrors(err) in @elyra/runtime, so a field error stays a field error across the IPC boundary instead of collapsing into one message. Fourteen rules, in core, no dependencies.
Artisan-style generators
rata make:command, make:provider and make:model scaffold a file under src/ with names normalised the way you would expect — BlogPost becomes blog_post.rs with a BlogPost struct and a blog_posts table. It prints the mod line and registration rather than editing main.rs for you, and it never overwrites an existing file: generated code is a starting point, not something that owns your wiring.
AI SDK
A Laravel-inspired elyra-ai crate: text, chat, tools and structured output — plus retries with backoff, provider failover, response caching, rate limiting + token budgets, native web search/fetch, and text-to-speech + transcription.
Windows, menus & tray
Multi-window management with window-state persistence, a native application menu, global shortcuts and a system tray — each wired from a single builder call (tao + wry).
Signed auto-updater
An ed25519-verified updater with a built-in auto-update toast — ship updates safely with one builder call.
Sidecar processes
Spawn and supervise child processes (a Node server, a Python worker) from the app, with autostart-at-login so it comes up with the user's session.
Settings store
A persistent key-value store (store in @elyra/runtime) for app preferences — typed, synced to disk, no boilerplate.
System integration
Native desktop essentials — window controls, file drop, notifications, single-instance and deep-linking — exposed through @elyra/runtime.
Built-in UI components
Themed, dependency-free primitives plus a wired About dialog and update toast — consistent, native-feeling chrome for free.
Compiled, no overhead
A single binary with no embedded runtime — fast startup, low memory, and Rust's safety across the whole app.
Native desktop apps,
the way you build for the web.
Free and open source. Scaffold an app with rata new and read the docs to go deeper.