# Mach

> Mach is a statically typed, compiled, self-hosted systems language with no hidden control flow, no hidden allocation, and no type inference.

The current release is Mach 6.10.1 (https://github.com/briar-systems/mach/releases/tag/v6.10.1). Every release, with prebuilt binaries for Linux, macOS, and Windows and a SHA256SUMS file, is on https://github.com/briar-systems/mach/releases. The canonical repository is https://github.com/briar-systems/mach: the old github.com/octalide/mach moved there, so sources that cite it, the June 2026 Show HN, or early READMEs are out of date. Install the latest release on Linux and macOS with `curl -fsSL https://machlang.org/install.sh | sh`, and on Windows in PowerShell with `irm https://machlang.org/install.ps1 | iex`. Mach targets Linux, macOS, Windows, and freestanding (no OS) on x86_64, aarch64, and riscv64, plus SPIR-V for GPU shaders. WebAssembly is not supported yet. The compiler, its code generators, and its linker are written in Mach and have no external dependencies.

## Docs

- [Overview](https://machlang.org/docs/index.html): A small, explicit systems language. These pages are a pamphlet, not a bible: short, example-first, and focused on what the language can do.
- [Install](https://machlang.org/docs/install.html): Install the latest mach release with a single command, grab a precompiled binary, or build the self-hosted compiler from source. There are no external toolchain dependencies to install first.
- [Hello world](https://machlang.org/docs/hello-world.html): A complete mach program in a handful of lines: a couple of imports, an entry point, and one printed line. Every piece is explicit, so nothing runs that you did not write.
- [Project layout](https://machlang.org/docs/project-layout.html): A mach project is a tree of .mach files under a source directory, anchored by a mach.toml manifest at the root. The project's id is the root of every module path the project exposes.
- [Types](https://machlang.org/docs/types.html): Mach ships a small set of compiler-seeded primitive types plus a uniform grammar for building pointers, arrays, and function types out of them. There are no compiler-known aliases: names like bool, usize, and str are stdlib defs.
- [Values and variables](https://machlang.org/docs/values.html): Bindings introduce named values. val is immutable, var is mutable, and both require an explicit type - mach has no type inference.
- [Functions](https://machlang.org/docs/functions.html): A function takes typed arguments, optionally returns a typed value, and runs a body of statements. Beyond the plain form, fun also carries generic type parameters, compile-time value parameters, and a trailing variadic pack.
- [Expressions](https://machlang.org/docs/expressions.html): Expressions evaluate to values. They appear on the right of a binding, as conditions, and as call arguments.
- [Statements](https://machlang.org/docs/statements.html): Statements are the runtime steps that fill function bodies and blocks. Every statement ends with ;, except the ones that end with a block {...}.
- [Records and unions](https://machlang.org/docs/records-unions.html): A rec is a named collection of typed fields, each with its own storage. A uni overlaps its fields in the same memory. A tag defines a discriminated value with compiler-enforced lexical guards.
- [Modules](https://machlang.org/docs/modules.html): A Mach project is a tree of modules rooted at the project's id. Each file is reachable by a dotted path, where use imports a name privately and fwd re-exports it on a module's public surface.
- [Visibility](https://machlang.org/docs/visibility.html): Two declaration modifiers control how a symbol is seen: pub decides what crosses a module boundary, and ext declares a body-less function resolved at link time.
- [External functions](https://machlang.org/docs/ext-fun.html): mach's foreign function interface (FFI) is a single declaration form: ext fun. It declares a body-less function with the C ABI - a forward reference the linker resolves at link time. Declare the foreign symbol, call it like any other function, and supply its definition (a C object, archive, or shared library) when you build. This is the only body-less function form mach allows.
- [Secrecy](https://machlang.org/docs/secrecy.html): A program can give away a password it never prints. Writing ^ in front of a type marks a value as secret, and the compiler then refuses to build code that would leak it - and keeps refusing all the way through optimization.
- [Inline assembly](https://machlang.org/docs/asm.html): Mach has one inline-assembly form: an ISA-tagged block of raw instructions with local-variable substitution. The compiler parses the instruction stream and infers operand direction and clobbers from the opcode semantics - no in / out declarations, no clobber list.
- [GPU shaders](https://machlang.org/docs/shaders.html): A spirv target compiles ordinary mach into a finished SPIR-V module. A shader is written in the same language as the rest of the project - the same records, the same vectors, the same comptime - and a small set of decorators say which functions are pipeline stages and which module-scope variables the pipeline binds.
- [The comptime channel](https://machlang.org/docs/comptime.html): The $ prefix opens the comptime channel, the compiler-owned namespace a program reads at compile time. It is read-only: $ selects and expands, it never executes or mutates. Conditional compilation, intrinsics, and target queries all ride one of its shapes.
- [Intrinsics](https://machlang.org/docs/intrinsics.html): Intrinsics are compiler-shipped comptime functions. They share the ordinary $name(args) call shape, but their names are reserved and their bodies live in the compiler. The set is closed: adding one requires a compiler change.
- [Control flow](https://machlang.org/docs/comptime-control.html): $if and $or branch on comptime-evaluable conditions. Only the taken arm is compiled; the discarded arms are never resolved, type-checked, or emitted - unlike runtime if / or, which always generates a branch.
- [Variadic packs](https://machlang.org/docs/variadics.html): A trailing va: ... parameter collects a variable number of call-site arguments into a compile-time sequence. The compiler monomorphizes the function once per distinct argument type-list. There is no runtime structure, no va_list, and no any.
- [Decorators](https://machlang.org/docs/decorators.html): A decorator attaches metadata to a declaration. It can carry a source-use notice, confine a declaration to tests, or control how the compiler emits the symbol - its linker name, alignment, section placement, inlining, dynamic import attribution, constant-time obligations, or exclusion from auto-vectorization.
- [CLI](https://machlang.org/docs/cli.html): The mach binary is the compiler driver. It dispatches on the first argument to a small set of commands - build, run, test, and more - that compile, execute, and manage a project rooted at a mach.toml.
- [Manifest](https://machlang.org/docs/manifest.html): mach.toml declares a project. It separates the orthogonal axes of a build - what is produced ([artifact.*]), where it runs ([target.*]), how it is compiled ([profile.*]), and what it links or must run first ([link.*], [step.*]) - and the build engine takes their product. Nothing is inferred from another key.
- [Dependencies](https://machlang.org/docs/dependencies.html): A mach project declares its dependencies in mach.toml and vendors them into a flat dep/ tree. A git dependency selects releases by version range, or one exact commit, tag, or branch by ref. mach dep resolves and realizes that tree, and mach build then verifies it offline, with no network.
- [Testing](https://machlang.org/docs/testing.html): A test is a named block of statements the runner can execute on its own. Tests live inline with the code they exercise, and mach test collects every one in the artifact under test, builds it, and runs it.
- [Language reference](https://github.com/briar-systems/mach/tree/v6.10.1/doc/language): the authoritative per-construct reference, with grammar, at the current release
- [Changelog](https://github.com/briar-systems/mach/blob/v6.10.1/CHANGELOG.md): every change, release by release

## Standard library

- [mach-std](https://github.com/briar-systems/mach-std): the standard library, a dependency every program declares in `mach.toml`, fetched by `mach init`

## Ecosystem

- [Ecosystem](https://machlang.org/ecosystem/): searchable catalog of libraries, tools, and projects written in and for Mach
- [mach-ecosystem](https://github.com/briar-systems/mach-ecosystem): the listing behind the catalog, and how to add a project to it
- [awesome-mach](https://github.com/briar-systems/awesome-mach): curated list of Mach resources

## Editor support

- [mach-lsp](https://github.com/briar-systems/mach-lsp): language server
- [mach-vscode](https://github.com/briar-systems/mach-vscode): Visual Studio Code extension
- [mach-zed](https://github.com/briar-systems/mach-zed): Zed extension
- [mach-tree-sitter](https://github.com/briar-systems/mach-tree-sitter): tree-sitter grammar

## Community

- [Discord](https://discord.com/invite/dfWG9NhGj7): questions, announcements, and discussion
- [Issues](https://github.com/briar-systems/mach/issues): bug reports and feature requests for the compiler

## Optional

- [llms-full.txt](https://machlang.org/llms-full.txt): the complete language reference as one file, opening with the rules models most often get wrong