x07lang.org

Choose a path

Start from the entrypoint that matches the job

The website serves two audiences on purpose: humans need a clear overview, and agents need stable machine-readable contracts.

For humans

Start with the docs and ecosystem overview

Use this path if you are opening X07 for the first time and want a clear explanation of the execution model, the toolchain, and where MCP, the wasm target, packages, and certification fit.

Read docs

For builders

Build or verify MCP servers

Use x07-mcp to author servers in X07 and Hardproof to verify any MCP server with deterministic reports, CI gates, and review artifacts.

Open MCP lane

For agents

Consume stable machine entrypoints

Use the agent portal for versioned schemas, skills, stdlib indexes, package indexes, examples, and release manifests. The HTML pages are discoverability only.

Open agent portal

Why X07 is opinionated

Less guesswork in the language. Less guesswork in the repair loop.

The first example is about API ambiguity. The second is about what happens when the first attempt is wrong and you need a repair loop a human reviewer can follow.

Reversing bytes should be boring

Python exposes several valid-looking ways to read stdin and manipulate bytes. X07 exposes one canonical bytes helper.

PythonSeveral plausible wrong turns

# Wrong turn 1 — text instead of bytes
import sys
data = sys.stdin.read()

# Wrong turn 2 — .reverse() does not exist on str
result = data.reverse()
# → AttributeError: 'str' has no attribute 'reverse'

# Wrong turn 3 — reversed(data) is an iterator
data = sys.stdin.buffer.read()
sys.stdout.buffer.write(reversed(data))
# → TypeError: a bytes-like object is required, not 'reversed'

X07One canonical bytes operation

; x07text: the lossless, human-readable
; projection of canonical x07AST.
{
  :kind entry
  :module_id main
  :schema_version x07.x07ast@0.8.0
  :imports (std.bytes)             ; the bytes module
  :decls ()
  :solve (std.bytes.reverse input) ; the one reverse helper
}

The X07 side is the shipped 03_reverse example, shown in x07text (round-trips to canonical x07AST JSON via x07 ast from-text). The point is not that Python cannot reverse bytes, but that X07 leaves the agent with far less API guesswork.

When the first attempt is wrong, the repair surface matters

Python gives the agent a human traceback. X07 gives it stable JSON diagnostics and deterministic repair commands.

PythonHuman traceback

Traceback (most recent call last):
  File "reverse.py", line 6, in <module>
    sys.stdout.buffer.write(reversed(data))
TypeError: a bytes-like object is required, not 'reversed'

X07Machine-readable repair loop

x07 lint --input src/main.x07.json
# -> emits x07diag JSON with:
#    stable code
#    x07AST pointer
#    optional quickfix as JSON Patch

x07 fix --input src/main.x07.json --write
# -> applies the quickfix deterministically

The X07 docs define diagnostics as machine-readable, error codes as stable, and quickfixes as deterministic JSON Patch operations.

Direct authoring

Authoring X07 directly is a bet we test, not assume

Agents and humans can write X07 directly, and the toolchain now backs that path with a text projection, behavioral docs, and suggestion-bearing diagnostics.

x07text

Lossless text projection

x07 ast to-text and x07 ast from-text round-trip between canonical x07AST JSON and a readable, writable text form, so agents and humans can author X07 directly without losing structure.

x07 doc

Behavioral API summaries

x07 doc describes what stdlib and package functions do — inputs, outputs, and effects — so authors guess less before the first compile.

Diagnostics

Did-you-mean suggestions

Near-miss identifiers come back as structured diagnostics with concrete suggestions, which keeps the first repair iteration short.

Direct authoring is an explicitly gated bet, not a settled conclusion. A comparative agent eval in the x07 repo (labs/agent-eval) decides how much deeper the language investment goes. The results will be published either way.

Ecosystem

A deliberately small active surface

The 2026-06 scope cut focused the project on five active repos: x07, x07-mcp, x07-registry, x07-wasm-backend, and Hardproof. Earlier experiments — studio, forge, crewops, tactics, device host, web UI, the sentinel reference stack, and the app platform — are archived.

Core docs

Understand the language, worlds, toolchain, and ecosystem

Start at the docs if you are evaluating X07, installing the toolchain, or trying to understand how the pieces fit together before you build anything.

Read the docs

MCP

Author servers in X07 or connect agents through the official bridge

Use x07-mcp to build MCP servers in X07, run demos, or connect agent runtimes to the official x07lang-mcp bridge for typed access to X07 tooling.

Open MCP docs

WASM

Compile the same programs to a wasm target

x07-wasm-backend compiles X07 programs to WebAssembly for environments where a native binary is not an option, with the same determinism and test story.

Open WASM docs

Hardproof

Verify MCP servers with evidence you can keep in CI and review

Hardproof is the verification lane: deterministic scans, explicit score truth, replay artifacts, trust checks, and usage metrics for MCP servers.

Open Hardproof

Registry

Install and publish packages through x07.io

Pinned dependencies, machine-readable metadata, and versioned schemas stay aligned with the toolchain so humans and agents do not guess at compatibility.

Open x07.io

Deterministic execution

Programs run in solve worlds with record/replay, so the same input produces the same output, the same diagnostics, and a rerunnable trace.

Budgeted and capability-sandboxed

Explicit budgets bound how long code runs and what it allocates; capability sandboxes decide what it can touch. Agent-written code runs inside limits you set, not limits it picks.

Certifiable, not just plausible

Spec-first XTAL tests, structured diagnostics with quickfixes, and proof-backed certification produce evidence a reviewer can check instead of take on faith.