Why Zeus?

Zeus exists to answer a simple question: what if a language felt like TypeScript but compiled straight to a native binary? It borrows the syntax you already know and runs it as machine code — no interpreter, no VM, no runtime tax.

The problem

Picking a language usually means trading ergonomics for performance:

JavaScript / TypeScript give you familiar, expressive syntax and fast iteration — but you pay with interpreter/JIT overhead, higher memory use, and no standalone binaries.
Rust, Go, or C++ give you native speed and real compiled binaries — but with a steeper learning curve and unfamiliar paradigms.

Zeus aims for the middle: the feel of TypeScript with the output of a systems language.

The Zeus solution

Familiar Syntax

If you know TypeScript, you already know most of Zeus. Classes, functions, and type annotations work the way you expect.

Native Speed

Zeus compiles to native machine code via LLVM. No interpreter, no virtual machine, no JIT warmup.

Simple Memory Model

Automatic garbage collection means you focus on your logic — no ownership rules, no borrow checker, no manual malloc/free.

Tooling First

The language server was built alongside the compiler, so you get real-time diagnostics and completions from day one.

Design principles

1. Familiarity over novelty

Zeus doesn’t reinvent syntax that already works. If TypeScript’s class and function syntax is good, why make you relearn it?

// 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;
  }
}

2. Static types, minimal ceremony

Every value has a type, but you don’t have to spell it out when it’s obvious — Zeus infers types from initializers and only asks for annotations where they add clarity.

3. Tooling is not optional

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

4. Performance by default

Every program compiles to optimized native code through the LLVM backend. Static typing enables compile-time optimization, and there’s no interpretation overhead at runtime.

Who is Zeus for?

Web Developers

You love TypeScript but want to build CLI tools, games, or performance-critical apps without learning a completely new language.

Students & Learners

You want to understand how compiled languages work without the complexity of manual memory management.

Curious Engineers

You’re interested in language design and compilers. Zeus is open source and approachable.

Performance Seekers

You need more speed than JavaScript offers but don’t want to invest months learning Rust or C++.

How Zeus compares

Aspect	JavaScript / TypeScript	Zeus	Rust / Go
Syntax familiarity	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐
Native performance	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Memory management	Automatic (GC)	Automatic (GC)	Manual / ownership
Learning curve	Low	Low	High
Standalone binary	❌ (needs runtime)	✅	✅
IDE support	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐

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, and variadic parameters
Control flow (if/else, for, while)
Dynamic arrays and UTF-8 strings (including template literals)
Modules (import/export) and exception handling
Automatic garbage collection
Timers and a growing set of built-ins
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 →