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 the clearest explanation of the language, the toolchain, and where MCP, WASM, packages, and platform 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

{
  "schema_version": "x07.x07ast@0.4.0", // Canonical x07AST schema.
  "kind": "entry",
  "module_id": "main",
  "imports": ["std.bytes"],             // Import the bytes module.
  "decls": [],
  "solve": ["std.bytes.reverse", "input"] // Call the one reverse helper.
}

The X07 side is the shipped 03_reverse example. 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.

Ecosystem

One language, one story across the stack

Start with the core toolchain, then move into the official surfaces that ship real software.

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

Ship to browser, server, and device from one codebase

Compile to WebAssembly for browser UIs, backend services, or packaged desktop and mobile apps — with one build system and one test story.

Open WASM docs

Platform

Automate the full lifecycle: deploy, monitor, repair

One operational model for rollout control, incident tracking, regression testing, and device release supervision — built for agents and operators alike.

Open platform 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

Humans and agents read the same contracts

Docs, schemas, CLI reports, and package metadata line up, so the same contract survives from code review to CI to release operations.

Canonical APIs cut down repair noise

X07 tries to make each capability look like one obvious shape, which keeps generated code and repair patches more uniform and reviewable.

Deterministic loops are easier to trust

Lint, fix, test, run, MCP, packaging, and verification surfaces speak stable JSON and versioned schemas instead of ad hoc terminal output.