AI as a component. Not an oracle.

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.

json doc;
doc["servers"][0]["host"] = "alpha";  // levels made on demand
print(doc->count);                     // prints 1 — the handle knows itself

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.

Ten providers are supported, including fully local ones, so a program can ship with no external dependency and no per-token cost.

// guard is an entity; 0 = every frame, "" = no extra trigger
aiRule(guard, 0, "",
       "pursue the player when within 120 units; otherwise patrol");

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.

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.

All three platforms are built and tested, and the native and VM paths are held to identical output rather than merely "both working".

Over 300 automated tests run against that promise. A divergence between two backends is a failure, not a footnote.

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.

// pure CPU: no window, no graphics card needed
gpu_image_load_as("hero.png", "sprite_clean");

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.

sBody.s = httpGet("https://example.com/status.json");
json j = jsonParse(sBody);
print(j["state"]);
targz("backup.tar.gz", "./data");

The 35 component families, with the number of described builtins in each. These are the reference's own counts.

35 families · 882 described builtins — the counts above add up to exactly the number on the tile.

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 — 882 of its 882 rows carry a verified description — instead of implying it covers everything.

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.

print("hello from a browser tab");
n.i = 0;
for (i.i = 1; i <= 10; i = i + 1) { n = n + i; }
printf("1..10 sums to %d\n", n);

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.

// one broken line, compiled five times
EN  error: CX-E0001: expected ')', got EOF
ES  error: CX-E0001: se esperaba ')', se obtuvo EOF
FR  error: CX-E0001: attendu ')', obtenu EOF
DE  error: CX-E0001: ')' erwartet, EOF erhalten
IT  error: CX-E0001: atteso ')', ottenuto EOF

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.