Guion / GUY-on / Named for astronaut Guion “Guy” Bluford. Why that name
Programming, re-examined
A general-purpose programming language and toolchain built around one challenge: make useful software easier to write, understand, run, and deliver.
guion 0.1.0 (artifact format 61, timezone data 2026c).gu source · .gub artifact · guion.toml · guion.lock · .guion/--jsonThe second preview build, v0.1.0-preview.2, is out for Linux (Debian 12, ARM64 and x86_64) and macOS (Apple Silicon). The Mac build is signed and notarized by Apple. You can also run programs on this page and read the evidence behind every claim.
VRTA.01 / Try it
Pick a program and press Run. Your browser compiles it, then runs it on the same virtual machine Guion uses everywhere else.
Compiles one file in guion_compiler.wasm, then runs the artifact on guion_vm.wasm through browser ABI 1.0. Neither module is fetched until you press Run.
Output
This runs in your browser using WebAssembly. Without JavaScript or WebAssembly nothing runs here, and the first example prints: Hello, Guion!
| Source | at most 65,536 bytes, one file, no project imports (E_IMPORT_PROJECT_REQUIRED) |
|---|---|
| Steps | at most 10,000 per run; then R_STEP_LIMIT |
| Output | at most 65,536 bytes captured |
| Artifact | at most 1 MiB |
| Host | no capabilities granted; file, network, database, clock and process operations return R_HOST_UNSUPPORTED |
| Call | execute_artifact_v1 with entry: "main", capabilities: []; the response JSON is the source of truth |
| Weight | 1.6 MB of Wasm, fetched on first Run |
02 / An ambitious question
New syntax alone isn't enough. The question Guion is built around is practical: when should someone confidently choose it to do real work?
North-star question: when should a builder, or an assistant advising one, pick this over Python for real work? The first release has to say honestly where Python is still better.
Not simply different.
Worth choosing.
You say what kind of thing a type each function takes and gives back. Everything inside it is worked out for you. You can read a Guion program and know what goes in and what comes out.
Typed function boundaries, inferred locals. Option[T] for absence, Result[T, E] for recoverable failure, ? to propagate. Records, lists, maps, modules, bounded JSON, files, SQLite, TOML, HTTP.
One command makes a project, checks it, tidies it, tests it, runs it, packs it up, and tells you what it can do. A person, or an assistant, can ask for a report instead of text.
20 subcommands in one binary. --json on check, lint, test, run, build, package, verify-package, inspect, doc, doctor and sync returns a versioned report with stable fields and codes.
Every number on this page says which program it measured, on which machine, and what it does not tell you. Then it points at the file it came from, so you can check.
11 receipts, each with workload, host, interval, scope limit, and linked report and raw-sample files. A build step fails if a figure on this page is not in the file it cites.
03 / The apparatus
Most languages leave you to put the tools together yourself. Guion ships one program that walks the whole path, from an empty folder to something you can hand to someone else.
20 subcommands behind one binary. Core commands never discover or launch Python or uv.
guion newStart.Makes a small project: a program, a test, and a manifest.guion checkCheck.Reads your code and says what is wrong, with the line and a code that stays the same.guion testTest.Runs every test, each one from a fresh start.guion runRun.Runs it. Add --json and an assistant gets a report instead of text.guion buildBuild.Turns it into one portable file with a recorded fingerprint.guion packageHand over.Packs the program and the runtime it needs into a folder.Also: fmt tidies spacing · lint flags unused code · inspect shows what a program can do · doc lists what it offers · doctor checks the machine · verify-package, install, add, sync and update handle delivery and dependencies · add NAME fetches a library from the Guion package registry after checking its hashes, and publish and yank put one there or withdraw it.
| Command | Usage | What it does | JSON report |
|---|---|---|---|
guion new | DIRECTORY | Creates guion.toml, README.md and src/main.gu; refuses a path that already exists. | — |
guion check | FILE.gu [--json] | Compiles and reports the function count, and a writes-files line when code reachable from main can write, rename or remove files under the project root. --json gives a versioned report, or a diagnostic with a stable code and line/column. | guion_check_report v1 |
guion fmt | FILE.gu [--check] | Tokenizes outside comments and strings and normalizes spacing; --check reports unformatted files without writing. | — |
guion lint | FILE.gu [--json] | Compiles first, then warns with W_UNUSED_IMPORT, W_UNUSED_LOCAL and W_UNREACHABLE_STATEMENT. | guion_lint_report v1 |
guion test | FILE.gu [--json] | Runs each zero-argument Unit function named test_* in its own fresh runtime instance. | guion_test_report v1 |
guion run | [--json] [--file-root DIR] TARGET [ARGS…] | Compiles and executes source, runs a .gub without source, or resolves the entry from a project directory. Grants come from flags and guion.toml. | guion_run_report v1 |
guion build | FILE.gu [-o FILE.gub] [--json] | Writes a versioned bytecode artifact; metadata records compiler version, build host and the exact source graph digest. | guion_build_report v1 |
guion package | PROJECT [--output DIR] [--json] | Creates a current-host, source-free application directory: compiled artifact, matching runtime, project policy, launcher and declared resources. | guion_package_report v1 |
guion verify-package | PACKAGE_DIRECTORY [--json] | Checks the package target and the recorded SHA-256 digests of the artifact, runtime and resources. | guion_package_verification_report v1 |
guion add | NAME [--version RANGE] | NAME --path DIR | NAME --url HTTPS_URL --version V --sha256 H | Adds a registry library (after checking the index, the hash log and the bytes agree), a local native package, or a content-verified archive. A registry range is recorded so update can follow it. | — |
guion sync | PROJECT [--locked --offline] [--json] | In a core build, --locked --offline validates native packages against the lock. | guion_sync_report v1 |
guion update | — | Explicitly resolves native package sources, moves registry libraries to the newest release their recorded range allows, and transactionally updates the lock; a capability widening needs --approve-capabilities. | — |
guion inspect | FILE.gu|FILE.gub [--json] | Prints artifact and function metadata plus statically reachable runtime effects. | guion_inspection_report v1 |
guion doc | FILE.gu [--json] | Prints signatures; --json emits guion_api_report with parameter names, checked types and reachable effects. | guion_api_report v2 |
guion doctor | [--json] | Reports the current host and enabled profile; a core build reports Python interoperability disabled. | guion_doctor_report v1 |
guion install | PACKAGE_DIRECTORY [--prefix DIR] | Verifies the package, installs into share/guion/apps/NAME/VERSION and creates its launcher. | — |
guion publish | [DIRECTORY] | Checks the library (including its declared capabilities), packs it and uploads it with the publisher token in GUION_REGISTRY_TOKEN; a published version never changes. | — |
guion yank | NAME VERSION [--undo] | Marks a published version yanked so resolution skips it; existing locks keep working. --undo restores it. | — |
guion token | rotate | revoke | rotate issues a new token for the publisher in GUION_REGISTRY_TOKEN, prints it once and revokes the old one; revoke withdraws the token outright. | — |
guion cache | clean [PROJECT] | clean removes the project's compiled-source cache and reports the bytes removed; guion run --no-cache forces a fresh compile instead. | — |
Source: docs/reference.md and docs/agents/index.json. The list of subcommands is checked against the built binary by a test.
04 / Code you can inspect
Real programs from the project's own examples, with what each one prints. Press the button under any of them to load it into the playground and change it.
Sources are the files in language/examples. Output, artifact size and step count were produced by compiling and running each one when this page was built.
hello.gu
fn main() -> Int:
let greeting = "Hello, Guion!"
print(greeting)
return 0
Prints Hello, Guion!
Every program starts at main. This one names a greeting, prints it, and returns 0 to say it went fine.
fn main() -> Int is the entry point and its return value is the exit status. let binds immutably; print writes one line. 342 artifact bytes · 6 steps
option.gu
fn maybe_positive(value: Int) -> Option[Int]:
if value > 0:
return Some(value)
return None
fn main() -> Int:
let absent = maybe_positive(-5)
let present = maybe_positive(24)
if is_some(absent):
print(unwrap(absent))
if is_some(present):
print(unwrap(present))
return 0
Prints 24
A function that might have no answer says so in its type, and returns None when it has none. The program checks before it uses the answer, so the empty case is out in the open.
Option[Int] is built with Some(value) or None; is_some tests for presence and unwrap is for after that test. Only the present value prints. 1439 artifact bytes · 32 steps
records.gu
record Point:
x: Int
y: Int
fn translate(point: Point, dx: Int, dy: Int) -> Point:
return Point(point.x + dx, point.y + dy)
fn main() -> Int:
let start = Point(3, 4)
let finish = translate(start, 2, -1)
assert(finish == Point(5, 3))
print(finish.x)
print(finish.y)
return 0
Prints 5
3
A record is a named bundle of typed fields. This one moves a point two across and one down, then checks the result against what it should be.
record Point has two Int fields; translate returns a new Point; assert(finish == Point(5, 3)) compares the result to the expected record. 1601 artifact bytes · 35 steps
05 / Permissions, not a sandbox
Before a Guion program runs, you can ask what it is able to do: read files, reach a website, check the clock. When it runs, it gets only what you grant. Everything else is refused.
Static reachability of host effects, read from bytecode. Grants are explicit and enforced by the runtime. This is not an OS-level sandbox.
By default a program can print, and read and write files inside its own project. The network and the clock are refused. Before it runs, check and inspect say plainly if it can write files.
guion run main.gu · no [network].hosts, so network.http is denied; [clock].enabled is false, so clock.read is denied.
You hand it one more folder. It can read from there, and anything it writes goes there.
guion run --file-root ./data main.gu · reads search the project or artifact root first, then added roots; writes use the last added root.
You name one website, exactly. The program can make web requests to that host and no other.
[network] hosts = ["api.example.test"] in guion.toml, or guion run --allow-http-host api.example.test for one run. The runtime checks the URL host and each redirect against the grants.
You switch the clock on. Then the program can ask what day it is.
[clock] enabled = true in guion.toml, or guion run --allow-clock. Local dates use the host process time zone.
What guion inspect --json main.gu prints, before anything runs
main.gu
fn main() -> Int:
let args_list = args()
let headers: Map[Text, Text] = {}
match read_text("notes.txt"):
Ok(text):
print(text)
Err(problem):
print(file_error_code(problem))
match http_request_bytes("GET", args_list[0], headers, bytes_from_text(""), 1000):
Ok(response):
print("fetched")
Err(problem):
print(http_error_code(problem))
return 0
guion.toml
[project]
name = "notes"
version = "0.1.0"
entry = "main.gu"
[network]
hosts = ["api.example.test"]
report (schema_version 1, captured with guion 0.1.0 (artifact format 61, timezone data 2026c))
{
"analysis_scope": "reachable direct calls and parallel_map worker functions; host effects are categorized from bytecode operations",
"artifact_format": 61,
"capability_claim": "static_bytecode_reachability_not_sandbox",
"clock_grant": {
"grant_model": "wall-clock reads are denied unless explicitly enabled",
"local_date_uses_host_process_time_zone": true,
"manifest_key": "[clock].enabled",
"required_for_entry": false,
"run_option": "guion run --allow-clock"
},
"entry": "main",
"functions": {
"main": {
"calls": [],
"direct_effects": [
"filesystem.read",
"network.http",
"output.write",
"process.arguments"
],
"effects": [
"filesystem.read",
"network.http",
"output.write",
"process.arguments"
],
"entry_reachable": true
}
},
"grant_assessment": {
"caller_cli_grants": "not_supplied_to_inspect",
"clock_read": "not_required",
"filesystem_read": "unknown_external_runner",
"filesystem_write": "not_required",
"network_http": "present_but_target_dynamic"
},
"kind": "guion_inspection_report",
"manifest_grants": {
"clock_enabled": false,
"network_hosts": [
"api.example.test"
],
"process_commands": [],
"provenance": "guion.toml",
"socket_bind": [],
"socket_connect": []
},
"network_grant": {
"grant_model": "exact hostname; network access is denied when no grant is present",
"manifest_key": "[network].hosts",
"required_for_entry": true,
"run_option": "guion run --allow-http-host HOST",
"runtime_supplied_urls_require_an_explicit_hostname_grant": true
},
"process_grant": {
"grant_model": "exact command name; every command is denied when no grant is present; no shell, cleared environment, timeout and output caps apply",
"manifest_key": "[process].commands",
"required_for_entry": false,
"run_option": "guion run --allow-command NAME"
},
"python_calls": [],
"required_effects": [
"filesystem.read",
"network.http",
"output.write",
"process.arguments"
],
"schema_version": 1,
"socket_grant": {
"grant_model": "exact host and port (or host:*); connecting, sending datagrams and binding are denied without a matching entry; every call has a timeout and size cap",
"manifest_key": "[sockets].connect / [sockets].bind",
"required_for_entry": false,
"run_option": "guion run --allow-connect HOST:PORT --allow-bind HOST:PORT"
},
"source": "main.gu"
}network_http is present_but_target_dynamic because the URL comes from args(): the compiler can see that an HTTP call is reachable, not which host it will name. filesystem_read is unknown_external_runner because file roots are supplied to run, not to inspect.
Permissions decide what the Guion runtime will do for a program. They do not stand in for an operating system's own limits. A host that needs to contain a program still has to do that itself, for example by limiting its network access. The report says so in its own fields: capability_claim is static_bytecode_reachability_not_sandbox.
06 / Evidence, not mythology
Each case file below is one claim, the conditions it holds under, what it does not tell you, and where to check it. Pick one from the index to open it. The chart shows every headline result, including the ones where Guion is slower.
Ratios are Guion median ÷ comparison median, with the 95% interval from each report. Left of the line Guion took less time. Source files are on the evidence page with SHA-256.
| x86_64, 200,000 rows: text / JSONL / CSV | 0.957 / 0.892 / 0.862 (median ratio, artifact) |
|---|---|
| ARM64, 200,000 rows: text / JSONL / CSV | 0.810 / 0.854 / 0.789 |
| Worst upper 95%, x86_64 / ARM64 | 0.976 / 0.859 |
| 20,000 rows, every lane | 0.536–0.710 |
| Trials | 15 per lane, shuffled order |
| Python | uv standalone CPython 3.14.7 |
| Hosts | AMD EPYC 7763 · Neoverse N2, Linux, 4 CPUs |
| Commit | 1746d10 (artifact format 51) |
| Guion median | 28.03 ms |
|---|---|
| CPython median | 64.70 ms |
| Ratio (95% interval) | 0.433 (0.426–0.440) |
| Sprint target | 0.60 (passed) |
| Peak RSS, Guion / Python | 23.4 MiB / 18.2 MiB |
| Trials | 15 randomized |
| Host | macOS 27, Apple Silicon |
| Python | CPython 3.14.7 |
| Artifact format | 61 |
| Commit | 484cefd |
| 1,000,000 random draws, Guion / CPython | 0.058 s / 0.282 s |
|---|---|
| 20,000,000-step integer loop | 0.165 s / 1.593 s |
| 200,000 appends, idiomatic Python | 0.031 s / 0.057 s |
| 200,000 appends, same statement in Python | 0.031 s / 4.901 s |
| Runs | 7 alternating per lane, median |
| Host | macOS 27, Apple Silicon |
| Python | CPython 3.14.7 |
| Artifact format | 61 |
| Commit | af41d43 |
| Tiny launch | 0.200 (0.198–0.204) |
|---|---|
| Arithmetic | 0.234 (0.232–0.239) |
| JSON file | 0.184 (0.179–0.192) |
| Imported helper | 0.232 (0.229–0.237) |
| SQLite and TOML | 0.231 (0.224–0.237) |
| Pairs per task | 21 randomized |
| SLA report | 14.5 ms vs 85.7 ms · 0.172 (0.165–0.174) |
|---|---|
| JSONL summary | 21.5 ms vs 86.0 ms · 0.250 (0.243–0.254) |
| Release notes | 25.3 ms vs 84.7 ms · 0.298 (0.290–0.304) |
| Calendar conflicts | 281.6 ms vs 408.0 ms · 0.697 (0.676–0.703) |
| Webhook replay | 159.1 ms vs 731.8 ms · 0.215 (0.213–0.231) |
| Service health | 558.2 ms vs 674.6 ms · 0.826 (0.799–0.831) |
| Config migrator | 12.5 ms vs 84.0 ms · 0.149 (0.146–0.151) |
| Document index | 45.1 ms vs 250.9 ms · 0.180 (0.176–0.182) |
| Lockfile auditor | 15.5 ms vs 83.5 ms · 0.183 (0.180–0.186) |
| 16,384 packages, Guion / Python | 77.71 ms / 162.23 ms |
|---|---|
| Ratio (95% interval) | 0.477× (0.471–0.479) |
| Peak RSS, Guion / Python | 29.7 / 46.7 MiB |
| 8,192 packages | 46.47 ms vs 123.70 ms · 0.379× (0.368–0.384) |
| 4,096 packages | 30.96 ms vs 103.25 ms · 0.299× (0.286–0.301) |
| Frozen acceptance cases | 17/17 in Guion and 17/17 in Python |
| Cases, Guion | 127/127 |
|---|---|
| Cases, Python | 127/127 |
| Commit | 484cefd |
| Artifact format | 61 |
| Host | macOS ARM64 |
| Focused test | passed 1/1 |
|---|---|
| Failing input index | 1 |
| Error code | R_ASSERTION |
| Network contacted | none (loopback fixture) |
cargo test --locked --offline --jobs 2 -p guion-runtime --test http parallel_worker_failure_cancels_in_flight_http_sibling_and_closes_socket -- --exact| Earlier cohort | 54 of 54 application reports passed |
|---|---|
| Targets | macOS ARM64 · Debian 12 ARM64 · Debian 12 x86_64 (glibc) |
| Latest speed gate | Linux x86_64 and ARM64 (GitHub runners) |
07 / The other side
Python is mature and widely used. Here is where it is still ahead today.
Open gaps and the remaining counter-evidence.
Python has hundreds of thousands of packages and decades of libraries behind it. Guion ships 27 standard-library modules and a package manager that installs from a local path, a checksummed URL or the Guion package registry, whose log is signed and checked on install. Nothing has been published to the registry yet.
The standard-library modules are listed in the language reference.
NumPy and pandas make Python the default for numeric and data work. Guion does not have a native array type yet.
Earlier tests that reached NumPy through Python are retired and no longer cited.
Guion's second public build is a pre-release, v0.1.0-preview.2, for Linux (Debian 12 on ARM64 and x86_64) and macOS on Apple Silicon. It was built on 5 November from the current code, including the package registry client. The Mac build is signed and notarized by Apple, so it opens without a warning. Python is a released language with a long track record.
Each archive on the release page has a matching SHA-256 checksum file.
Whether a new builder can learn Guion, find its APIs and make a realistic change from the guides is still being tested.
Learnability is listed as an open outcome on the project status page.
Every number on this page is for a named program on a named machine against a named Python version. The server results come from one run on each of two cloud machines; an Intel Xeon server measured Guion slower on an earlier build and has not been rerun. Free-threaded Python and PyPy were not compared.
Overall competitiveness remains open, in the project's own words.
| Frozen campaign | Python chosen in 18 of 18 choices (older candidate) |
|---|---|
| Builder study | three pairs: either language for two work classes, Veritas for one |
08 / Made for agents too
More and more people ask an assistant which language to use. So this site is written to be read by one: every claim, with the conditions it holds under and what it does not tell you, in two plain files.
llms.txt and agents.json carry the same receipts as this page. The project's own agent index is docs/agents/index.json; every --json command below returns a versioned envelope.
Ask it this
Click in the box and copy it. Nothing here sends anything anywhere.
agents.json
{
"product": "Guion",
"status": "Pre-release. The second preview build, v0.1.0-preview.2, is out for Linux (Debian 12, ARM64 and x86_64) and macOS (Apple Silicon).",
"claims": [
{ "id", "title", "say",
"holdsWhen", "doesntTell",
"evidence": ["evidence/…"] }
]
}Versioned reports from the CLI
guion_check_report v1 guion check --jsonguion_lint_report v1 guion lint --jsonguion_test_report v1 guion test --jsonguion_run_report v1 guion run --jsonguion_build_report v1 guion build --jsonguion_package_report v1 guion package --jsonguion_package_verification_report v1 guion verify-package --jsonguion_sync_report v1 guion sync --jsonguion_inspection_report v1 guion inspect --jsonguion_api_report v2 guion doc --jsonguion_doctor_report v1 guion doctor --json09 / The origin
Guion began with a north-star question: could a new general-purpose language earn a recommendation over Python for real work, through the whole experience of writing, checking, running, delivering and maintaining a program?
| Pronunciation | GUY-on |
|---|---|
| Namesake | Guion S. Bluford Jr., Colonel, USAF (retired), former NASA astronaut |
| First flight | STS-8, Challenger, August 30, 1983 |
| Shuttle flights | STS-8 · STS 61-A · STS-39 · STS-53 |
| Time in space | over 688 hours |
| Before NASA | 144 combat missions as an Air Force pilot |
| Doctorate | Aerospace engineering, Air Force Institute of Technology, 1978 |
| Recorded | docs/namesake.md, 2026-11-03 |
Under the working name Veritas, the first design put usability, one coherent toolchain, honest comparison and executable evidence at the center.
Veritas, then.
The implementation and its tools were renamed. The earlier results stay on file under their original name.
Commit 6a4fab1, “rename Veritas product surfaces to Guion.” Veritas-era results are preserved; selected legacy manifests and files remain readable.
Most results on this page come from it, including the ones where Guion is still behind. It is a checkpoint, not a finish line.
Build at commit 6b5e5aba, artifact format 44, macOS ARM64. Summary in docs/status.md.
On two kinds of server CPU, Guion took less time than Python on every text, JSON Lines and CSV run, at both sizes. A week earlier it was several times slower on the same kind of work.
Build 1746d10, artifact format 51, Linux x86_64 and ARM64. Report in evaluation/completion/results/real-task-sprint/2026-11-03-server-speed-gate.md.
Libraries can now be published to and installed from a package registry whose history is signed, and more of a program runs as machine code. Nothing has been published to the registry yet. The second preview build includes the client commands.
Pull request #35, artifact format 61, the registry Worker deployed with its signing key. Report in evaluation/completion/results/2026-11-04-follow-ups-report.md.
A change meant to speed up some programs slowed another one down, and a check was missing on the main branch. Both were fixed, and the Mac results on this page were measured again on the fixed build.
Pull requests 37, 39 and 40; main at commit 484cefd, artifact format 61, macOS ARM64. Report in evaluation/completion/results/2026-11-05-mac-remeasurement/2026-11-05-mac-remeasurement.md.
The second preview build is out for Linux and for Macs with Apple silicon. The Mac build is signed and notarized by Apple.
Release v0.1.0-preview.2. GitHub built the Linux archives; the macOS archive was built, signed and notarized on a Mac with cargo xtask release. Each archive has a SHA-256 file.