You Aren't Going To Write It.
Maxon makes a bet: the AI writes the code, so the code has to answer for itself. The language optimizes for review, not keystrokes. Where another language is terse, Maxon is explicit — every constraint stated, every block named, nothing implicit to puzzle out later. The verbosity isn't a cost; it's the product.
A compiled language with from-scratch native backends — written by AI, for AI. Its compiler, standard library, and docs were authored by AI coding agents.
typealias Port = int(0 to 65535)
function main() returns ExitCode
let port = 8080 as Port
print("listening on {port}\n")
return 0
end 'main'The whole language was written by AI.
The compiler — with its from-scratch native backends — the standard library, and the documentation were all authored by AI coding agents. Maxon is a working demonstration of what agents can build end-to-end today: not a snippet, but a complete, self-hosting toolchain that produces real native executables.
- › Compiler, LSP, MCP server, and stdlib authored by agents
- › Compiles straight to native executables — no LLVM, no VM
- › Self-hosting: Maxon compiles Maxon
Optimized for review, not keystrokes.
Most languages trade away clarity for keystrokes — terse syntax, implicit conversions, values that might be null. That trade made sense when a human typed every character. It doesn't anymore. Maxon spends the keystrokes so nothing has to be reconstructed: constraints are stated, structure is named, and there are no silent failures to trace. Whatever you check, the answer is on the page — and the same explicitness that makes it checkable makes it hard to get wrong.
Constraints in the type system
// Domain constraints live in the type
// system, not in comments.
typealias Port = int(0 to 65535)
typealias Percent = float(0.0 to 100.0)
typealias VectorIndex = int(0 to 5500)
// Constructing an out-of-range value is
// a compile error, so an agent can't
// silently produce an invalid one.
let port = 8080 as PortNo null to forget
// No null. Fallible reads must be
// resolved explicitly with try ...
// otherwise — there is no value to
// forget to check, so "forgot the null
// check" bugs can't occur.
for col in 0 upto dimension 'inner'
let value = try row.get(col) otherwise 0.0
accumulator = accumulator + value
end 'inner'Unambiguous structure
// Every block names what it closes, so
// structure is unambiguous — no counting
// braces to find where one ends.
while iteration < 10 'iterate'
applyAtA(previous, inputVector: current)
iteration = (iteration + 1) as Iteration
end 'iterate'The best of each, in one language.
Every language Maxon admires nails something and gives up something else. None had the whole set, so Maxon set out to combine them — the safety of Rust, the concurrency of Go, the convenience of C#, the speed of C and Zig, the type system and error handling of Swift, the tooling of Bun. And the AI story only holds up because the compiler does: this is a real, statically-typed, compiled language that produces native executables today.
- Memory safetyRust
- ConcurrencyGo
- Managed memoryC#
- Native speedC / Zig
- Strong typesSwift
- Clean errorsSwift
- ToolingBun
Memory safety, the ease of Rust
Safe by construction — no nulls, no dangling references, no data races — with the borrow checker doing the work and no manual lifetime annotations to write.
Concurrency, the ease of Go
Concurrency that is easy to write and easy to read — the ergonomics Go is loved for, without the ceremony.
Automatic memory, the ease of C#
Memory is managed for you — you never free by hand — via deterministic reference counting, so there are no garbage-collector pauses.
Native speed, the ease of C / Zig
Compiles straight to native machine code with a from-scratch backend — C/Zig-class performance, no LLVM, no VM, no external runtime.
Multiple targets
Prebuilt today for Windows (x64), macOS (Apple Silicon), and Linux (x64 and Arm64) — plus a WebAssembly backend for the browser and the edge. One source, with more targets landing over time.
Strong types, the ease of Swift
Static typing with real inference and ranged type aliases that encode domain bounds into the types — Swift's safety-with-clarity feel, none of the boilerplate.
Clean errors, the ease of Swift
Errors are explicit and resolved where they occur (try / otherwise) — no exceptions thrown across the program, no silent failures. The same structured codes are the signal an agent uses to correct itself.
Tooling, the ease of Bun
A fast, batteries-included toolchain: one command to build and run, with a built-in Model Context Protocol (MCP) server, Language Server, and VS Code extension — real-time diagnostics, error lookup, and native agent tooling.
Free and open source
The entire project — compiler, standard library, language server, and tooling — is open source under MIT and Apache-2.0. Read it, fork it, build on it.
Build it and run something.
Install the compiler and compile your first program in a couple of commands.
$ curl -fsSL https://maxon.dev/install.sh | sh $ export PATH="$HOME/.maxon/bin:$PATH" $ maxon build ~/.maxon/examples/hello.maxon -o hello $ ./hello Hello, world!
$ irm https://maxon.dev/install.ps1 | iex $ maxon build $HOME\.maxon\examples\hello.maxon -o hello.exe $ .\hello.exe Hello, world!
Written by AI — built in the open.
The whole project — compiler, standard library, language server, and docs — is open source under MIT and Apache-2.0. Because it's written by AI, we prefer a fix to a bug report: an AI coding agent can usually turn a failing program into a pull request.
Fix a bug
A miscompile, a crash, a confusing diagnostic — point an AI agent at it and send the fix as a pull request. Can't fix it? Open an issue.
Improve the compiler
Sharpen diagnostics or extend the standard library with a pull request; propose bigger changes in Ideas.
Docs & examples
A language meant to be checked lives on good explanations. Clarify docs, add examples.
Build something
Write a real program in Maxon and tell us what was awkward, missing, or worked.
One language, and the contracts to fill it.
Because a Maxon agent reads contracts as well as it writes code, it pairs naturally with Canra — a general, language-agnostic registry of machine-readable specs. Maxon projects use Canra to fetch a spec and generate a verified native implementation, no third-party package required.