The Jac Programming Language

Jac is a programming language built for coding agents and the humans who direct them. An agent writes one clean, Python-like language, and one compiler checks it end to end and compiles it to Python bytecode, JavaScript, and native machine code, with the entire PyPI, npm, and C ecosystems available without wrappers or interop layers. The things every real application needs (an LLM call, a data model that persists, a REST API, a frontend, a deployment story) are compiler generated and abstracted by the language, not frameworks you assemble around it. The design rests on two properties, synechic and topokinetic (as described in "the ninja book"), and defined further below ("Why Jac").

What you get:

• One binary, your whole toolchain -- one download replaces the python interpreter, the JS runtime, the Rust/Zig/C compilers, and the package managers: nothing for you or your agent to install or configure, and the docs (jac guide) and an MCP server (jac mcp) ship inside it
• One language for the whole stack, compiler-checked end to end -- frontend, backend, and data model are one program under one type checker: a cross-tier mistake your agent makes is a compile error it sees and fixes, not a production surprise, and there is one codebase to maintain, not five
• ~5x less code than a modern full-stack setup -- the difference is glue the compiler now generates: API endpoints, route tables, ORM models, validation, serializers, and migrations nobody writes, reviews, or debugs. A whole full-stack app fits in your agent's context window
• AI is a typed function call, not a framework -- the compiler builds the prompt from your function signature and enforces the return type as the output schema
• Persistence built in -- Objects just persist: no database, no ORM, no migrations
• Laptop to Kubernetes without changing a line -- jac scale deploy builds the images and provisions the cluster: you write no Dockerfile and no YAML. The compiler runtime spools out multipod deployments with spliced out microservices.

It's time to show and stop telling. See all of those features running in one single codebase next.

Try Jac in 30 seconds

Install the self-contained jac binary. No Python, pip, Node, or C toolchain required:

curl -fsSL https://raw.githubusercontent.com/jaseci-labs/jaseci/main/scripts/install.sh | bash

Then scaffold and run the official jaclang.org website -- the site is a full technology demonstration and it ships inside the binary, built end to end in Jac (naturally):

jac create mysite --awesome   # dumps the whole site as your project, pulls npm deps
cd mysite
jac run                       # builds the frontend + wasm, serves on http://localhost:8000

One language spans all three codespaces in this single codebase: the pages and components compile to JavaScript, the endpoints compile to Python and serve over RPC, and the arcade game in game/arena.jac compiles through LLVM to in-browser WebAssembly -- fully borrow-checked, with zero reference counting in the artifact. The docs reader serves the language corpus straight from a real graph, the Ninja Leaderboard persists scores through walkers with no database, and the whole thing is one typechecked, contiguous, synechic codebase. The same tree is the site's source of truth at jac/examples/jaclang_org, and it is what CI runs as its full-stack smoke test.

For a smaller example, jac create mysocial --awetiny scaffolds Tiny JacYac: web, mobile, desktop, and CLI clients sharing feed and scoring services. Run it with cd mysocial then jac run --serve --fleet web.

Prebuilt binaries ship for macOS and Linux; on Windows, use WSL (a native PowerShell installer is coming soon). See the installation guide for versions, upgrading, and IDE setup.

Give it to your agent

Jac is built for agents to write, so the fastest way to start is to hand it to yours. The lowest-effort setup is no setup: point your agent at the jac CLI and tell it to figure it out. A first prompt like this is genuinely enough:

Build me a <your app idea> in Jac. The `jac` binary is installed and self documenting with `jac guide`.

The binary is self-documenting -- jac guide prints curated reference guides on every corner of the language, and one command extracts them as Agent Skills your agent can load directly:

jac guide --export ~/.claude/skills

For a deeper integration, the jac binary also ships an MCP server with Jac validation, formatting, docs, and examples built in. Wire it into Claude Code with one command:

claude mcp add jac -- jac mcp

For Cursor, Windsurf, or any other MCP client, add this to your MCP config (use jac mcp --mode lite for smaller models):

{ "mcpServers": { "jac": { "command": "jac", "args": ["mcp"] } } }

There's a structural reason agents do better in Jac than in a conventional stack. Glue code is most of what coding models emit (it dominates their training corpora), and glue is exactly the code no tool can verify without writing still more glue. It's cheap to generate but expensive to trust. In Jac, entire categories of glue are eliminated, and one compiler checks everything: a whole full-stack app fits in one file that fits in a context window, and a cross-tier mistake an agent makes is a compile error instead of a production surprise.

As discussed in the ninja book, the key insight is that when authorship is abundant, the scarce resource is jurisdiction: the reach of the verifiers that can examine a change and say no, and Jac is built to leave no program point outside it. Even sem annotations do triple duty: prompt material for by llm(), documentation for humans, context for your agent.

여기까지가 README 앞부분입니다. 나머지는 원문에서 읽을 수 있습니다. README 전문 보기 ↗