[ DEXA ]
One language for
intelligent & trustless compute.
Language for the DXA stack (.dxa files, dxc compiler on dxa.dev).
Targeting GPU kernels, native binaries, and contract VMs — without Python's overhead or Solidity's traps. A small, typechecked core you can run today.
Targets: CPU · GPU · WASM · DX-VM │ Domains: AI/ML · Smart contracts · Secure compute │ Core: Deterministic · Safe · Fast
[ RUNS TODAY ]
model Wallet {
owner: address;
balance: int;
}
fn credit(w: Wallet, amount: int) -> Wallet {
require(amount > 0, "amount must be positive");
return Wallet { owner: w.owner, balance: w.balance + amount };
}
fn main() -> int {
let w: Wallet = Wallet { owner: address("addr:debug"), balance: 0 };
let w2: Wallet = credit(w, 5);
print(w2);
return w2.balance;
}[ WHY DEXA ]
Today's compute stack is split and fragile. AI runs on Python glued to native code and GPU toolchains. Smart contracts run on Solidity glued to VM semantics that are hard to reason about. This project collapses that stack into one language and one set of deterministic semantics — starting with a small core you can execute and test.
AI / ML
High-level, compiled ML (goal)
Tensor-native types, graph lowering, GPU codegen — planned on top of the deterministic core. Design preview.
CONTRACTS
Safer contract subset (goal)
Asset-aware types, deterministic execution, restricted semantics. Design preview.
RUNTIME
Deterministic core (implemented)
Typechecked core with explicit semantics. Structured results: value, prints, trace, gas.
[ WHERE IT FITS ]
DEXA vs Python
Typed, deterministic core with gas + trace instead of dynamic scripts glued to native/GPU code. Goal: Python-level ergonomics, compiler-level guarantees.
DEXA vs Solidity
Same determinism and gas mindset, but designed for general compute and future DX-VM backends — not only EVM contracts.
DEXA vs Rust
Rust is the implementation language; DEXA is a constrained, deterministic language that can target multiple runtimes (interpreter today, LLVM / GPU / VM later).
[ ARCHITECTURE ]
Same source → shared IR → multiple backends. Native, GPU, or VM when those exist.
Early interpreter today. LLVM, GPU, and DX-VM backends planned once the core semantics are fully locked.
FRONTEND
Language core
Lexer & parser, type checker, nominal records, deterministic semantics.
IR
DX-IR
Locals, blocks, calls, control flow, trace + gas, ProgramResult.
BACKENDS
Targets
Interpreter (today). LLVM, GPU, DX-VM (planned).
[ BENCHMARKS (EARLY) ]
Early interpreter-only microbenchmark on a typical laptop: vector add over 1k ints in a tight loop, averaged over many runs.
# vector_add_1k.dxa — microbenchmark (indicative only)
# machine: typical laptop, release builds, averaged over many runs
DEXA (interpreter): ~1.2 ms
Rust (native): ~0.9 ms
Python 3.11: ~9.5 ms[ ROADMAP ]
PHASE 0.x
Core (implemented)
Lexer & parser, typechecker, nominal records + address, DX-IR + interpreter.
NEXT
Tooling
Diagnostics, arrays/slices, CLI JSON, minimal stdlib.
LATER
Backends
LLVM, tensor + GPU, contract subset + DX-VM.
[ START SHAPING DEXA ]
Early and deliberately uncompromising. If you care about performance, determinism, and language design — this is the moment.