AIENOSPERSISTENT MACHINE INTELLIGENCE

Omega

Omega is AIEN's language for all computing, GPU to CPU.

You write a program once. Omega's own tools check it and compile it straight to the machine code of the processor that runs it, GPU or CPU. No vendor compiler, toolkit or runtime library is involved anywhere.

On the GPU, that makes Omega the replacement for CUDA. On the CPU, it replaces C and its toolchain. This page says how far each of those has got, and the checks that have to pass before we can claim each one.

True today, with a receipt

Omega runs AIEN's models on the GB10 with no CUDA software: no libcuda, no cuBLAS, no nvcc.

See the receipt

Not true yet

“Omega replaces CUDA.”

0 of 6 checks met

Written from docs/OMEGA.md in the omega repository (branch docs/what-omega-is at 237c2095), checked 2026-10-21. Status words: PASS (a receipt exists on the named commit), PARTIAL, MISSING. Ledger item L386 tracks the work; tracking issue omega#593. Data file: /omega.json.

CUDA++, the GPU half of Omega, has its own page: CUDA++.

1 · The parts

Four parts, and the driver below them

Below Omega, and not part of it: the driver

Omega reaches the GPU through the physics repository's driver client (nvrm/nvrm.c, m16/m16_native.c). The client talks to NVIDIA's open-source kernel module (nvidia.ko, nvidia-uvm.ko, version 580.173.02) and the module boots NVIDIA's signed GSP firmware. Replacing the kernel module with our own driver is a separate job, L332. The firmware stays NVIDIA's for a physical reason: the GPU checks its signature and will not boot anything else.

Source on GitHub

2 · CUDA, piece by piece

Each piece of CUDA and Omega's replacement

“CUDA” is a stack of NVIDIA software. This is each piece, top of the stack to the chip, and Omega's replacement for it. Missing pieces are shown as missing.

  • PASS 2
  • PARTIAL 5
  • MISSING 5
  • NOT REPLACEABLE 1
CUDA pieceIts jobOmega's replacementStatus
CUDA C++ languageHow you write a kernelThe kernel builder (C calls). Omegese and OSC do not compile to the GPU yet.MISSINGbar C1Source on GitHub
nvcc, NVVM, PTX, ptxasCompile the kernel to machine codeOmega's own sm_121 encoder and register allocatorPASSevery kernel Omega runs is encoded by itSource on GitHub
libcuda (driver API)Talk to the kernel driverphysics nvrm client, ioctls straight to the open kernel modulePASSrequalification receipt in physicsReceipt on GitHub
libcudart (runtime API)Device, memory, launch, streamsOmega GPU session, command lists, job enginePARTIALone device, one process; no streams or events; a timeout ends GPU use for the processSource on GitHub
cuBLASMatrix multiplyOmega matmul, tensor-core GEMM, FP8 and BF16 APIsPARTIALshaped for the models we run; no any-shape GEMMSource on GitHub
cuDNN, FlashAttentionAttention and network layersOmega decode and prefill attentionPARTIALmodel-shapedSource on GitHub
CUB, ThrustReductions, scans, sortsOmega frozen-order reductionsPARTIALno general scan or sortReceipt on GitHub
cuFFT, cuRANDFFT, random numbersnoneMISSINGSource on GitHub
cuobjdump, nvdisasmRead machine code backnone: the tests still call NVIDIA's nvdisasm when it is installedMISSINGbar C6Source on GitHub
NsightMeasureOmega's own ceiling probes (115.14 TFLOPS tensor-core peak, 195.1 GB/s reads)PARTIALprobes exist, no single toolReceipt on GitHub
CUDA samples, docsYour first kernelnone yet: runtime/r2-hello and runtime/r1-api are unmerged branchesMISSINGbar C2Source on GitHub
nvidia.ko, nvidia-uvm.koKernel drivernot Omega: AIEN's own GB10 driver, L332MISSINGSource on GitHub
GSP firmwareRuns inside the GPUstays NVIDIA's (signature-checked by the chip)NOT REPLACEABLESource on GitHub

