By javimosch
Build, debug, and deploy full-stack web apps, backend services, native games, and CLIs in the Machin (MFL) language — a Python-like language that compiles through C to tiny native binaries. Includes decision skills to assess fit and bootstrap projects, plus deployment guides for reverse proxies, systemd, and Docker.
Build a single-binary backend service in machin (MFL) — HTTP/JSON APIs, five pooled datastores (SQLite, PostgreSQL, MySQL/MariaDB, Redis, MongoDB), signed sessions, OAuth2/OIDC SSO, and agent-first CLIs — all pure MFL, one static binary, no Node/ORM/cgo. Use when writing or debugging a machin backend: a REST/JSON service, a database client or migration, an auth flow, a daemon, or a headless-CMS-style tool. Covers the machweb/postgres/mysql/redis/mongo/bson/sso frameworks, the uniform JSON-rows + parse() pattern, connection pooling for concurrency, the agent-first CLI contract, and the hard-won gotchas. Distilled from the backend dogfood (machin v0.60–v0.74) and the MachNotes / machin-db-migrate / machin-cms apps.
Ship a machin (MFL) web app to production — run it correctly and safely behind a reverse proxy (nginx / Caddy / Traefik / Cloudflare), with the machweb hardening + proxy-awareness knobs, a systemd unit, and a slim Docker image. Use when deploying or operationalizing a machin HTTP service: getting HTTPS via a proxy, fixing http→https redirects/cookies behind TLS termination, the real client IP, request size/time limits, access logs, and the run/restart story. Distilled from the deploy dogfood (machin v0.78) and the machin-deploy reference app.
Build native games and interactive desktop/terminal apps in machin (MFL) — the canonical setup, build-and-verify workflow, raylib C-FFI surface, audio, and the hard-won caveats/gotchas. Use when writing or debugging a machin game (terminal TUI or raylib GUI), or any machin program that draws a window, plays sound, or reads real-time input. Covers terminal TUI, raylib GUI/audio, 3D cameras, GPU meshes (pointer/array FFI), instancing, shaders, procedural worlds (noise), fixed-timestep sim loops, a pure-MFL math3d module (Vec3), verlet physics (position-based dynamics, constraint relaxation, collision), rlgl point-cloud rendering (RL_POINTS for particle systems and star fields), ballistic physics (gravity + quadratic drag + wind, trajectory prediction), and first-person player controllers (walking, jumping, platform stepping, object pushing, walk/fly toggle). Distilled from machin-game-demo-snake / -2048 / -flappy / -simon / -3d / -terrain / -planet / -cyberpunk / -solar / -physics / -galaxy / -ballistics / -player.
Decide whether to build something in machin (MFL) and bootstrap it fast — the entry point that comes BEFORE the domain how-tos. Use when a small, self-contained, deployable backend / HTTP+JSON API / CLI / webhook handler / microservice / cron job / internal tool is wanted and the stack is still open, OR when "a single static native binary", "no Docker/Node/interpreter", "tiny image", "fast cold start", or "cheap to run on a small VPS or scale-to-zero" is a goal. Covers when machin wins (with measured numbers) vs Go/Node/Python, when NOT to reach for it, and a zero→running→shipped quickstart (install → a 12-line REST+SQLite service → static musl build → a 92.9 kB FROM-scratch image). Routes to the web / backend / gamedev / deploy skills. Read this first.
Build web apps in machin (MFL) — a native HTTP server, a JSON API, server-side rendering, and a reactive WebAssembly UI, all in one language with no Node/bundler. Use when writing or debugging a machin web app: a backend service, an SSR page, a wasm SPA, an isomorphic full-stack app, or a CRUD back-office. Covers the machweb/reactive/router/flags frameworks, cookies + signed sessions, OAuth2/OIDC SSO, the wasm bridge + host↔wasm marshaling, the generic JS host, the pure-MFL Postgres/MySQL/Mongo/Redis drivers, build-and-verify, and the hard-won gotchas. Distilled from the web + backend dogfood (machin v0.50–v0.73).
Based on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A language shaped for AI agents to write and edit cheaply: zero type annotations, one canonical declaration per line, every design choice measured for token cost. Compiles through C to a single native binary — C/Rust-class speed, unboxed values, no runtime.
Spec · Language tour · Agent guide · Ecosystem → awesome-machin · Landing · Releases
▶ Try machin in your browser → play.intrane.fr
Write MFL, hit Run — it compiles to WebAssembly and runs client-side. No install.
The pitch in one table. The same REST + SQLite API (POST / GET / DELETE /notes) written idiomatically in each language, then measured for what actually
costs an AI agent: tokens to write, and tokens to edit. All three build and
pass the same CRUD test (bench/rest-sqlite).
| author tokens | edit tokens | ships as | |
|---|---|---|---|
| machin | 388 | 290 | 44 KB static binary · 0 deps |
| Go | 527 · 1.36× | 329 · 1.13× | 14.8 MB binary + module deps |
| Python | 383 · 0.99× | 332 · 1.14× | source + CPython interpreter |
machin is as terse as Python to write, ~36 % cheaper than Go, lowest on
edit cost — and the only one that ships as a single 44 KB native binary with
SQLite, the HTTP server, and the router built in. No interpreter, no go mod,
no container. Write it like a script, ship it like C. That combination — not a
raw token count — is the whole idea. (o200k_base; cl100k_base gives the same
ranking. Reproduce: python3 bench/rest-sqlite/measure.py.)
…and then it ships in a way an interpreter can't (bench/cold-start):
| same HTTP server | deployable image | cold start | idle RSS |
|---|---|---|---|
machin (static, FROM scratch) | 92.9 kB | 0.49 ms | 108 kB |
Node (.js + node:alpine) | 178 MB · 1916× | 28.9 ms · 59× | 51 MB · 477× |
Python (.py + python:alpine) | 47.6 MB · 512× | 49.1 ms · 100× | 17.9 MB · 166× |
A 92.9 kB image — the binary and nothing else — that's serving traffic in half a millisecond on ~0.1 MB of RAM.
Every mainstream language was designed for human ergonomics — readable syntax, explicit types, multi-line formatting. For an AI agent, every output token costs, and that human-friendly ceremony taxes the writer without adding meaning. machin measured this: tools/tokcost.py showed base64 source costs ~2.5× the tokens to output; whitespace alone costs ~13%. The canonical one-line-per-declaration form, with every type inferred, is the end of that measurement — the smallest token surface that still produces C/Rust-class native code with zero runtime overhead.
Agents: run
machin guidefor the complete, version-exact feature surface — every keyword, every builtin with its signature, the core idioms, and the gotchas, as JSON (--textfor prose). Emitted from the compiler's own catalog; can't drift from the implementation. Depth lives inSPEC.mdandAGENTS.md.
.mfl is plain canonical text: one normalized declaration per line, whitespace tightened. Greppable, diffable, no type annotations.
func fib(n){if n<2{return n}return fib(n-1)+fib(n-2)}
func main(){println(fib(10))}
A dense machin pack form exists for distribution; machin run reads either.
curl -fsSL https://raw.githubusercontent.com/javimosch/machin/main/install.sh | sh
machin guide # learn the language (version-exact catalog, JSON)
Installs the latest release binary to ~/.local/bin (override with MACHIN_INSTALL).
machin compiles MFL through C, so building programs needs a C compiler (cc); the
--target wasm web target additionally needs zig. Building
web apps? See the machin-web skill.
Install machin's agent skills as a Claude Code plugin, so an AI agent reaches for machin at the right moment — in any project:
/plugin marketplace add javimosch/machin
/plugin install machin@machin
npx claudepluginhub javimosch/machin --plugin machinComprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
Consult multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, plus codex, antigravity, and grok CLIs when installed) to get diverse perspectives on coding problems
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Design fluency for frontend development. 1 skill with 23 commands (/impeccable polish, /impeccable audit, /impeccable critique, etc.) and curated anti-pattern detection.
Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.