North star
Speed · speed · speed · concurrency & parallelism first-class · security first-class · no GC · fast builds · deployable native binary where supported · strong stdlib.
The game: run as close to Rust as possible, with first-class concurrency
and parallelism (crew / kick / join / fan / channels / actors) that do
not leak work or color the whole language, and first-class security (memory,
crews, secrets, secure defaults) that does not silently tax the hot path.
Write-ups: SPEED.md · SECURITY.md.
Why Mako exists: fix the real pain points of Go and Rust without cloning
either language. Go’s GC/nil/err-noise/goroutine leaks and Rust’s
lifetime/trait/async ceremony are product problems we answer with Mako
tools (hold/share/arena, crew/kick/fan, Result/?, enum/match,
pack/pull). Full map: PAIN_POINTS.md.
Product goal: Mako is a versatile, general-purpose backend and infrastructure language. It aims to be approachable and deployable, with strong safety mechanisms, a Rust-class performance bar, first-class concurrent/parallel work, and low cognitive overhead for everyday backend work.
| Principle | What it means |
|---|---|
| Speed first | The name of the game — as close to Rust as possible (PERFORMANCE.md, SPEED.md) |
| Concurrency first-class | crew / kick / join / channels / select / actor — structured, no free-fire leaks |
| Parallelism first-class | fan + multi-kick crews — use the cores without a third-party pool |
| Security first-class | Compiler + runtime contract — NLL, bounds, secrets, secure stdlib (SECURITY.md) |
| Simple syntax | Clean, readable code that gets out of your way |
| Low ceremony | Real work without a lot of typing (ERGONOMICS.md) |
| Fast builds | Compile times stay short even as projects grow |
| Easy deploy | Static binaries where the target/toolchain supports them; otherwise document runtime libraries |
| Practical stdlib | Batteries included for real backend work |
| Memory safety | Ownership, arenas, explicit resource control — active UAF prevention, not a formal proof |
| Low-overhead abstractions | High-level constructs compile to efficient machine code |
Mako is for backend software, cloud infrastructure, networking systems, developer tools, databases, and high-performance services — without academic ceremony and without a mandatory garbage collector. Product surfaces that must work over time:
mako init --backend)examples/db_engine/, plus SQL clients)-O3 -flto, no GC — PERFORMANCE.md)Core promise: Ship fast binaries, run concurrent and parallel work as a first-class part of the language, stay safe without a GC, keep everyday code short.
Syntax promise: Mako has its own flair — not a Go or Rust clone. It may
accept dual spellings for familiarity, but preferred docs, examples, and
mako fmt always lead with Mako forms: fn, let, on, pack / pull,
hold / share / arena, crew / kick / join, match, export,
.mko. See IDENTITY.md.
Honest status lives in STATUS.md. How to write Mako today: The Mako Book (guided tour) and GUIDE.md (verified syntax). This file is the product map (includes Target ideas).
| Pillar | Target |
|---|---|
| Memory | Ownership + arenas; RC/manual escapes; no tracing GC |
| Speed | Rust-class hot path; measure; no silent cost |
| Concurrency | First-class crew / channels / actors / select (structured) |
| Parallelism | First-class fan + multi-kick crews |
| Syntax | Unique Mako surface; familiar, concise, practical backend style |
| Errors | Explicit, typed, easy ? — unused Result is illegal |
| Tooling | pkg, fmt, lint, test, bench, docs, audit, cross-compile, IDE/LSP |
| Stdlib | net/tls/quic/http/ws, JSON/CBOR/…, DB drivers, queues, observability |
| Systems | Drivers, protocols, DBs, engines, compilers |
| Generics | List<T>, Map<K,V>, Result<T,E> — light interfaces |
| Deploy | Static binaries, small containers, WASM later, fast startup |
Mako should be equally comfortable for:
The standard for "general purpose" is practical: a beginner should be able to ship a simple API, and an expert should be able to build a database, proxy, compiler, or distributed runtime.
Session-oriented servers remain a high-value proving ground: VoIP/telecom, game rooms, connection brokers, streaming gateways, and realtime collaboration.
// Target surface (actors)
actor Session {
state Call
receive Invite
receive Bye
receive Timer
}
The actor model keeps actor state behind message passing rather than exposing
it as ordinary shared mutable state. Under the hood today: mailboxes on
channels + crew (see examples/actor.mko). This is a language/runtime design
boundary. The compiler enforces this boundary for safe Mako kick/fan code;
generated C, FFI, and explicit unsafe code remain outside that guarantee.
This track should guide runtime and networking decisions without becoming the language's entire identity:
| Layer | Priority |
|---|---|
| Transport | TCP, UDP, TLS, WebSocket, HTTP/1.1, HTTP/2, HTTP/3, QUIC |
| Telecom | SIP parsing/building, RTP/SRTP packet primitives, session timers |
| Runtime | Lightweight tasks, actors, bounded channels, high-performance timers |
| Memory | Request arenas, pools, ring buffers, zero-copy packet views |
| Observability | Metrics, tracing, profiling, structured logs |
| Deploy | Static binaries, fast cross-compile, Linux/macOS/Windows/ARM/WASM |
The rule of thumb: a SIP proxy, signaling server, session controller, WebSocket gateway, or job worker should all feel like obvious Mako programs.
| Mode | When | Status |
|---|---|---|
| Ownership / scopes | Default | Now |
arena |
Request/batch | Now |
share / RC |
Opt-in graphs | Next |
hold / manual |
Systems escapes | Next |
| GC | No tracing collector | Now |
No tracing GC. See SECURITY.md.
Zero-copy: string region ops (str_slice_* / str_at_eq / str_byte_at) are
Now — compare/search s[off:off+len] without substring alloc. Packet/file
views, borrowed buffers, and pools continue under Next/Later.
| Feature | Status |
|---|---|
crew / kick / join / fan |
Now |
| Channels | Now |
crew.cancel |
Now |
| Actors (mailbox + owned state) | Now (seed) |
| Timeouts (portable) | Now (seed) — timeout_portable_test |
| Async I/O without colored functions | Now (seed) — native IO / poll / wait |
| Auto cancellation on scope exit | Now (partial via crew) — full product residual |
| Deterministic scheduling | Later |
Async goal: normal-looking code, runtime does I/O; structured concurrency keeps lifetimes honest.
Now (seed):
actor Counter {
n: int = 0
receive Inc { self.n = self.n + 1 }
receive Bye { let _ = 0 }
}
// Counter_spawn() / Counter_spawn_cap(n) · Counter_send · Counter_loop
Owned state + self.field in receives; packed mailboxes (tag + optional int
payload: receive Inc(delta)); Bye/Stop ends the loop. Multi-field /
string payloads and supervision remain Later.
Target builtins: tcp / udp / tls / dns / quic / http / websocket / grpc with
.listen()-style APIs.
| Piece | Status |
|---|---|
tcp_listen / tcp_accept / tcp_close / write helpers |
Now |
http_serve / http_echo |
Now |
| TLS / QUIC / WebSocket / DNS / gRPC | Now (seeds) — depth/product residual |
Backend APIs also need routing, middleware, auth, validation, cookies/sessions, file uploads, rate limiting, compression, caching, graceful shutdown, health checks, and background jobs. These should live in stdlib packages or official extensions before third-party frameworks become mandatory.
| Format | Status |
|---|---|
| JSON (manual / echo) | Seed |
| XML / YAML / TOML / CSV | Now (YAML/TOML config subset + CSV/XML; full YAML 1.2 / TOML 1.0 Later) |
| Binary / CBOR / MessagePack / Protobuf / Avro | Later |
derive(JSON) / derive(SQL) compile-time |
Later — no runtime reflect tax |
Built-in SQL (Later): typed select verified by the compiler. Raw SQL must
always remain available. Database support should cover PostgreSQL, MySQL /
MariaDB, SQLite, Redis, MongoDB-style document stores, Cassandra/ClickHouse, and
Elasticsearch-compatible systems through stdlib or official packages.
Light interfaces — compile-time method sets, dyn dispatch, easy mocks.
Now (seed): interface Adder { fn add(int) -> int } +
on Counter : Adder { fn add(self, …) } (or free Adder_Counter_add).
No trait maze; embedding/generic bounds remain Later.
| Capability | Status |
|---|---|
mako.toml + mako.lock |
Now (foundation) |
| Version pinning / content hashes | Now (local lock foundation; registry and reproducibility depth remain) |
| Private modules / path deps | Next |
| Reproducible builds | Next |
Supply-chain / vuln scan (mako pkg audit) |
Now (offline advisory + license policy) |
| Minimal transitive deps (culture + tooling) | Ongoing |
No null · bounds checks · safe strings · unused Result illegal · secure TLS defaults (Next) · crypto done right (Next) · vuln checks in pkg (Next). Details: SECURITY.md.
| Tool | Status |
|---|---|
| Clear runtime abort messages | Now |
| Stack traces / debugger | Next |
| Race / deadlock / leak detectors | Next |
| CPU / memory / alloc profiler | Next |
| Compiler hints (avoidable allocs, useless locks, escape analysis) | Later |
| Deterministic latency / scheduling | Later |
Observability is part of the language product, not an afterthought: backend programs should get cheap counters, spans, structured logs, and profiling hooks without pulling in a large framework.
Unit · integration · fuzz · bench · race · property · snapshot · mocks —
Now (mako test / mako bench are implemented; coverage and diagnostics
depth continue to improve).
Coverage, fixtures, parallel tests, leak/race detection, and end-to-end test helpers are part of the general-purpose backend bar.
Strong backward compat, clear versioning (0.2.1 tip), stable stdlib, no constant breaks. API stability annotations — Later. Module isolation — Later.
| Tool | Status |
|---|---|
mako check / build / run |
Now |
mako fmt / lint / test / bench |
Implemented — deeper IDE/debug workflows remain |
mako pkg init / lock / audit |
Now |
| Docs generator | Later |
| LSP: rename / extract / debug / profile | Later (day-one intent) |
| Cross-compile | Later |
| Incremental compile (1M LOC < 2s rebuild) | Later |
| WASM target | Later |
| Runtime introspection / AI compiler metadata hooks | Later |
| Domain extensions without fragmentation | Later |
The official toolchain should be a single coherent product: compiler, package manager, formatter, linter, tests, benchmarks, docs, dependency auditor, profiler, debugger integration, LSP, cross-compiler, and build system — all working together out of the box.
| Theme | Status |
|---|---|
| Systems audience (drivers, engines, protocols) | Vision Now |
| SIMD vector types | Later |
| GPU AI seed (matmul/activations; OpenCL multi-vendor + host) | Seed done — build inference blocks in Mako |
| Local models (safetensors + author nets + .makomodel) | Seed done |
| AI depth (attention, layernorm, GGUF/LLM runtime, tokenizer) | Later |
gpu fn / Metal-native / CUDA / Vulkan |
Later (same buffer/dispatch surface) |
| DB engine primitives (storage/index/tx/cache) | Later |
Comptime const x = scan(...) |
Later |
Single static binaries · small containers · easy cross-compile · fast startup · low memory · deploy awareness in tooling (Later).
Targets: Linux, Windows, macOS, FreeBSD, ARM, x86-64, RISC-V, and WebAssembly. Applications should fit single binaries, minimal containers, system services, serverless functions, edge apps, desktop utilities, and embedded agents.
actor / receive syntax · portable timeouts · real http.Request + TLS hold / share · interfaces · mako test for real