What is already true, with a receipt

The live 35B server ran with zero CUDA libraries

The 35B model AIEN serves on the Spark runs on Omega with no NVIDIA user-space software at all. On 2026-10-21 the live server (port 18091, --engine omega) had only libc, libm, libgcc_s and the loader mapped: zero CUDA libraries. It held /dev/nvidia0, /dev/nvidiactl and /dev/nvidia-uvm open, which is the open kernel module and nothing above it.

CUDA libraries mapped
0
Searched for
libcuda, libcudart, cublas, cudnn, nvrtc, libnvidia-ptxjitcompiler
Process
aien-serve-http --engine omega --port 18091, pid 2587647
Binary sha256
f4677d87750adbdcbe894e70d692d1b011bcc30296a5f550438b5ed5e442361b
Mapped libraries
ld-linux-aarch64.so.1, libc.so.6, libgcc_s.so.1, libm.so.6
Kernel driver
NVIDIA open kernel module 580.173.02
Device files held open
/dev/nvidia0, /dev/nvidiactl, /dev/nvidia-uvm

Taken 2026-10-21T21:50:23Z on spark-b87b. The receipt holds the binary sha256, the mapped libraries, ldd, the driver version and the commands used.

So this sentence is true today: Omega runs AIEN's models on the GB10 with no CUDA software: no libcuda, no cuBLAS, no nvcc.

Receipt on GitHub

What is not true yet

“Omega replaces CUDA.” is not true yet

The language does not reach the GPU

Omegese and OSC compile to one IR and checker2 checks it, but no Omegese kernel has run on the GB10 yet. Every GPU kernel Omega runs is still built by C calls to the kernel builder. This is bar C1.

Source on GitHub

The toolkit has gaps a stranger would hit on day one

No FFT or random numbers, no disassembler of our own, no samples and no written runtime API, no streams or events, one process per GPU, and GEMM shaped for the models we run. These are bars C2 to C6.

Source on GitHub

The kernel driver is still NVIDIA's open module

Omega reaches the GPU through the physics driver client, which talks to nvidia.ko and nvidia-uvm.ko, version 580.173.02. AIEN's own GB10 driver that replaces them is a separate job, L332.

Receipt on GitHub

The GSP firmware stays NVIDIA's

The kernel module boots NVIDIA's signed GSP firmware, which runs inside the GPU. It stays for a physical reason: the chip checks its signature and will not boot anything else.

Source on GitHub

3 · The bar for “Omega replaces CUDA”

0 of 6 met

We say it when every row is PASS, each with a receipt pushed on the exact commit. No row is waived. A row is ticked here only when its receipt is in the data file; until then it shows where it stands on the CUDA map above.

  1. C1 The language reaches the GPU.OPEN · MISSING

    Done when: Kernels written in Omegese compile through the IR and checker2 to sm_121 machine code and run on the GB10: vector add, a tiled GEMM and one decode-attention kernel. Their output matches a host reference bit for bit (or within a tolerance stated before the run), checker2 accepts every one, and a deliberately broken kernel is refused. At least one kernel of the live 35B decode path is then replaced by its Omegese version with identical golden tokens.

    Now: No Omegese kernel has run on the GPU (map row: CUDA C++ language).

    Source on GitHub

  2. C2 A stranger can run a kernel.OPEN · MISSING

    Done when: From an empty folder, only the README commands build and run hello-GPU on the GB10, and the zero-CUDA gate (aien-sovereign-core scripts/zero-cuda-gate.sh) passes on the binary. The runtime API is written down and versioned (docs/runtime/API.md, manifest check with negative controls).

    Now: hello-GPU and the runtime API are on unmerged branches (map row: CUDA samples, docs).

    Source on GitHub

  3. C3 General libraries.OPEN · PARTIAL

    Done when: Any-shape GEMM in BF16 and FP8, both layouts, at least 200 shapes from 1 to 8192, every shape correct against a host reference, speed given as a fraction of the measured tensor-core ceiling. Reductions and prefix sums over lengths 1 to 2^28, bit-exact against the frozen-order host reference.

    Now: GEMM is shaped for the models we run; no general scan or sort (map rows: cuBLAS, CUB).

    Source on GitHub

  4. C4 Streams and events.OPEN · MISSING

    Done when: Two independent queues of the same work finish in under 0.75 of the sum of their solo times; an event wait orders two dependent jobs, checked by data, on the chip.

    Now: The runtime has no streams or events (map row: libcudart).

    Source on GitHub

  5. C5 Sharing and recovery.OPEN · MISSING

    Done when: Two processes on one GPU both get correct results, or the second gets a named refusal and the first is unharmed. A kernel that never ends is timed out and a correct launch then succeeds in the same process.

    Now: One device, one process; a timeout ends GPU use for the process (map row: libcudart).

    Source on GitHub

  6. C6 No NVIDIA tool in the loop.OPEN · MISSING

    Done when: Omega's own sm_121 disassembler agrees with nvdisasm on every library kernel in src/, and every check that called nvdisasm calls ours.

    Now: The tests still call NVIDIA's nvdisasm when it is installed (map row: cuobjdump, nvdisasm).

    Source on GitHub

