Ship Rust. Write TypeScript.

A complete development ecosystem for building native applications with the TypeScript syntax you already know. 3MB binaries. No V8. No garbage collector.

app.rts
import { Serialize } from "serde";

type Book = {
  title: string,
  author: string,
  rating: f64,
} derives Serialize

function main() {
  const books: Array<Book> = [
    { title: "Dune", author: "Herbert", rating: 4.7 },
    { title: "Neuromancer", author: "Gibson", rating: 4.5 },
  ];

  const top = books.filter(b => b.rating > 4.6);
  console.log(JSON.stringify(top));
}
app.rs (generated)
use serde::Serialize;

#[derive(Debug, Clone, Serialize)]
struct Book {
    pub title: String,
    pub author: String,
    pub rating: f64,
}

fn main() {
    let books: Vec<Book> = vec![
        Book { title: "Dune".to_string(), author: "Herbert".to_string(), rating: 4.7 },
        Book { title: "Neuromancer".to_string(), author: "Gibson".to_string(), rating: 4.5 },
    ];

    let top: Vec<Book> = books.iter()
        .filter(|b| b.rating > 4.6).cloned().collect();
    println!("{}", serde_json::to_string(&top).unwrap());
}
2,600+
Tests
330+
Built-in Methods
11
Crates
195
Conformance Tests

Get Started in 30 Seconds

terminal
cargo install rustscript  # installs rustscript + rsc
rsc init my-app --template web-server
cd my-app
rsc run

Every Rust crate, in TypeScript syntax

The entire Rust ecosystem already speaks your language. Browse any crate, any version, with its public API translated to RustScript syntax on demand.

Browse All Crates →

Everything you need to ship Rust

Not a prototype. A complete compiler with full TypeScript syntax coverage, a standard library, production tooling, and zero known conformance gaps.

Familiar Syntax

  • Every TypeScript pattern: classes, generics, async/await, destructuring
  • 330+ built-in methods: map, filter, reduce, find, forEach, and more
  • Template literals, optional chaining, nullish coalescing, spread
  • String unions, type aliases, interfaces, discriminated unions

Rust Performance

  • 3MB native binaries — no V8, no garbage collector
  • No runtime overhead — compiles to idiomatic Rust
  • Generated code is human-readable and inspectable
  • Eject to pure Rust at any time — no lock-in

Full Crate Ecosystem

  • import { Router } from "axum" — any Rust crate, TS import syntax
  • Dependencies auto-detected from imports — no Cargo.toml editing
  • derives keyword for proc macros: Serialize, Deserialize, Parser
  • axum, serde, tokio, clap, reqwest, sqlx — they all just work

Zero Memory Management

  • No lifetimes, no borrowing annotations, no ownership errors
  • Compiler infers ownership and inserts clones for correctness
  • Tier 2 borrow inference eliminates unnecessary allocations
  • Async/await with tokio — just works, no runtime configuration

Production Tooling

  • VS Code extension with real language server (LSP)
  • Type-aware hover: signatures, doc comments, inferred types
  • Closure parameter inference, generic substitution, field resolution
  • Live diagnostics, code formatting, watch mode, project templates

Friendly Error Messages

  • Errors point to your .rts source lines, not generated Rust
  • Dense source maps with O(1) line lookup
  • rustc JSON diagnostics parsed and re-rendered with RustScript types
  • 9 enrichment patterns: type translation, borrow hints, lifetime suggestions

Type Generator

  • rsc types emits .d.ts files from RustScript source
  • One file per module — TypeScript-native output
  • Share types between RustScript backend and TS frontend
  • rsc build --emit-types for CI pipelines — perfect for Tauri apps

Eject Anytime

  • Generated Rust compiles with standard rustc
  • Uses standard crates, follows Rust conventions
  • No custom runtime, no code generation magic
  • Walk away to pure Rust whenever you want

Try it in your browser

Live compilation, real diagnostics, and TypeScript-grade hover tooltips — all running client-side via WebAssembly. No server required.

Open Playground →