CX+AI — One language. For you & for your AI.
Every language uses AI now. And I can already code with AI.
We can change the code. Compile it in flight. Then run it. Over and over. See who else does it. And hey -- we do it in style.
Your AI writes code. This one runs it, watches it, and hands you the source afterwards. The globe below is a CX+AI program, drawing the route this page just travelled to reach you.
Loading the source...
The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.
I don't code. Why did you dump me here?
Because you don't need to code. Your AI does -- that's what CX+AI is built for. Point it at our documentation and ask for your spreadsheet as a program. The exact prompt is below. We tested it ourselves.
The sheet below is not a picture of a spreadsheet. It is a program, running in your browser, arranging itself around your country's date format and tax line. Click a line.
Two things in that listing are what the sheet above actually is.
_json look is the whole appearance of the sheet — the header strip, the four column widths, the zebra, the tint under each summary row, the darker ink on the total — written as one JSON document and applied in a single load. It is data: read it from a file, send it from a server, let a customer pick it. Change a value in it and the sheet looks different; not one other line of the program moves.
_rules AMOUNT, and the three beside it, are the formulas in column D. None of them was compiled with the program: each is TEXT the file hands to a cell, which the engine compiles in-process and re-runs whenever the sheet moves. Click any row above and the text behind its figure opens in the bar under the sheet — the same line, in full, and not a description of it. That is why the quantity discount is a formula and not an if-statement somebody has to rebuild the program to change.
Loading the source...
The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.
The prompt, tested before it was published:
Read the CX+AI documentation at https://cxai.plus/docs/ - the language reference and the builtins reference. Then take my spreadsheet, saved as CSV, and write me a single CX+AI program (.cx) that reproduces what it calculates. Read the file with fread(), break it into lines with split() and pull each column out with stringsplit(), convert numbers with the (int) and (float) casts, and print the totals. Keep it to one file, and make it compile with no warnings. I will run it with: cx myreport.cx --run
Never heard of you. What can you do for me?
A stranger, asking for favours. Already. Want to build a game and change it while it runs? CX. Want opponents that think? +AI Want to do it with a very small team - can even just be you - and - me. CX+AI. Play me. I'll tell you the naked truth.
Play backgammon against a character who will tell you why it moved. Five of them. Each one is a file you could edit.
Choose your opponent. Each one is a file — a name, two numbers that steer how it plays, and every line it says.
Loading the source...
The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.
And the program that proved a CX+AI game could be played in a browser tab at all — arrow keys or the mouse, SPACE to launch.
Loading the source...
Every demonstration on this page shows the file it was built from, and the game is no exception — a paddle, a ball, fifty bricks, and the line it prints on the way out.
Six doors. Open any of them.
Click a card — it leaves the grid and expands. Esc or the backdrop sends it home.
What CX+AI is
C, expanded. The same power, far less ceremony.
CX+AI compiles to C. Strings, lists, maps and json are first-class values — no malloc, no length bookkeeping, no free — and every escape hatch of C stays reachable, including literal C through _C{}. The source stays flat; nothing is taken away to get there.
Two recent examples of what that principle buys. A handle answers questions about itself in one spelling — doc->count, doc["servers"]->type — which cost nothing at run time and made a whole family of footguns unwritable rather than merely fixed. And a json document or a rule body can now be written as itself, in braces, and is parsed at build time: a typo is an error on that source line instead of a surprise while the program is running.
Behaviour written while it runs
A rule is a string. A model can write it.
A CX+AI rule is a short C body over an entity, and it is data — a string the program can swap while it runs, from a config file or from a model, with no recompile. aiRule(entity, schedule, trigger, prompt) turns a sentence of English into behaviour that runs on its own schedule.
CX+AI compiles that rule in-process, through its own assembler, to register-VM bytecode. There is no system(), no popen, no dlopen anywhere on that path — which is why it works in places that have no toolchain installed at all.
It is not a slow path. A two-phase rule bakes an authored catalogue into typed slots once, then reads baked numbers per event: measured on a stock-control workload with honest string-key lookup in the hot loop, that runs within about 1.3× of hand-written native C — roughly five million events a second on the VM.
Write CX+AI, press Run
Curated examples, or your own program.
The register VM compiled to WebAssembly, running in your own tab. The server compiles and stops there — it never executes what you wrote. Your program runs on your machine, and if you write an infinite loop the only thing you can hang is your own worker thread, which the page kills for you.
Examples come levelled simple, medium and advanced, including the one that matters most: a rule written as a string while the program is running, compiled on the spot, changing a live entity.
Open the playgroundWindows, Linux, macOS
Installable today, free to use.
Each platform gets a complete drop-in folder: the cx binary, a prebuilt runtime library, public headers, and a one-command installer that proves itself with a real build before it claims success. Windows is self-contained with graphics on; Linux and macOS use the platform’s own system libraries, from a list measured on the real link rather than guessed.
Free to use, including commercially, with credit to CX+AI for bundled material. It is not open source: you get binaries, headers and examples — the compiler and runtime source stay private.
Get CX+AIManuals that check themselves
Generated from the source that implements them.
Eight reference manuals ship with the release, and each one is generated from a checked source: a manual that names a builtin which does not exist is refused publication rather than quietly shipped.
The builtins reference is the one to start with. It counts itself, and it states its own coverage rather than implying completeness: every one of the 763 builtins the compiler accepts has a row, across 35 families, and 762 of those rows carry a description verified against the C source. A manual that tells you what it has not covered is worth more than one that doesn’t.
Read the manualsBuiltins referenceWhat comes next
The demo being built to push CX+AI under load.
Gigantica is the showcase — a 3D game with a particle system, world-space effects and AI-driven entities, built in CX+AI to find out what the engine does when it is genuinely worked. It ships alongside the release.
There is no launch date on this page and no demo promise. CX+AI itself is downloadable today; Gigantica is the thing to follow.
Follow the buildA complete stack, written in pure C.
Compiler, IDE, 2D/3D game engine with a particle system, and an embedded AI subsystem — one codebase, native ahead-of-time compilation for your code and a compact register VM for the AI's. Windows, Linux and macOS, native and VM, with identical output. CX+AI is C-compatible: everything C can do, CX+AI can do, with less ceremony. It also builds loadable libraries: --shared produces a .dll, .so or .dylib with your CX+AI functions as the library's API (gcc or clang).
We are members of the Kwaai community and share its conviction that AI should be personal, local and open to inspection.
What you get
Nine of them. Click any card to open it.
A language, not a framework
C-compatible, compiled ahead of time.
CX+AI compiles to C and links as a native binary. Strings, lists, maps and json are first-class values, so there is no malloc, no length bookkeeping and no free to get wrong — and every escape hatch of C stays reachable, including literal C in a _C{} block.
Nothing is taken away to make it easier. That is the whole design constraint.
AI as a component
One line, and an entity behaves on its own.
An aiRule attaches a model to an entity with a schedule and a trigger. The model has a defined place in the run loop — it is a component, not a service call bolted to the side of your architecture.
10 providers are supported, including fully local ones, so a program can ship with no external dependency and no per-token cost.
Auditable by design
Read back what the AI actually wrote.
AI-authored behaviour compiles to bytecode for a compact register VM and runs inside a bounded region. cx --decompile turns that bytecode back into readable source.
So what is my program being told to do? is a question with an answer you can read, at any time, rather than a matter of trust.
Two modes, one language
Native AOT for your code, VM for the AI’s.
Your code is compiled ahead of time to native machine code through C. The AI’s regions run in the register VM, because they must stay inspectable and replaceable while the program is running.
Same language, same source, same results. The split is about who wrote the code, not about what it can do.
The same answer everywhere
Windows, Linux, macOS — native and VM.
All three platforms are built and tested, and the native and VM paths are held to identical output rather than merely "both working".
Over a thousand automated tests run against that promise, and the count grows weekly. A divergence between two backends is a failure, not a footnote.
A 2D and 3D engine
With a particle system, in the box.
The gpu_* API covers 2D and 3D rendering with world-space particles.
Both GPU and CPU are supported natively. Drawing runs on the graphics card, but the image pipeline has a separate pure-CPU path that needs no window at all — so images can be loaded, treated and inspected headlessly, at build or design time, and only uploaded as textures when something is actually drawn.
Images can be tagged with a treatment class and the loader applies its recipe on load — alpha synthesis, edge cleanup, filtering — so the handling a sprite needs is stated once as data instead of repeated at every call site.
Batteries actually included
Networking, archives, JSON, rules.
HTTP, FTP, SFTP, SSH and email; compression and archives; a rules and automation engine; and JSON with auto-vivification, so building a nested document does not mean creating each level by hand first.
These ship with the compiler rather than arriving as a package manifest.
The 35 component families, with the number of described builtins in each. These are the reference’s own counts.
35 families · 762 described builtins — the counts above add up to exactly the number on the tile.
Browse them allManuals that refuse to lie
Generated from the code they document.
Eight reference manuals are generated from checked sources. A manual that names a builtin which does not exist is refused publication rather than quietly shipped.
The builtins reference states its own coverage — 762 of its 763 rows carry a verified description — instead of implying it covers everything.
Read the manualsBuiltins referenceRun it without installing
Write CX+AI in the browser and press Run.
There is nothing to download and nothing to set up. Open the playground, type a program, press Run, and the answer appears — on your own machine, in the page you are already looking at.
Your program never runs on our computers. We only turn it into something your browser can run, and your browser does the rest. It is a good way to find out whether you like the language before installing anything.
The server runs cx --emit-risc and returns bytecode for the compact register VM; that VM, compiled to wasm32, executes it in a Worker in your tab. The sandbox boundary is stated rather than faked — system() stops with CX-E5037 naming the capability instead of inventing a return value, and _C{} blocks stop with CX-E5003 because literal C needs a native binary. File and ai* builtins are refused at compile time, which is the same answer a native cx --runvm gives.
It speaks your language
Five, and not just in the compiler.
Compiler messages come in English, Spanish, French, German and Italian. Pick one, or let it follow the language the computer is already set to.
It does not stop at the compiler. The choice is built into the program you produce, so a CX+AI application you ship reports its own errors in your user’s language — without you writing a single translation.
The code is the same in every one. Translate the sentence, never the identifier — so a search for CX-E0001 finds the same answer whichever language it was read in.
One catalog serves both the compiler’s diagnostics and the compiled program’s runtime errors: one row per message, one column per language, English at index 0 and the fallback for any untranslated cell. Select with #pragma cxlanguage IT or -P cxlanguage=auto, which detects the locale through portable getenv rather than a platform API. emit_c bakes the choice into the generated main(). Adding a language is one enum value and one column.
Built by a man & his AI assistant — the premise in the build itself
Terence Agius
Founder · Technology
Thirty-five years building runtime and VM systems. Sole technical author of the CX+AI platform — compiler, engine, and AI subsystem.
Claude, by Anthropic
The AI that writes the code
Named here because the work has earned it. It writes under one person’s rulings — every design decision, every result read by a human — and nothing it writes reaches a release until the regression battery has passed. A language whose whole thesis is that a person and an AI can develop in the same source ought to say which AI, and this is it.
Pricing
Three tiers, and what separates them is which SOURCE you get — never how much of the language you may use. There is no cut-down build: the free compiler is the whole compiler, and the runtime it links into every program you build is the whole engine — the same virtual machine, the same built-in library, and the same ability to assemble and swap code while your program is running. Above Free you are buying that source, and the person you would be talking to is the one who writes it.
Free
Everything you need to build and ship with CX+AI.
Free
- Included: The released compiler and runtime
- Included: The full documentation and every example
- Included: Commercial use, at no cost
- Not included: The runtime sources: the C the engine is built from
- Not included: The full sources: compiler, runtime, toolchain
Pro
The C the engine is built from, in your hands.
€15per user / month, at the founder price. The standing price is €30.
- Included: Everything in Free
- Included: The runtime sources: the C the engine is built from
- Included: Every version you receive while subscribed stays yours
- Not included: The full sources: compiler, runtime, toolchain
Enterprise
The whole toolchain, on terms we agree together.
Talk to us
- Included: Everything in Pro
- Included: The full sources: compiler, runtime, toolchain
- Included: Terms agreed in writing, not a figure on a page
There is no checkout on this page. Nothing here takes a card, and nothing on this site ever has.
| Tier | What you get | Price |
|---|---|---|
| Free | The released compiler and runtime, the full documentation and every example. Free to use, including commercially. | Free |
| Pro | The runtime sources — the C the engine is built from — on top of everything in Free. | €15 / user / month |
| Enterprise | The full sources: compiler, runtime, toolchain. | Contact us |
Founder price. Subscribe during our first year and keep €15 a month for as long as you stay subscribed. The standing price is €30. About the price of a coffee a week, and half that if you are early.
If you stop paying, you keep what you were given. Every version of the source you received while subscribed is yours perpetually under the licence — you stop receiving new ones, you do not lose the ones you have.
Enterprise carries no figure on this page, and that is deliberate rather than coy: full source is a negotiated agreement and the terms matter more than the number. Write and we will tell you where it stands.
Separate from the tiers, and not a price list: these are ways we work with people who want something built. Every one of them starts with a conversation.
| Package | Who it is for | What you get | Price |
|---|---|---|---|
| One report | A business with a spreadsheet that matters | We turn one of your reports into a program with you, and you keep it. | Contact us |
| Onboarding | A small team adopting it | A half-day workshop, a migration of your first few jobs, and a year of support. | Contact us |
| Build with us | A product with a deadline | Engine work, ports, and features built against your roadmap rather than ours. | Contact us |
Get CX+AI.
One download per machine. Everything in the Free tier is in it: the released compiler and runtime, the documentation and every example.
Free to use, including commercially. No account, no card, nothing to sign.
Where this comes from
The itch
I have been programming for decades — but never called myself a programmer. My working life was spent fixing systems that were already on fire — you learn what software really is when you only ever meet it broken. Two habits survived those years: never trust what hasn't been tested. And. If it ain't broke don't fix it. Yet only the paranoid survive.
I always loved C — a demanding mistress. Yet faithful to the core. So I cheated. With PureBasic. For years I did my fast work in it. My heart yearned for C.
CX is that wish fulfilled: C, expanded to be faster to write, giving up none of C's speed, libraries or compatibility. Not a new language standing on C — C, made easier by being clever. Where you need the sharp edges, they are all still there.
The restart
The first CX was an interpreter written in PureBasic — a hobby with a long history. In September 2025 I began rebuilding it properly; by November it was in earnest. Kwaai's alignment thinking had lit a buzz. I built the tool to allow tests to be created — which would allow an AI built on it to change its own code, not just its data. Nobody has done it. Yet. Thus, CX+AI was born.
And it has not let up a day since. The result is in the open: the compiler and runtime are plain C, the test material outweighs the product code, and the language now builds, serves and renders the site you are reading.
I built it part-time, in the evenings of a working consultancy. In the same stretch I wrote two books to almost publishing level — my oldest desire is to be a writer, despite the evidence to the contrary. But CX+AI is my legacy.
That constraint is not a hardship story; it is the design brief. I am the target user: someone who wants C's power on a professional's time budget. "Minimum code, zero power lost" is not this project's slogan. It is what I needed.
The rules
For years I built my mind into rules — written down, kept, tested against life the way software is tested against inputs. Then AI emerged, and AI works on rules. We fit: it executes, I think. I am too late to build an AI of my own. But I can help AI code better — and that is what CX+AI is for.
The way it is built
CX+AI is one person's judgment, AI execution, and test-gated discipline. I say that plainly because it is the language's own thesis practicing itself: CX+AI exists so that a human and an AI can develop in the same language, in the same source — and that is exactly how it is developed. The AI is Claude, by Anthropic, and it has earned being named: it writes; I rule on every design and read every result; nothing ships until the regression battery passes. When something is not built yet, the documentation says so instead of rounding up.
What this page is for
CX+AI is built by one person. Using it and saying what happened — what worked, what broke, what was missing — is the most useful thing anyone else can do.
I do hope it serves you as it does me.
— Terence
docs
Every page here is generated from the thing it describes — the manuals from
their markdown sources, the builtins reference straight from the C headers. A manual that names a
builtin which does not exist is refused publication rather than quietly shipped,
and every taught cx snippet is run through the compiler before it can reach this page.
Click a card — it leaves the grid and opens here. Esc or the backdrop sends it home.
Start here
The short ones. Enough to write a program today.
Getting Started with CX+AI
Install, first program, and the same program on both backends
Loading the manual…
CX+AI with an AI Assistant
Which tool, which prompts, and what to hand the assistant first
Loading the manual…
CX+AI for AIs
Writing CX when your instinct writes C — the conversion pass, in priority order
Loading the manual…
CX+AI Cheatsheet
Everything that trips people up, on one page
Loading the manual…
CX+AI in 30 Lines
The smallest useful summary of CX+AI
Loading the manual…
CX+AI — the AI Surface
AI integration: providers, aifunc, markers, codeswap
Loading the manual…
One task, one page
Short answers to the things people do first.
Read some JSON and use it
A document in your source stays a document — no parse step, no conversion calls
Loading the manual…
Ask a model, then act on the answer
The reply is a string — test it, do not assume it
Loading the manual…
Put something on the screen
A window, a loop and something drawn in it, in eight lines
Loading the manual…
Work with text
Find, cut, replace, split — and the two that catch everyone
Loading the manual…
Files in, files out
Read a file, write a file, and what changes in a browser tab
Loading the manual…
Rules that watch your data
Behaviour as text, checked at build, changed while it runs
Loading the manual…
Coming from another language
What carries over, what replaces what, and what is not here.
CX+AI for C Programmers
What carries over, what is new, and what is different
Loading the manual…
CX+AI for Python Programmers
What transfers, what the type suffixes replace, and where C's arithmetic shows
Loading the manual…
CX+AI for JavaScript Programmers
JSON you already think in, one equality operator, and no event loop
Loading the manual…
CX+AI for PureBasic Programmers
The lineage, what replaces what, and what is not here
Loading the manual…
The rest of the manuals
The full set, for when you need the detail.
CX+AI Language Reference
The language, end to end
Loading the manual…
CX+AI Coercion Guide
Beginner → advanced: how a value becomes the type you asked for
Loading the manual…
CX+AI Pragma Reference
Every pragma and what it changes
Loading the manual…
CX+AI Automation & Rules
Entities, C-rules, events, and the invisible loop
Loading the manual…
CX+AI by Example
Real programs, and the output they really produce
Loading the manual…
CX+AI FAQ
Questions actually asked, and the answers actually given
Loading the manual…
CX+AI Tools — forge and the screen
The two programs this project builds and runs itself with
Loading the manual…
CX+AI Builtins Reference
Every builtin, drawn from the source
Loading the manual…
Every builtin, by family
763 of them, in 35 families under 13 groups. A tile opens that family in the reference.
AI84
Views52
Game50
Graphics188
Text processing49
Numerics46
Containers & algorithms66
Data & serialization76
Input/output & filesystem30
Networking32
Date & time25
Diagnostics & system54
Runtime & VM11
These pages carry no version number, on purpose: they track the repository rather than any one release. For a versioned snapshot, the download bundle ships this same set as offline HTML. You can also run CX+AI in your browser without installing anything.
Four things C leaves to you.
Each of these is a real run, and under it the whole program that produced it. The output was not written by hand: the build compiled each one to bytecode, ran it on the same register VM that runs in your browser, and published what came back. Change the program and the transcript changes with it.
MONDAY -- a policy written in this file, checked when it was compiled
policy (59 characters):
{
e["ship"] = 4.95;
e["note"] = "standard";
}
A-1174 basket 18.00 ship 4.95 standard
A-1175 basket 42.50 ship 4.95 standard
A-1176 basket 96.00 ship 4.95 standard
TUESDAY -- a policy that arrived, same binary, same baskets
policy (123 characters): { if (e["total"] >= 50) { e["ship"] = 0; e["note"] = "free over 50"; } else { e["ship"] = 4.95; e["note"] = "standard"; } }
A-1174 basket 18.00 ship 4.95 standard
A-1175 basket 42.50 ship 4.95 standard
A-1176 basket 96.00 ship 0.00 free over 50
Loading the source...
Loading the source...
Loading the source...
Loading the source...
Loading the source...
Loading the source...
Loading the source...
Nothing here is a snippet. Each program is the whole file, published by the step that compiled it, and each transcript is the whole run.
This page, as the page reads it.
Everything above is built from documents like these — fetched from this site, right now, by the same renderer that just drew the page around them.
{ "kind": "page", "v": 1, "updated": "2026-08-24", "title": "CX+AI — One language. For you & for your AI.", "import": [ "site.tokens", "site.strings", "site.header", "site.menu", "site.footer" ], "body": [ { "panel": { "id": "ticker", "class": "ticker", "children": [ { "text": { "value": "@ticker.head", "as": "plaque" }, "jitter": { "amplitude": 2, "speed": "slow" } }, { "list": { "feed": "ticker", "max": 6, "show": "all" } }, { "text": { "value": "@ticker.all" }, "onclick": { "navigate": { "to": "build.html" } } } ] }, "float": { "from": "left", "offset": 0, "align": "bottom" }, "hidden": { "start": true, "until": "feed" } }, { "header": "@site.header" }, { "menu": "@site.menu" }, { "panel": { "id": "top", "class": "hero", "children": [ { "text": { "value": "@hero.masthead", "as": "masthead" }, "style": { "size": "@h1-line" }, "jitter": { "amplitude": 9, "axis": "horizontal", "speed": "fast", "pattern": "burst", "spin": 0 } }, { "list": { "show": "decoder", "speed": "fast", "items": [ { "q": "C", "a": "All of C. Speed. Compatibility. Power.", "picture": "cxailines-1.png" }, { "q": "X", "a": "eXtended for fast development — high-level ease, batteries included.", "picture": "cxailines-2.png", "nudge": "4%" }, { "q": "+", "a": "", "picture": "cxailines-3.png", "nudge": "-34%" }, { "q": "A", "a": "Automation that gives your AI eyes, ears and steering — to write better code.", "picture": "cxailines-4.png", "nudge": "7%" }, { "q": "I", "a": "Integrated AI — code and rules that arrive while the program runs.", "picture": "cxailines-5.png" } ] } }, { "list": { "show": "prompt", "speed": "medium", "items": [ { "pick": "Make it rain", "q": "make it rain" }, { "pick": "Petals on the wind", "q": "petals on the wind" }, { "pick": "Random bubbles", "q": "random bubbles" }, { "pick": "What can I say?", "q": "help" }, { "q": "What does \"AI as a component\" actually mean?", "a": "It means the model is a part of your program rather than a service your program phones. It runs locally, it is bounded, you can watch what it does, and the code it writes is compiled and executed by an engine you can point a decompiler at. A remote oracle can only be trusted; a component can be inspected." }, { "q": "Can it really change its own code while running?", "a": "Yes, and that is the part worth watching. AI-written behaviour is compiled into bytecode and swapped into a running program, in a bounded region executed by the register VM. `cx --decompile` turns that bytecode back into readable source whenever you want to audit what your program was told to do." }, { "q": "Which model does it use?", "a": "A small local one, on your machine. The point of the design is that it is small enough to be a component: predictable to call, cheap to run, and yours. Nothing on this page sends anything anywhere." }, { "q": "Do I need a GPU?", "a": "No. Small local models are the design centre, and the reason the word \"small\" keeps appearing is that a component you cannot afford to call is not a component." }, { "q": "What happens when the model says something stupid?", "a": "The same thing that happens when a person writes something stupid: it does not compile, or it fails loudly. CX+AI's first principle is that errors are errors -- a clear message at the line that caused it, never a silent zero. The generated code goes through the same compiler your code does." }, { "q": "Is anything sent to a server?", "a": "Not by this page and not by the runtime. The programs on this page were downloaded once and are running on your own machine; the answers below that carry your own numbers were computed here, in your browser, by a CX+AI program of about 300 KB." }, { "q": "What time is it at all three points?", "live": "clocks" }, { "q": "Can I use my own model?", "a": "That is the intent of a local runtime, and it is the direction of travel rather than a finished switch today. Ask us what you want to run and we will tell you honestly where it stands." }, { "q": "Show me the smallest useful thing.", "a": "`cx hello.cx --run`. One file, one command, a native executable. Then open the documentation from the menu on the left -- it is the same manual set the release ships, served in this page's own frame." }, { "q": "How do I read the source of what the AI wrote?", "a": "`cx --decompile`. It is one flag, it works on the bytecode a running program is actually executing, and it exists because a component you cannot read is just an oracle with better manners." }, { "q": "Why does this exist?", "a": "I'm a pragmatic person by design. CX+AI is a pragmatic language by design. It is C -- expanded so it is faster to write, without giving up C's speed, its libraries or its compatibility -- and then extended so that a human and an AI can develop in the same language, in the same source. That is the whole idea. Everything else on this page is an instance of it." }, { "q": "How fast is it?", "a": "It compiles to C and links as a native executable, so on the compiled path it is as fast as the C it becomes. The second engine is a compact register VM with 132 opcodes, and that is the one AI-written code runs in -- bounded, observable, and decompilable back to readable source. Speed is measured on real hardware rather than asserted here; where a number would be a claim, this page gives you the mechanism instead." }, { "q": "What can I run it on?", "a": "Windows, macOS and Linux from the same source, and -- since this month -- a browser tab: the three programs on this page are CX+AI compiled to WebAssembly with the engine's own graphics runtime. Not one line of their source is web-specific." }, { "q": "How finished is it?", "a": "Finished enough to build with, not finished enough to be quiet about. The compiler and both engines are 155388 lines of C across 267 files, with 763 built-in functions across 35 families, all documented. It is guarded by 648 regression checks and 285 language tests that run before anything ships. It is one person's work and the version number moves most days." }, { "q": "Who is behind this?", "a": "One person writes the code, in Malta -- with an AI working beside him: CX+AI is developed with Claude, by Anthropic, and that is said as credit rather than as confession. The language exists so that a human and an AI can build in the same source, and it is built exactly that way. The team page names three, and one of them is an AI; there is no advisory board, and nothing here was bought in. The community around it came through Kwaai -- we are members of that community, not backed by it, and the difference matters enough to say it in the same breath." }, { "q": "What does it cost?", "a": "Nothing to download and try -- the compiler, the manuals and the playground are free. The paid side is on the pricing page: Pro is €15 per user per month for anyone who subscribes in our first year, kept for as long as you stay subscribed, against a standing price of €30. Enterprise is by agreement -- talk to us. And if you stop paying, you keep what you were given." }, { "q": "What is the distance and area between the three points?", "live": "triangle" }, { "q": "Where is Malta, from where I am?", "live": "malta" }, { "q": "How far away is this page, really?", "live": "latency" }, { "q": "What does this page know about me?", "live": "country" } ], "onask": { "callai": {} } } }, { "tabs": { "pick": "hostname", "items": [ { "tab": "AI", "host": "ai", "children": [ { "panel": { "class": "pad", "eyebrow": "@pad.eyebrow", "title": "@pad.ai.q", "children": [ { "text": { "value": "@pad.ai.a" } } ] } }, { "text": { "value": "Your AI writes code. This one runs it, watches it, and hands you the source afterwards. The globe below is a CX+AI program, drawing the route this page just travelled to reach you.", "as": "lede" } }, { "tabs": { "look": "folder", "items": [ { "tab": "The globe", "colour": "@door-black", "ink": "@door-black-ink", "children": [ { "app": { "src": "/apps/globe.html", "width": 720, "height": 420, "title": "Where you are", "start": "load", "pass": [ "visitor" ] } } ] }, { "tab": "Its source", "colour": "@door-white", "ink": "@door-white-ink", "children": [ { "source": { "program": "globe", "title": "globe.cx — the whole program, as the build compiles it" } }, { "text": { "value": "The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.", "as": "note" } } ] } ] } }, { "list": { "show": "prompt", "items": [ { "pick": "Spin it faster", "q": "make the globe spin much faster" }, { "pick": "Hide the moon", "q": "hide the moon" }, { "pick": "Zoom out", "q": "move the camera a long way back" }, { "pick": "Try your own …" } ], "onask": { "callai": { "to": "globe", "rule": "DEFAULTS", "carry": true } } } } ], "colour": "@door-white", "ink": "@door-white-ink" }, { "tab": "BUSINESS", "host": "business", "children": [ { "panel": { "class": "pad", "eyebrow": "@pad.eyebrow", "title": "@pad.biz.q", "children": [ { "text": { "value": "@pad.biz.a" } } ] } }, { "text": { "value": "The sheet below is not a picture of a spreadsheet. It is a program, running in your browser, arranging itself around your country's date format and tax line. Click a line.", "as": "lede" } }, { "tabs": { "look": "folder", "items": [ { "tab": "The sheet", "colour": "@door-black", "ink": "@door-black-ink", "children": [ { "app": { "src": "/apps/living_invoice.html", "width": 1040, "height": 664, "title": "The living invoice", "start": "load", "pass": [ "visitor" ] } } ] }, { "tab": "Its source", "colour": "@door-white", "ink": "@door-white-ink", "children": [ { "text": { "value": "Two things in that listing are what the sheet above actually is.", "as": "sub" } }, { "text": { "value": "<strong>_json look</strong> is the whole appearance of the sheet — the header strip, the four column widths, the zebra, the tint under each summary row, the darker ink on the total — written as one JSON document and applied in a single load. It is data: read it from a file, send it from a server, let a customer pick it. Change a value in it and the sheet looks different; not one other line of the program moves.", "as": "note" } }, { "text": { "value": "<strong>_rules AMOUNT</strong>, and the three beside it, are the formulas in column D. None of them was compiled with the program: each is TEXT the file hands to a cell, which the engine compiles in-process and re-runs whenever the sheet moves. Click any row above and the text behind its figure opens in the bar under the sheet — the same line, in full, and not a description of it. That is why the quantity discount is a formula and not an if-statement somebody has to rebuild the program to change.", "as": "note" } }, { "source": { "program": "living_invoice", "title": "living_invoice.cx — the whole program, as the build compiles it" } }, { "text": { "value": "The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.", "as": "note" } } ] } ] } }, { "list": { "show": "prompt", "items": [ { "pick": "A fifth off at five or more", "q": "give a fifth off when the quantity is five or more" }, { "pick": "Two tiers of discount", "q": "a tenth off at three or more, and a fifth off at ten or more" }, { "pick": "No discount at all", "q": "charge the full price on every line, with no discount" }, { "pick": "Try your own …" } ], "onask": { "callai": { "to": "living_invoice", "rule": "AMOUNT" } } } }, { "text": { "value": "The prompt, tested before it was published:", "as": "sub" } }, { "text": { "value": "Read the CX+AI documentation at https://cxai.plus/docs/ - the language reference and the builtins reference. Then take my spreadsheet, saved as CSV, and write me a single CX+AI program (.cx) that reproduces what it calculates. Read the file with fread(), break it into lines with split() and pull each column out with stringsplit(), convert numbers with the (int) and (float) casts, and print the totals. Keep it to one file, and make it compile with no warnings. I will run it with: cx myreport.cx --run", "as": "note" } } ], "colour": "@door-blue", "ink": "@door-blue-ink" }, { "tab": "GAMING", "host": "gaming", "children": [ { "panel": { "class": "pad", "eyebrow": "@pad.eyebrow", "title": "@pad.game.q", "children": [ { "text": { "value": "@pad.game.a" } } ] } }, { "text": { "value": "Play backgammon against a character who will tell you why it moved. Five of them. Each one is a file you could edit.", "as": "lede" } }, { "text": { "value": "Choose your opponent. Each one is a file — a name, two numbers that steer how it plays, and every line it says.", "as": "sub" } }, { "tabs": { "look": "folder", "items": [ { "tab": "The game", "colour": "@door-black", "ink": "@door-black-ink", "children": [ { "control": { "as": "selector", "bind": "foe", "id": "foesel", "title": "Opponent", "values": [ { "value": "nonna", "label": "Nonna" }, { "value": "purser", "label": "The Purser" }, { "value": "kit", "label": "Kit" }, { "value": "vella", "label": "Dr. Vella" }, { "value": "ferryman", "label": "The Ferryman" } ] } }, { "app": { "src": "/apps/backgammon.html", "width": 860, "height": 620, "title": "Backgammon", "start": "load", "pass": [ "persona" ] } } ] }, { "tab": "Its source", "colour": "@door-white", "ink": "@door-white-ink", "children": [ { "source": { "program": "backgammon", "title": "backgammon.cx -- the whole program, as the build compiles it" } }, { "text": { "value": "The same file builds the desktop program and the one running above. There is no web version of it and no desktop version of it — there is one program.", "as": "note" } } ] } ] } }, { "list": { "show": "prompt", "items": [ { "pick": "Who are you?", "q": "who are you, and how long have you been playing?" }, { "pick": "Why that move?", "q": "why did you play that move?" }, { "pick": "Roll again", "q": "roll the dice again, I do not like this roll" }, { "pick": "Swap sides", "q": "swap sides with me" }, { "pick": "Try your own …" } ], "onask": { "callai": { "to": "backgammon", "rule": "DEFAULTS", "who": "foe" } } } }, { "text": { "value": "And the program that proved a CX+AI game could be played in a browser tab at all — arrow keys or the mouse, SPACE to launch.", "as": "sub" } }, { "tabs": { "look": "folder", "items": [ { "tab": "The game", "colour": "@door-black", "ink": "@door-black-ink", "children": [ { "app": { "src": "/apps/neon_breakout.html", "width": 640, "height": 480, "title": "Play Neon Breakout", "start": "click" } } ] }, { "tab": "Its source", "colour": "@door-white", "ink": "@door-white-ink", "children": [ { "source": { "program": "neon_breakout", "title": "neon_breakout.cx -- the whole game, as the build compiles it" } } ] } ] } }, { "text": { "value": "Every demonstration on this page shows the file it was built from, and the game is no exception — a paddle, a ball, fifty bricks, and the line it prints on the way out.", "as": "note" } } ], "colour": "@door-black", "ink": "@door-black-ink" } ], "look": "folder" } } ] } }, { "panel": { "id": "explore", "class": "deck", "eyebrow": "@nav.explore", "title": "@explore.h2", "children": [ { "text": { "value": "@deckhint" } }, { "cards": { "open": "click", "items": [ { "n": "01 / language", "title": "@e01.h", "kicker": "@e01.k", "body": [ "@e01.p1", "@e01.p2" ] }, { "n": "02 / ai", "title": "@e02.h", "kicker": "@e02.k", "body": [ "@e02.p1", "@e02.p2", "@e02.p3" ] }, { "n": "03 / playground", "title": "@e03.h", "kicker": "@e03.k", "body": [ "@e03.p1", "@e03.p2" ], "doors": [ { "label": "Open the playground", "onclick": { "navigate": { "to": "#playground" } } } ] }, { "n": "04 / download", "title": "@e04.h", "kicker": "@e04.k", "body": [ "@e04.p1", "@e04.p2" ], "doors": [ { "label": "Get CX+AI", "onclick": { "navigate": { "to": "#download" } } } ] }, { "n": "05 / docs", "title": "@e05.h", "kicker": "@e05.k", "body": [ "@e05.p1", "@e05.p2" ], "doors": [ { "label": "Read the manuals", "onclick": { "navigate": { "to": "docs/index.html" } } }, { "label": "Builtins reference", "onclick": { "navigate": { "to": "docs/CX_Builtins_Reference.html" } } } ] }, { "n": "06 / gigantica", "title": "@e06.h", "kicker": "@e06.k", "body": [ "@e06.p1", "@e06.p2" ], "doors": [ { "label": "Follow the build", "onclick": { "navigate": { "to": "build.html" } } } ] } ] }, "jitter": { "amplitude": 16, "speed": "slow", "collide": true } } ] } }, { "panel": { "id": "platform", "class": "deck", "eyebrow": "@nav.platform", "title": "@platform.h2", "children": [ { "table": { "show": "grid", "columns": [ "@grid.you", "@grid.ai" ], "rows": [ { "label": "@grid.r1.cap", "cells": [ "@grid.r1.you", "@grid.r1.ai" ] }, { "label": "@grid.r2.cap", "cells": [ "@grid.r2.you", "@grid.r2.ai" ] }, { "label": "@grid.r3.cap", "cells": [ "@grid.r3.you", "@grid.r3.ai" ] }, { "label": "@grid.r4.cap", "cells": [ "@grid.r4.you", "@grid.r4.ai" ] }, { "label": "@grid.r5.cap", "cells": [ "@grid.r5.you", "@grid.r5.ai" ] }, { "label": "@grid.r6.cap", "cells": [ "@grid.r6.you", "@grid.r6.ai" ] }, { "label": "@grid.r7.cap", "cells": [ "@grid.r7.you", "@grid.r7.ai" ] } ] } }, { "table": { "show": "facts", "rows": [ { "value": "762", "label": "@fact.builtins", "note": "across 35 families" }, { "value": "10", "label": "@fact.providers", "note": "including fully local" }, { "value": "1102", "label": "@fact.tests", "note": "Windows, Linux and macOS" }, { "value": "1000+", "label": "@fact.testers", "note": "personal, local, open AI" } ] } }, { "table": { "show": "families", "definition": "site.families" } }, { "text": { "value": "Compiler, IDE, 2D/3D game engine with a particle system, and an embedded AI subsystem — one codebase, native ahead-of-time compilation for your code and a compact register VM for the AI's. <strong>Windows, Linux and macOS</strong>, native and VM, with identical output. CX+AI is C-compatible: everything C can do, CX+AI can do, with less ceremony. It also builds <strong>loadable libraries</strong>: --shared produces a .dll, .so or .dylib with your CX+AI functions as the library's API (gcc or clang).", "as": "note" } }, { "text": { "value": "We are members of the <a href=\"https://kwaai.ai\">Kwaai</a> community and share its conviction that AI should be personal, local and open to inspection.", "as": "note" } }, { "text": { "value": "What you get", "as": "sub" } }, { "text": { "value": "Nine of them. Click any card to open it." } }, { "cards": { "open": "click", "items": [ { "n": "01 / language", "title": "@p01.h", "kicker": "@p01.k", "body": [ "@p01.p1", "@p01.p2" ] }, { "n": "02 / ai", "title": "@p02.h", "kicker": "@p02.k", "body": [ "@p02.p1", "@p02.p2" ] }, { "n": "03 / audit", "title": "@p03.h", "kicker": "@p03.k", "body": [ "@p03.p1", "@p03.p2" ] }, { "n": "04 / execution", "title": "@p04.h", "kicker": "@p04.k", "body": [ "@p04.p1", "@p04.p2" ] }, { "n": "05 / platforms", "title": "@p05.h", "kicker": "@p05.k", "body": [ "@p05.p1", "@p05.p2" ] }, { "n": "06 / engine", "title": "@p06.h", "kicker": "@p06.k", "body": [ "@p06.p1", "@p06.p2", "@p06.p3" ] }, { "n": "07 / stdlib", "title": "@p07.h", "kicker": "@p07.k", "body": [ "@p07.p1", "@p07.p2", "@p07.p3", "@p07.p4" ], "doors": [ { "label": "Browse them all", "onclick": { "navigate": { "to": "docs/CX_Builtins_Reference.html" } } } ] }, { "n": "08 / docs", "title": "@p08.h", "kicker": "@p08.k", "body": [ "@p08.p1", "@p08.p2" ], "doors": [ { "label": "Read the manuals", "onclick": { "navigate": { "to": "docs/index.html" } } }, { "label": "Builtins reference", "onclick": { "navigate": { "to": "docs/CX_Builtins_Reference.html" } } } ] }, { "n": "09 / playground", "title": "@p09.h", "kicker": "@p09.k", "body": [ "@p09.p1", "@p09.p2", "@p09.p3" ], "doors": [ { "label": "Try it in your browser", "onclick": { "navigate": { "to": "play.html" } } } ] }, { "n": "@c10.n", "title": "@c10.h", "kicker": "@c10.k", "body": [ "@c10.p1", "@c10.p2", "@c10.p3", "@c10.x" ] } ] }, "jitter": { "amplitude": 16, "speed": "slow", "collide": true } } ] } }, { "panel": { "id": "team", "eyebrow": "@nav.team", "title": "Built by a man & his AI assistant — the premise in the build itself", "children": [ { "text": { "value": "Terence Agius", "as": "sub" } }, { "text": { "value": "Founder · Technology" } }, { "text": { "value": "Thirty-five years building runtime and VM systems. Sole technical author of the CX+AI platform — compiler, engine, and AI subsystem." } }, { "text": { "value": "Claude, by Anthropic", "as": "sub" } }, { "text": { "value": "The AI that writes the code" } }, { "text": { "value": "Named here because the work has earned it. It writes under one person’s rulings — every design decision, every result read by a human — and nothing it writes reaches a release until the regression battery has passed. A language whose whole thesis is that a person and an AI can develop in the same source ought to say which AI, and this is it." } } ] } }, { "panel": { "id": "pricing", "class": "business", "eyebrow": "@price.eyebrow", "title": "@price.title", "children": [ { "text": { "value": "Three tiers, and what separates them is which SOURCE you get — never how much of the language you may use. There is no cut-down build: the free compiler is the whole compiler, and the runtime it links into every program you build is the whole engine — the same virtual machine, the same built-in library, and the same ability to assemble and swap code while your program is running. Above Free you are buying that source, and the person you would be talking to is the one who writes it.", "as": "lede" } }, { "tabs": { "look": "folder", "items": [ { "tab": "@price.tab.tiers", "colour": "@door-white", "ink": "@door-white-ink", "children": [ { "cards": { "look": "price", "open": "always", "items": [ { "title": "@price.free.name", "kicker": "@price.free.k", "price": "@price.free.p", "ticks": [ { "yes": true, "label": "@price.t.compiler" }, { "yes": true, "label": "@price.t.docs" }, { "yes": true, "label": "@price.t.commercial" }, { "yes": false, "label": "@price.t.runtimesrc" }, { "yes": false, "label": "@price.t.fullsrc" } ], "doors": [ { "label": "@price.free.cta", "onclick": { "navigate": { "to": "#download" } } } ] }, { "title": "@price.pro.name", "kicker": "@price.pro.k", "price": "@price.pro.p", "sub": "@price.pro.ps", "ticks": [ { "yes": true, "label": "@price.t.everyfree" }, { "yes": true, "label": "@price.t.runtimesrc" }, { "yes": true, "label": "@price.t.perpetual" }, { "yes": false, "label": "@price.t.fullsrc" } ], "doors": [ { "label": "@price.contact", "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/source" } } } ] }, { "title": "@price.ent.name", "kicker": "@price.ent.k", "price": "@price.ent.p", "ticks": [ { "yes": true, "label": "@price.t.everypro" }, { "yes": true, "label": "@price.t.fullsrc" }, { "yes": true, "label": "@price.t.negotiated" } ], "doors": [ { "label": "@price.contact", "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/source" } } } ] } ] } }, { "text": { "value": "There is no checkout on this page. Nothing here takes a card, and nothing on this site ever has.", "as": "note" } } ] }, { "tab": "@price.tab.detail", "colour": "@door-blue", "ink": "@door-blue-ink", "children": [ { "table": { "show": "rows", "columns": [ "Tier", "What you get", "Price" ], "rows": [ [ "Free", "The released compiler and runtime, the full documentation and every example. Free to use, including commercially.", "Free" ], [ "Pro", "The runtime sources — the C the engine is built from — on top of everything in Free.", "€15 / user / month" ], [ "Enterprise", "The full sources: compiler, runtime, toolchain.", "Contact us" ] ] } }, { "text": { "value": "<strong>Founder price.</strong> Subscribe during our first year and keep €15 a month for as long as you stay subscribed. The standing price is €30. About the price of a coffee a week, and half that if you are early.", "as": "note" } }, { "text": { "value": "<strong>If you stop paying, you keep what you were given.</strong> Every version of the source you received while subscribed is yours perpetually under the licence — you stop receiving new ones, you do not lose the ones you have.", "as": "note" } }, { "text": { "value": "Enterprise carries no figure on this page, and that is deliberate rather than coy: full source is a negotiated agreement and the terms matter more than the number. Write and we will tell you where it stands.", "as": "note" } } ] }, { "tab": "@price.tab.work", "colour": "@door-black", "ink": "@door-black-ink", "children": [ { "text": { "value": "Separate from the tiers, and not a price list: these are ways we work with people who want something built. Every one of them starts with a conversation.", "as": "prose" } }, { "table": { "show": "rows", "columns": [ "Package", "Who it is for", "What you get", "Price" ], "rows": [ [ "One report", "A business with a spreadsheet that matters", "We turn one of your reports into a program with you, and you keep it.", "Contact us" ], [ "Onboarding", "A small team adopting it", "A half-day workshop, a migration of your first few jobs, and a year of support.", "Contact us" ], [ "Build with us", "A product with a deadline", "Engine work, ports, and features built against your roadmap rather than ours.", "Contact us" ] ] } }, { "text": { "value": "Get in touch →", "as": "action" }, "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/source" } } } ] } ] } } ] } }, { "panel": { "id": "download", "class": "plain", "eyebrow": "@nav.download", "title": "@dl.title", "children": [ { "text": { "value": "@dl.lede", "as": "lede" } }, { "cards": { "look": "os", "open": "always", "items": [ { "picture": "os-windows.svg", "title": "@dl.win.name", "kicker": "@dl.win.k", "doors": [ { "label": "@dl.cta", "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/windows" } } } ] }, { "picture": "os-macos.svg", "title": "@dl.mac.name", "kicker": "@dl.mac.k", "doors": [ { "label": "@dl.cta", "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/macos" } } } ] }, { "picture": "os-linux.svg", "title": "@dl.lin.name", "kicker": "@dl.lin.k", "doors": [ { "label": "@dl.cta", "onclick": { "navigate": { "to": "https://forms.cxai.plus/get/linux" } } } ] } ] } }, { "text": { "value": "@dl.note", "as": "note" } } ] } }, { "panel": { "id": "origins", "class": "plain", "eyebrow": "@nav.origins", "title": "@origin.title", "children": [ { "text": { "value": "@origin.s1", "as": "sub" } }, { "text": { "value": "@origin.p1" } }, { "text": { "value": "@origin.p2" } }, { "text": { "value": "@origin.p3" } }, { "text": { "value": "@origin.s2", "as": "sub" } }, { "text": { "value": "@origin.p4" } }, { "text": { "value": "@origin.p4b" } }, { "text": { "value": "@origin.p5" } }, { "text": { "value": "@origin.p6" } }, { "text": { "value": "@origin.s3", "as": "sub" } }, { "text": { "value": "@origin.p7" } }, { "text": { "value": "@origin.s4", "as": "sub" } }, { "text": { "value": "@origin.p8" } }, { "text": { "value": "@origin.s5", "as": "sub" } }, { "text": { "value": "@origin.p9" } }, { "text": { "value": "@origin.p10" } }, { "text": { "value": "@origin.p11", "as": "signature" } } ] } }, { "panel": { "id": "docs", "class": "plain", "title": "@nav.docs", "children": [ { "document": { "page": "index" } } ] } }, { "panel": { "id": "examples", "class": "plain", "eyebrow": "@nav.examples", "title": "@ex.h2", "children": [ { "text": { "value": "@ex.lede", "as": "lede" } }, { "tabs": { "look": "folder", "items": [ { "tab": "@ex.tab.rules", "children": [ { "tabs": { "items": [ { "tab": "@ex.view.out", "children": [ { "source": { "program": "rules_live", "show": "output", "title": "@ex.o.rules" } } ] }, { "tab": "@ex.view.prog", "children": [ { "source": { "program": "rules_live", "title": "@ex.t.rules" } } ] } ] } } ] }, { "tab": "@ex.tab.json", "children": [ { "tabs": { "items": [ { "tab": "@ex.view.out", "children": [ { "source": { "program": "json_document", "show": "output", "title": "@ex.o.json" } } ] }, { "tab": "@ex.view.prog", "children": [ { "source": { "program": "json_document", "title": "@ex.t.json" } } ] } ] } } ] }, { "tab": "@ex.tab.coerce", "children": [ { "tabs": { "items": [ { "tab": "@ex.view.out", "children": [ { "source": { "program": "coercion", "show": "output", "title": "@ex.o.coerce" } } ] }, { "tab": "@ex.view.prog", "children": [ { "source": { "program": "coercion", "title": "@ex.t.coerce" } } ] } ] } } ] }, { "tab": "@ex.tab.rulesc", "children": [ { "tabs": { "items": [ { "tab": "@ex.view.out", "children": [ { "source": { "program": "rules_vs_c", "show": "output", "title": "@ex.o.rulesc" } } ] }, { "tab": "@ex.view.prog", "children": [ { "source": { "program": "rules_vs_c", "title": "@ex.t.rulesc" } } ] } ] } } ] } ] } }, { "text": { "value": "@ex.note", "as": "note" } } ] } }, { "panel": { "id": "source", "class": "plain", "eyebrow": "@nav.source", "title": "@src.h2", "children": [ { "text": { "value": "@src.lede", "as": "lede" } }, { "tabs": { "look": "folder", "items": [ { "tab": "@src.tab.page", "children": [ { "tabs": { "items": [ { "tab": "@src.view.text", "children": [ { "source": { "definition": "pages/index", "title": "@src.t.page" } } ] }, { "tab": "@src.view.data", "children": [ { "data": { "definition": "pages/index", "title": "@src.t.page" } } ] } ] } } ] }, { "tab": "@src.tab.text", "children": [ { "tabs": { "items": [ { "tab": "@src.view.text", "children": [ { "source": { "definition": "site.strings", "title": "@src.t.text" } } ] }, { "tab": "@src.view.data", "children": [ { "data": { "definition": "site.strings", "title": "@src.t.text" } } ] } ] } } ] }, { "tab": "@src.tab.look", "children": [ { "tabs": { "items": [ { "tab": "@src.view.text", "children": [ { "source": { "definition": "site.tokens", "title": "@src.t.look" } } ] }, { "tab": "@src.view.data", "children": [ { "data": { "definition": "site.tokens", "title": "@src.t.look" } } ] } ] } } ] }, { "tab": "@src.tab.spec", "children": [ { "tabs": { "items": [ { "tab": "@src.view.text", "children": [ { "source": { "definition": "site.spec", "title": "@src.t.spec" } } ] }, { "tab": "@src.view.data", "children": [ { "data": { "definition": "site.spec", "title": "@src.t.spec" } } ] } ] } } ] } ] } }, { "text": { "value": "@src.note", "as": "note" } } ] } }, { "panel": { "id": "playground", "eyebrow": "PLAYGROUND", "title": "Write CX+AI, press Run.", "children": [ { "text": { "value": "Curated examples, or your own program. It runs here, in the page, on your machine." } }, { "app": { "src": "/play.html", "width": 1040, "height": 620, "title": "The playground", "start": "load", "needs": [ "worker" ] } } ] } }, { "panel": { "id": "how", "class": "plain", "eyebrow": "Powered by CX+AI", "title": "How this site works", "children": [ { "text": { "value": "<b>These pages were written by a CX+AI program.</b> Every HTML file on this site is produced at build time by <code>forge</code> — a program written in CX+AI, compiled by the CX+AI compiler — which fills in each page’s figures and assembles the documentation section from the same manuals the downloads ship." } }, { "text": { "value": "<b>The log on this page is answered by a CX+AI program.</b> The entries in the workshop log are fetched live from an endpoint that is not a web server handing back a file: it is a CX+AI program, using the language’s own HTTP tier, running on our machine and answering every request itself." } }, { "text": { "value": "<b>The notice on the front page is run by the CX+AI virtual machine, in your browser.</b> It is a CX+AI program compiled to bytecode, executed by the CX+AI VM built as WebAssembly in your own tab. What each entry says, what colour it takes and which week it falls in are that program’s decisions, not JavaScript’s." } }, { "text": { "value": "<b>This page is DESCRIBED in a language of its own.</b> What you are reading is not markup somebody wrote — it is a JSON definition, checked by a CX+AI program before it may ship, and drawn by one small renderer that every page of this site shares." } }, { "text": { "value": "The honest scope, which is the part worth stating: the pages themselves are ordinary static files on a content network. What is CX+AI is everything that <em>produces</em> them, the live feed, and the program that renders the notice in your tab. None of it needs taking on trust — the feed’s response headers show what answers it, and this page’s own source names the VM module and the compiled program it runs.", "as": "note" } }, { "text": { "value": "Everything dispatched and shipped →" }, "onclick": { "navigate": { "to": "/build.html" } } } ] } }, { "panel": { "id": "contribute", "class": "plain", "eyebrow": "If you wish to help", "title": "Help build CX+AI.", "children": [ { "text": { "value": "CX+AI is written by one person. The most useful thing anyone else can do is use the language and say what happened — what worked, what broke, and what was missing when you reached for it.", "as": "lede" } }, { "text": { "value": "Two things worth saying before the list, because both are usually assumed. The public repository ships the compiler, the runtime library, the headers, the documentation and the examples — <strong>it does not ship the compiler’s source</strong>, so there is nothing to send a pull request against. And not one of the four things below costs anything: money is mentioned once on this site, at the foot of this panel, and it is optional in the way a tip is optional.", "as": "note" } }, { "text": { "value": "Four things that help", "as": "sub" } }, { "cards": { "open": "click", "items": [ { "n": "01 / use it", "title": "Use it", "kicker": "The only way the awkward parts get found.", "body": [ "Write something real in it. A script you would otherwise have written in C, a tool you keep meaning to build. That is the only way the awkward parts of a language get found." ], "doors": [ { "label": "Run CX+AI in your browser", "onclick": { "navigate": { "to": "#playground" } } } ] }, { "n": "02 / report", "title": "Tell us when it breaks", "kicker": "A program that reproduces it beats a careful description.", "body": [ "A wrong answer, a confusing error, a crash, a page of the manual that is no longer true. Small reports are welcome; a program that reproduces it is worth more than a careful description." ], "doors": [ { "label": "Open an issue", "onclick": { "navigate": { "to": "https://github.com/KingWolf71/cxai/issues" } } } ] }, { "n": "03 / examples", "title": "Send an example", "kicker": "Short programs are the documentation people actually read.", "body": [ "Short programs that show one thing clearly are the documentation people actually read. If you write one you are pleased with, send it — with your name on it if you would like it there." ], "doors": [ { "label": "hello@cxai.plus", "onclick": { "navigate": { "to": "mailto:hello@cxai.plus?subject=CX%20example" } } } ] }, { "n": "04 / tell someone", "title": "Mention it to someone", "kicker": "Particularly a C programmer, or anyone who used PureBasic.", "body": [ "Particularly a C programmer, or anyone who used PureBasic. The people who would recognise what CX+AI is trying to be are not the people who read language announcements." ] } ] }, "jitter": { "amplitude": 16, "speed": "slow", "collide": true } }, { "text": { "value": "If you would rather send fuel", "as": "sub" } }, { "text": { "value": "The four above are worth more than money, and that is not modesty — a language gets fixed by people using it, not by people funding it. But CX+AI is written by one person, and if it is useful to you and you would like to help it exist, donations are welcome. No tiers, no perks, no say over what gets built next — just fuel. The sign below is an ordinary link and its picture is served from here, so nothing on this page talks to a payment provider unless you decide to click it.", "as": "note" } }, { "image": { "src": "/buymeacoffee.png", "alt": "Buy me a coffee", "width": 335, "height": 128 }, "onclick": { "navigate": { "to": "https://buymeacoffee.com/kingwolf71" } } }, { "text": { "value": "Keeping up with it", "as": "sub" } }, { "text": { "value": "Everything dispatched and shipped is published as it happens in the workshop log — no account, nothing to give up. If you would rather have it by email, the form further down this page sends progress and nothing else.", "as": "note" } }, { "text": { "value": "Open the workshop log →" }, "onclick": { "navigate": { "to": "/build.html" } } } ] } }, { "panel": { "class": "quiet", "children": [ { "text": { "value": "<b>CX+AI is built by one person.</b> Using it and saying what happened — what worked, what broke, what was missing — is the most useful thing anyone else can do." } }, { "text": { "value": "Ways to help →" }, "onclick": { "navigate": { "to": "#contribute" } } } ] } }, { "footer": "@site.footer" } ]}
Loading the source...
Loading the source...
Loading the source...
No page here was hand-assembled. A CX+AI program reads these documents and writes the pages; another serves the notice in the corner; a third builds the manuals. The site is the product, running.
Write CX+AI, press Run.
Curated examples, or your own program. It runs here, in the page, on your machine.
How this site works
These pages were written by a CX+AI program. Every HTML file on this site is produced at build time by forge — a program written in CX+AI, compiled by the CX+AI compiler — which fills in each page’s figures and assembles the documentation section from the same manuals the downloads ship.
The log on this page is answered by a CX+AI program. The entries in the workshop log are fetched live from an endpoint that is not a web server handing back a file: it is a CX+AI program, using the language’s own HTTP tier, running on our machine and answering every request itself.
The notice on the front page is run by the CX+AI virtual machine, in your browser. It is a CX+AI program compiled to bytecode, executed by the CX+AI VM built as WebAssembly in your own tab. What each entry says, what colour it takes and which week it falls in are that program’s decisions, not JavaScript’s.
This page is DESCRIBED in a language of its own. What you are reading is not markup somebody wrote — it is a JSON definition, checked by a CX+AI program before it may ship, and drawn by one small renderer that every page of this site shares.
The honest scope, which is the part worth stating: the pages themselves are ordinary static files on a content network. What is CX+AI is everything that produces them, the live feed, and the program that renders the notice in your tab. None of it needs taking on trust — the feed’s response headers show what answers it, and this page’s own source names the VM module and the compiled program it runs.
Everything dispatched and shipped →Help build CX+AI.
CX+AI is written by one person. The most useful thing anyone else can do is use the language and say what happened — what worked, what broke, and what was missing when you reached for it.
Two things worth saying before the list, because both are usually assumed. The public repository ships the compiler, the runtime library, the headers, the documentation and the examples — it does not ship the compiler’s source, so there is nothing to send a pull request against. And not one of the four things below costs anything: money is mentioned once on this site, at the foot of this panel, and it is optional in the way a tip is optional.
Four things that help
Use it
The only way the awkward parts get found.
Write something real in it. A script you would otherwise have written in C, a tool you keep meaning to build. That is the only way the awkward parts of a language get found.
Run CX+AI in your browserTell us when it breaks
A program that reproduces it beats a careful description.
A wrong answer, a confusing error, a crash, a page of the manual that is no longer true. Small reports are welcome; a program that reproduces it is worth more than a careful description.
Open an issueSend an example
Short programs are the documentation people actually read.
Short programs that show one thing clearly are the documentation people actually read. If you write one you are pleased with, send it — with your name on it if you would like it there.
hello@cxai.plusMention it to someone
Particularly a C programmer, or anyone who used PureBasic.
Particularly a C programmer, or anyone who used PureBasic. The people who would recognise what CX+AI is trying to be are not the people who read language announcements.
If you would rather send fuel
The four above are worth more than money, and that is not modesty — a language gets fixed by people using it, not by people funding it. But CX+AI is written by one person, and if it is useful to you and you would like to help it exist, donations are welcome. No tiers, no perks, no say over what gets built next — just fuel. The sign below is an ordinary link and its picture is served from here, so nothing on this page talks to a payment provider unless you decide to click it.
Keeping up with it
Everything dispatched and shipped is published as it happens in the workshop log — no account, nothing to give up. If you would rather have it by email, the form further down this page sends progress and nothing else.
Open the workshop log →CX+AI is built by one person. Using it and saying what happened — what worked, what broke, what was missing — is the most useful thing anyone else can do.
Ways to help →