4 · The rest of “Omega replaces everything”

Beyond the CUDA claim

These are not part of the CUDA claim. They are the rest of what Omega is for, and each has its own bar.

No NVIDIA software at all

Our own GB10 driver replaces nvidia.ko and nvidia-uvm.ko (L332): Omega's golden tokens identical on our driver and on NVIDIA's, with per-word timing. The GSP firmware stays, as above.

Source on GitHub

The runtime written in Omega

The GPU runtime and libraries are C today. The language rule (aien-architecture ADR 0024) keeps C only where hardware, boot, ABI or measurement justifies it, so the runtime moves into Omega once C1 makes that possible.

Source on GitHub

The CPU

The OSC and Omegese backends emit AArch64 machine code today (src/compiler/osc_a64.c). The live server is still a gcc and Rust build linked against glibc; it moves to Omega-compiled code as the language grows.

Source on GitHub

5 · Performance: matching and then beating CUDA

0 of 5 met

Where we stand: at FP8 with one conversation we are level with or ahead of the published CUDA numbers. We are behind on three things: prompt reading (7 to 30 times), many conversations at once (5 to 15 times), and 4-bit weights (not yet live). All three are work, not physics: the ceilings are far from reached.

Same machine (one DGX Spark GB10), same kind of model (a ~30B mixture-of-experts with about 3B active per word). Our numbers are measured by us, with receipts. Everyone else's are published by others and labelled that way, with their source; none of them has been re-measured here yet (bar P0). The table of numbers, with every source, is section 5 of docs/OMEGA.md.

Source on GitHub

Each row PASS needs our receipt and the other system measured by us on this Spark, same model, same prompts, same output length, in the same quiet window.

  1. P0 Measure them ourselves.OPEN · MISSING

    Done when: llama.cpp and vLLM (their own current releases, built for sm_121) run Qwen3.6-35B-A3B at FP8 and at 4-bit on this Spark, one and eight conversations, 512 and 8k prompts, three runs each; table and logs pushed, labelled measured-by-us. Benchmark only: nothing of theirs enters the Omega path.

    Now: None of the other systems' numbers has been re-measured here yet.

    Source on GitHub

  2. P1 One conversation.OPEN · MISSING

    Done when: Omega's best format beats the best measured CUDA number at one conversation, with golden tokens identical to our host reference.

    Source on GitHub

  3. P2 Prompt reading.OPEN · MISSING

    Done when: Omega prefill beats the best measured CUDA number at 512 and 8k.

    Source on GitHub

  4. P3 Many conversations.OPEN · MISSING

    Done when: Omega total words per second beats the best measured CUDA number at 8 and 32 conversations.

    Source on GitHub

  5. P4 What CUDA stacks do not do.OPEN · MISSING

    Done when: At least one measured win that comes from owning the whole path: one submission per word or a resident whole-model kernel, zero-copy use of the shared memory, our own driver's launch path (L332).

    Source on GitHub