Home.

A language for JavaScript and TypeScript, built from one Zig toolchain. It is a drop-in replacement for tsc that type-checks your project many times faster, a runtime with Node and Bun built in, and a native language that reads like TypeScript and compiles without a garbage collector. There is no language like Home.

• home-lang.org
• Documentation
• Parity status
• GitHub

Try it

Home is under active development and has no tagged release yet, so for now it builds from source. Then swap the command:

git clone https://github.com/home-lang/home && cd home
pantry install && ./pantry/.bin/zig build

home tsc -p tsconfig.json --noEmit   # instead of npx tsc
home tsc --watch                     # incremental rebuilds
home lsp --stdio                     # one language server for TS and .home
home run server.ts                   # run TypeScript directly

A drop-in tsc

The part most people will meet first. Swap the command and keep everything else: the same tsconfig.json, the same flags, the same TSxxxx diagnostics and the same exit codes.

• Same interface Reads your existing tsconfig.json and accepts tsc's flags, from --noEmit and --strict to --paths, --declaration, --sourceMap and @response files. Exit codes match tsc: 0, 1 for type errors, 2 for config errors.
• Literally tsc Run under the name tsc (or home-tsc) and the home binary behaves exactly like tsc, so a symlink is enough for every script and tool that already calls it.
• Faster On its published benchmark suite, home tsc --noEmit type-checks 1.6x to 11.9x faster than native TypeScript 7 (tsgo) and 4.7x to 19x faster than tsc, with the lowest time on all 20 workloads. Startup is 3.9 ms against tsgo's 45.8 ms.
• Measured honestly Checked against TypeScript's own conformance corpus rather than tests written for Home: all 5,907 diagnostic families pass, and the first 2,960 cases match byte for byte, with the rest being revalidated. Every benchmark run has to reproduce exact diagnostics before its timing counts.
• Watch and build --watch rebuilds incrementally from a persistent on-disk cache. -b builds project references in dependency order, with cycle detection, --dry, --force and --verbose.
• Emit JavaScript output with downlevelling (optional chaining, async, private fields, legacy decorators, CommonJS interop), every JSX mode, .d.ts declarations and source maps. Stage 3 decorators and generator downlevelling are still maturing.

A Bun and Node compatible runtime

Home carries Bun's Zig engine on its own JavaScriptCore realm, so the toolchain that checks your TypeScript can also run, test and bundle it. This half is in active development: the core works, and the API surface grows every week.

• Run home run server.ts runs JavaScript, TypeScript and HTML entrypoints, CommonJS and ESM, plus home eval and a REPL. Bare home app.ts works too.
• Node APIs Partial but broad: fs, path, process, buffer, events, crypto hashing, child_process, os, url, util, zlib, timers, stream and more, plus fetch, URL and TextEncoder. N-API addons pass the conformance suite.
• Bun APIs Bun.file, Bun.write, Bun.spawn (Bun's own spawn tests pass on macOS), Bun.hash, Bun.inspect, Bun.which, Bun.sleep and friends. Bun.serve, Bun.$ and Bun.SQLite are not in yet.
• Test home test runs bun:test suites (describe, test, expect, lifecycle hooks, snapshots) on Home's own VM.
• Bundle home build app.ts bundles the module graph into a standalone executable, for browser, Bun or Node targets, as ESM, CommonJS or IIFE, with source maps.
• Packages home install, add, remove, update, outdated and audit, plus native ports of pack, publish and the pm utilities.

A native language

The other half: .home files that read like TypeScript and compile to native binaries, with no garbage collector and no runtime shipped beside them. The speed of Zig, the safety of Rust, the joy of TypeScript.

• Familiar syntax let, let mut and const, string interpolation, ranges, structs, enums with payloads, match and if as expressions.
• Safety Exhaustive matching (every case, or it does not compile), Result with ? propagation, and null-safety operators like ?. and ??.
• Memory Lifetimes settled by ownership and borrowing instead of a collector. The ownership and borrow checkers are being built now.
• Compile time Generics, traits, macros and comptime functions: compile time is just code.
• Native output Its own x86-64 and arm64 backends write Mach-O and ELF directly, and --kernel emits freestanding code. A tree-walking interpreter runs everything today while the backends mature.
• C interop Call C through extern "C", and describe package APIs with .d.hm declaration files.

Tooling

One binary, one cache, one set of diagnostics for a repository that mixes both languages.

• Language server home lsp --stdio is one server for TypeScript, JavaScript and .home files, reading your tsconfig.json.
• Editor A VS Code extension with grammar, snippets and a debug adapter, now covering TypeScript too.
• Everyday commands home init, check, lint --fix, fmt, docs, doctor, explain for any diagnostic code, and shell completions.
• Built with Zig, in about 136 packages, under the MIT license.

A taste

fn fib(n: int): int {
  if (n <= 1) { return n }
  return fib(n - 1) + fib(n - 2)
}

fn main() {
  let result = fib(10)
  print("Fibonacci(10) = {result}")
}

Built in Home

• home-os An open-source operating system written entirely in Home. Early bring-up: a Home-compiled kernel boots in QEMU.
• Generals Command & Conquer: Generals, Zero Hour, rewritten in Home. Games are where a systems language proves itself.