You Aren't Going To Write It.
Maxon makes a bet: the AI writes the code, and you read it. So the language optimizes for the reader, not the typist. 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 a native x86-64 backend — written by AI, for AI. Its compiler, standard library, and docs were authored by AI coding agents.
function main() returns ExitCode
let port = Port{8080}
print("listening on {port}")
return 0
end 'main'The whole language was written by AI.
The compiler — a from-scratch native x86-64 backend — 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, and stdlib authored by agents
- › Compiles to native PE / ELF — no LLVM, no VM
- › Self-hosting: Maxon compiles Maxon
Optimized for the reader, not the typist.
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 the reader never has to guess: constraints are stated, structure is named, and there are no silent failures to trace. The same explicitness that makes it easy to read 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 Percentage = 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 = Port{8080}No 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 inputVector.get(col) otherwise 0.0
accumulator = accumulator + value
end 'inner'Unambiguous structure
// Every block names what it closes. Structure is
// unambiguous to read back — for a human or a model.
while iteration < 10 'iterate'
applyAtA(previous, inputVector: current, dimension: size)
iteration = Iteration{iteration + 1}
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 safety Rust
- Concurrency Go
- Managed memory C#
- Native speed C / Zig
- Strong types Swift
- Clean errors Swift
- Tooling Bun
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.
Runs everywhere
Native executables for Windows, macOS, and Linux on both x86-64 and Arm64 — plus a WebAssembly backend for the browser and the edge. One source, every target.
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 Language Server and VS Code extension in the box — real-time diagnostics, completion, and hover.
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.
Clone the repository, build the compiler, and compile your first program in a couple of commands.
$ dotnet build maxon-sharp $ bin/maxon build examples/basic.maxon
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. Contributions are welcome, whether that's a bug report, a patch, a clearer doc, or a real program written in Maxon.
Report a bug
A miscompile, a crash, a confusing diagnostic — open an issue with a minimal reproduction.
Improve the compiler
Fix bugs, sharpen diagnostics, or extend the standard library with a pull request.
Docs & examples
A language meant to be read 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.