Why Zeus?

Zeus isn’t “TypeScript, but faster.” It’s a new language that keeps the ergonomics you love about TypeScript, deliberately leaves behind JavaScript’s runtime dynamism and footguns, and gives you a rich, static type system that feels like a subset of TS — then compiles straight to a native binary via LLVM.

The goal is a specific one: an approachable systems language. Something that lands in the gap nobody quite fills — richer and friendlier than Go, far easier to pick up than Rust.

The choice you shouldn’t have to make

Picking a language usually forces a trade between how it feels and what it produces:

JavaScript / TypeScript — expressive, familiar, fast to iterate. But you inherit JS’s dynamism and mistakes, pay for an interpreter/JIT and a runtime, carry node_modules, and you never get a standalone binary.
Rust — a genuinely rich type system and real native binaries. But a steep learning curve, a borrow checker to satisfy, and slow compiles.
Go — fast, simple, and it ships a real binary. But it’s verbose, has no inheritance, and its type system is deliberately minimal.

Each corner asks you to give something up. Zeus is an attempt to sit in the middle of all three.

Where Zeus fits

Think of it as a spectrum. Rust maximizes power at the cost of approachability. Go maximizes simplicity and speed at the cost of expressiveness. Zeus aims for the point in between:

A rich, TypeScript-like type system with classes, interfaces, and inheritance — compiled to a native binary — without Rust’s complexity tax and without giving up the expressiveness Go leaves on the table.

It brings back what Go misses — inheritance, a fuller type system, and TS-grade ergonomics — while staying miles more approachable than Rust. The honest trade is on the other side: Zeus is not chasing Go’s raw throughput. It gives up a little peak speed to buy a lot of expressiveness and a gentle learning curve. For CLIs, tools, servers, and everyday programs, that’s a trade that pays off.

What Zeus gives you

Familiar TypeScript syntax

Classes, interfaces, generics, closures, and type annotations that read like TypeScript. If you know TS, you already know most of Zeus — there’s very little new to learn.

Native LLVM binaries

Zeus compiles to a small, self-contained native executable through LLVM. No interpreter, no VM, no JIT warmup, no runtime to install — just a binary that starts instantly.

Batteries-included stdlib

fs, os, path, json, crypto, datetime, a test runner, and more ship in the box. Node/TS-level breadth, without the npm install sprawl.

Approachable by design

A rich type system with no borrow checker to fight and no ceremony to wade through. You get memory safety without ownership rules to memorize.

Design principles

1. Keep TypeScript’s ergonomics, not JavaScript’s baggage

Zeus borrows the syntax and feel that make TypeScript pleasant, and leaves behind the parts of JavaScript that cause pain — implicit coercions, undefined-vs-null confusion, and runtime type surprises. The result feels like a clean, statically-typed subset of TS.

// This should feel immediately familiar
class Rectangle {
  public width: f64;
  public height: f64;

  constructor(w: f64, h: f64) {
    this.width = w;
    this.height = h;
  }

  public area(): f64 {
    return this.width * this.height;
  }
}

let r = new Rectangle(3.0, 4.0);
console.log(r.area()); // 12

2. A rich type system, minimal ceremony

Every value has a static type, but you don’t spell it out when it’s obvious — Zeus infers types from initializers and only asks for annotations where they add clarity. Classes, interfaces, and inheritance are first-class, so you can model real programs without fighting the language.

3. Native by default, honest about speed

Every program compiles to optimized native code through LLVM, with no interpretation overhead at runtime. Zeus is fast — fast enough for real work — but it doesn’t pretend to out-benchmark Go. The win is a real binary and predictable native performance with TypeScript-grade expressiveness.

4. Memory safety without a borrow checker

Zeus manages memory for you, so you focus on logic instead of lifetimes. You get the safety of automatic memory management without ownership rules, ceremony, or a borrow checker standing between you and your program.

5. Tooling is not optional

Great tooling shouldn’t be a third-party add-on. Zeus ships a Language Server Protocol implementation built alongside the compiler, with real-time diagnostics, smart completions, and a VS Code extension from day one.

Who is Zeus for?

TypeScript developers

You love how TS feels but want a real binary and native performance — without switching to a language that makes you relearn everything.

Devs who bounced off Rust/Go

You wanted a compiled language but found Rust too heavy or Go too bare. Zeus aims for the approachable middle.

Tool & CLI builders

You’re shipping command-line tools, servers, and utilities where fast startup and a single self-contained binary matter.

Students & language fans

You want to understand compiled languages — or just enjoy trying new ones — without manual memory management getting in the way.

How Zeus compares

Zeus doesn’t win every column — it’s built to win the balance across them.

Aspect	TypeScript	Go	Rust	Zeus
Feels familiar to TS devs	⭐⭐⭐⭐⭐	⭐⭐	⭐	⭐⭐⭐⭐⭐
Rich / expressive types	⭐⭐⭐⭐	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Classes & inheritance	✅	❌	⚠️ traits	✅
Standalone native binary	❌	✅	✅	✅
Runtime performance	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐
Learning curve	Low	Low–Medium	High	Low
Memory management	Automatic	Automatic	Ownership / borrow	Automatic

Where Zeus stands today

Zeus is in alpha and under active development.

Available now

Classes with constructors, methods, and this
Encapsulation (public/private) and get/set accessors
Static members and single inheritance with dynamic dispatch
Structural interfaces with dynamic method and property dispatch
Functions, closures, default parameters, and variadic parameters
Control flow (if/else, for, for...of, while)
Dynamic arrays and UTF-8 strings (including template literals)
Modules (import/export) and exception handling
A batteries-included standard library (fs, os, path, json, crypto, datetime, …)
C interop (FFI) for calling into existing native libraries
Automatic memory management
A VS Code extension backed by the language server

On the roadmap

Generics, Promise with async/await, a Node-like HTTP server, and more — see the Roadmap for what’s coming next.

Get started with Zeus →