home-lang/home

A modern programming language for systems, apps, and games —
the speed of Zig, the safety of Rust, the joy of TypeScript.

Website · Documentation · Getting started · Parity status · Changelog

Home compiles to native binaries with no garbage collector and no runtime to ship alongside them. The same toolchain also type-checks and builds the TypeScript you already have: home-tsc reads your tsconfig.json and emits tsc-compatible diagnostics, and home run executes TypeScript and JavaScript on Home's own JavaScriptCore realm.

Status: under active development. The lexer, parser, type inference, TypeScript front end, and tree-walking interpreter are usable today; native codegen, tooling, and the Bun-compatible runtime are still maturing. Project status has the short version and Parity status has every number with the harness that produces it.

Install

curl -fsSL https://raw.githubusercontent.com/home-lang/home/main/install.sh | bash

The installer detects your platform, downloads a release tarball from GitHub Releases, verifies its checksum, and installs the home binary to ~/.home/bin. macOS (Intel + Apple Silicon), Linux (x64 + arm64), and Windows (x64 + arm64, via Git Bash / WSL) are supported.

Environment variables: HOME_VERSION pins a release tag (default latest), HOME_INSTALL_DIR overrides the install location (default ~/.home), and HOME_BIN_DIR overrides where the binary is placed.

Quick start

// hello.home
fn main() {
  print("Hello, Home!")
}

home build hello.home    # native executable, nothing to install beside it
./hello                  # Hello, Home!

home run hello.home      # or run it directly
home check hello.home    # type-check without building

Source files use the .home extension, or .hm for short. The getting started guide walks through a first project.

Why Home

• Native binaries, no collector. Ownership and borrowing settle lifetimes at compile time — no pauses, no runtime shipped beside the binary. (memory model)
• One toolchain for two languages. The same compiler builds .home files and type-checks TypeScript, so a mixed codebase needs one tool instead of two. (how it works)
• Exhaustive pattern matching. A missing branch is a compile error, not a runtime surprise. (pattern matching)
• Compile time is just code. comptime runs real Home during compilation. (comptime)
• Errors as values. Result types with ? propagation, plus null-safety operators (?., ?:, ??, ?[]). (error handling)
• Batteries in the stdlib. HTTP, database, JSON, async, threading and FFI. (standard library)

Language tour

A condensed pass over the syntax. Each section links to the full page in the language guide.

Variables and control flow

let name = "Alice"           // immutable by default
let mut counter = 0          // mutable
let age: int = 25            // explicit type
const PI = 3.14159           // compile-time constant

if (counter > 5) {
  print("big")
} else {
  print("small")
}

for (item in items) { print(item) }
for (i in 0..10) { print(i) }
for (index, item in items) { print("{index}: {item}") }

while (counter < 10) { counter = counter + 1 }

Strings interpolate with {}, ranges come with .len(), .step(), .contains() and .to_array(), and arithmetic includes ** (power) and ~/ (truncating integer division). Full reference: variables and control flow.

Functions

fn add(a: int, b: int): int {
  return a + b
}

fn greet(name: string = "World") {   // default parameters
  print("Hello, {name}!")
}

fn fetch_data(): async Result<Data> {
  let response = await http.get("/api/data")
  return response.json()
}

More: functions, async.

Structs, enums and pattern matching

struct User {
  id: i64
  name: string
}

enum Color {
  Red,
  Green,
  Custom(r: int, g: int, b: int)
}

let user = User { id: 1, name: "Alice" }

match color {
  Color.Red => print("red"),
  Color.Green => print("green"),
  Color.Custom(r, g, b) => print("rgb({r}, {g}, {b})")
}

if and match are expressions, so they return values:

let status = if (code == 200) { "ok" } else { "error" }

let label = match x {
  1 => "one",
  2 => "two",
  _ => "other"
}

More: structs and enums, pattern matching, traits.

Null safety and errors

let name = user?.name ?: "Anonymous"   // elvis
let city = user?.address?.city         // safe navigation
let first = items?[0]                  // safe indexing

