Husk

A Rust-inspired language for building type-safe JavaScript.

Pattern matching, algebraic data types, and strong static typing — compiling to clean, readable JS that runs everywhere.

Get Started GitHub

$ cargo install husk-lang

    main.hk 
 fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn main() {
    // Compiler ensures all cases are handled!
    match divide(10, 2) {
        Ok(value) => println("Result: {}", value),
        Err(err) => println("Error: {}", err),
    }
} 

Why Husk?

The power of Rust's type system, the reach of JavaScript's ecosystem. Write once, run anywhere — with confidence.

Rust-like Syntax

Familiar syntax with pattern matching, algebraic data types, and powerful type inference. If you know Rust, you'll feel right at home.

Type Safety

Catch errors at compile time with a robust type system. Strong static typing with inference means safety without verbosity.

Developer Experience

Fast compile times, clear error messages, and excellent tooling. LSP support, code formatting, and editor integrations included.

JavaScript Interop

Seamlessly call npm packages and JavaScript libraries. Compiles to clean ES modules that integrate with any JS project.

Full LSP Support

VS Code & Neovim

Source Maps

Watch Mode

See it in action

Clean, expressive syntax that compiles to readable JavaScript. No runtime overhead, no magic — just better code.

Exhaustive pattern matching with algebraic data types

    pattern-matching.hk 
 fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero")
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(value) => println("Result: {}", value),
        Err(err) => println("Error: {}", err),
    }
    // Compiler ensures all cases are handled!
} 

Define types with associated methods

    structs-methods.hk 
 struct User {
    name: String,
    email: String,
    age: i32,
}

impl User {
    fn new(name: String, email: String, age: i32) -> User {
        User { name, email, age }
    }

    fn greet(&self) -> String {
        format("Hi, I'm {} and I'm {} years old", self.name, self.age)
    }
}

fn main() {
    let user = User::new("Alice", "alice@example.com", 30);
    println("{}", user.greet());
} 

Seamlessly use npm packages

    js-interop.hk 
 // Use Express.js directly from Husk
extern fn express() -> Express;

struct Express {
    extern fn get(&self, path: String, handler: fn(Request, Response) -> void) -> void;
    extern fn listen(&self, port: i32, callback: fn() -> void) -> void;
}

fn main() {
    let app = express();

    app.get("/", |req, res| {
        res.send("Hello from Husk!");
    });

    app.listen(3000, || {
        println("Server running on port 3000");
    });
} 

Compiles to clean ES modules or CommonJS

Join the Community

Husk is open source and community-driven. Get involved, learn, and help shape the future of the language.

Want to contribute? Check out the contributing guidelines to get started.

Star on GitHub