fn read_file(path: string): Result<string, Error> {
  let file = fs.open(path)?            // ? propagates errors
  return Ok(file.read_all())
}

match read_file("config.home") {
  Ok(content) => process(content),
  Err(e) => print("Failed: {e}")
}

More: type system, error handling.

Generics and comptime

struct Stack<T> {
  items: []T

  fn push(self, item: T) { self.items.append(item) }
  fn pop(self): Option<T> { return self.items.pop() }
}

comptime fn factorial(n: int): int {
  if (n <= 1) { return 1 }
  return n * factorial(n - 1)
}

const FACT_10 = factorial(10)   // computed at compile time

More: generics, comptime, macros, FFI.

A server, end to end

import http { Server, Response }

fn main() {
  let server = Server.bind(":3000")

  server.get("/users/:id", fn(req): Response {
    let id = req.param("id")
    return Response.json({ id: id })
  })

  server.listen()
}

More: standard library, web services.

TypeScript and JavaScript

Home ships a drop-in tsc / tsgo-compatible TypeScript front end, built as its own set of Zig packages (ts_lexer, ts_parser, binder, ts_checker, ts_emit, ts_program, ts_resolver, ts_lsp, …). It runs the upstream TypeScript conformance corpus and compares byte-for-byte against baselines generated by the reference compiler.

cd my-typescript-app
home-tsc --noEmit        # same diagnostics, same codes, same exit status
home-tsc --watch         # incremental recompiles on change
home-lsp                 # TypeScript language server for your editor
home run server.ts       # run it on Home's own JavaScriptCore realm

home-tsc and home-lsp build alongside the compiler into zig-out/bin/; home lsp --stdio is the separate language server for .home sources. Details: TypeScript compiler, editor and CLI tooling, TypeScript migration.

TypeScript frontend benchmark snapshot

The reproducible frontend suite compares JavaScript TypeScript 6.0.3, native TypeScript 7.0.2 (tsgo), and Home on the same strict, no-emit projects. The current admitted snapshots use 30 fresh processes after three warmups and keep every successful finite sample without filtering.

The latest current-source focused confirmation uses the same 30-run admission and timing rules; it supplements rather than replaces the complete table above:

The latest benchmark-harness correction is reported separately from compiler timings:

The latest untimed correctness gate is reported separately from performance:

The same-parent ReleaseFast audit on the pinned 106-file Zod 4.5.2 graph is reported separately from the admitted synthetic suite:

The next exact-parent audit isolates mapped prototype parameter tuples and contextual receiver returns on that same frozen graph:

The next audit restores callback context for nested member assignments inside generic constructor initializers without publishing approximate imported types:

The dependent-default audit then instantiates later defaults with earlier effective arguments and retains only declaration-backed constraint proofs:

The next correctness audit preserves symbolic indexed-access defaults until earlier effective arguments are available. The production graph stays exactly stable while the focused TypeScript oracle gap closes:

The recursive fixed-point audit then distinguishes declaration-owned defaults from genuinely free outer parameters and applies the same proof across Program boundaries:

The explicit-file CLI gate then verifies that TypeScript boolean options keep the following source path positional and that skipLibCheck changes only declaration-file semantic reporting:

The complementary config-discovery check is source-matched against both pinned TypeScript controls and keeps explicit-file mode unambiguous:

The next owner/projection and narrowing audit uses the unchanged pinned graph and compares complete diagnostic identities rather than only aggregate counts:

The exact member-only projection then crosses an unsupported owner schema through a non-generic local child without weakening whole-schema admission:

The parameterized-callable audit then transfers exact Promise<T> and PromiseLike<T> identities through the same inherited-member path without admitting unsupported whole declarations:

The dependent-constraint audit then resolves later generic bounds using the effective earlier type arguments before validating literal keys:

The conditional indexed-alias audit then propagates an outer schema constraint through both local and imported output<T> aliases without weakening the unconstrained Record key check:

The Map-entry tuple audit then preserves [K, V] positions through array spreads and destructured filter / map callbacks, including leading binding elisions:

The nested default-lib alias audit then aligns parsed generic arguments with ordinary annotation resolution while retaining TS2304 for genuinely missing types:

The collection and generic-relation audit then resolves the default-lib map and set families, follows transitive generic constraints during argument checking, and evaluates conditional object-spread branches without weakening the corresponding negative cases:

The imported-class method audit then projects independently transferable method signatures without admitting an unsupported sibling class graph:

The mapped-handler audit then retains each mapped key parameter as explicit type identity, allowing imported object-literal callback members to specialize nested templates by their concrete property key:

The imported-overload audit then transfers ordered bodyless call signatures across Program ownership and contextually selects an object-literal overload only when arity plus declared property ownership leave one candidate:

The imported-Extract audit then carries standard distributive extraction through conditional mapped-handler aliases without admitting other utility graphs as approximate whole types:

The indexed-domain audit then resolves source-owned indexed-access aliases before mapped-key specialization, preserving exact union coverage and rejecting missing or partially covered properties without widening:

The qualified-declaration audit then admits namespace-qualified references only when their complete Program schema graph is lossless, retaining strict projection and opaque-leaf guards:

The contextual-path audit then projects only the members required by an Extract target when an otherwise useful declaration has opaque siblings:

The truthy-property audit then removes impossible never branches through the normal flow partitioner, while its unchanged Zod A/B rejects the initial locale attribution:

The imported homomorphic-union audit then preserves callback context through Pick/Exclude/partial/intersection pipelines and exact nested indexed constraints without admitting opaque imported graphs wholesale:

The imported Promise-union audit then admits losslessly serialized parameterized built-ins, narrows the false branch of terminating Promise guards, and validates actual multi-statement return unions:

Positive instanceof branches that replace their guarded value now join the assigned true path with the excluded false path at fallthrough:

TypeScript 6.0.3 reports zero diagnostics on this graph. Home still reports 348, so Zod remains outside the cross-compiler timing table until Home also reaches zero diagnostics.

The latest optimization admissions preserve that contextual snapshot while recording both accepted and rejected probes:

See the complete results, rejected-probe evidence, raw-result identifiers, fairness rules, and reproduction steps.

Project status

Conservative on purpose: anything not exercised by an example or a test stays "maturing" even when the underlying code is largely there.

Every figure is a file-count, row-count or byte-for-byte measurement against an external baseline, refreshed with scripts/measure-parity.sh. The full breakdown — headline numbers, per-phase runtime port, LSP method list, frontend performance snapshots — lives in Parity status.

Build from source

Requires the Pantry-pinned Zig 0.17 dev toolchain; nothing is installed globally.

git clone https://github.com/home-lang/home.git
cd home
pantry install              # installs the pinned Zig 0.17 dev toolchain
./pantry/.bin/zig build     # ./pantry/.bin/zig is a stable symlink to it

./zig-out/bin/home build examples/fibonacci.home
./examples/fibonacci

Common commands:

Repository layout

home/
├── src/main.zig      # CLI entry point
├── packages/         # 130+ Zig packages, each with its own tests
│   ├── lexer/  parser/  ast/  types/  codegen/  interpreter/
│   ├── ts_lexer/  ts_parser/  ts_checker/  ts_emit/  ts_program/
│   ├── ts_lsp/  ts_lsp_server/  ts_conformance/  ts_resolver/
│   ├── hir/  binder/  diagnostics/  compat/  runtime/
│   └── ...           # http, database, async, ffi, graphics, …
├── docs/             # Documentation site (home-lang.org)
├── examples/         # Example programs
├── tests/            # Integration tests
└── stdlib/           # Standard library

Monorepo structure and architecture go deeper.

Contributing

Contributions welcome — see CONTRIBUTING.md. Release notes live in CHANGELOG.md.

License

MIT — see LICENSE.