Unified Compute Language

One language for
intelligent & trustless
compute.

DEXA is a statically typed, deterministic language being built to target GPU kernels, native binaries, and contract VMs — without Python’s runtime overhead or Solidity’s security traps. The current prototype focuses on a small, typechecked core and an interpreter that runs real programs.

Get Started Language Tour View on GitHub

Targets

CPU · GPU · WASM · DX-VM

Domains

AI / ML · Smart Contracts · Secure Compute

Core values

Deterministic · Safe · Fast

example.dexa

AI + Contracts

// Model definition
model Classifier {
    layer conv1 = Conv2D(3, 32, kernel=3)
    layer relu1 = ReLU()
    layer dense = Dense(128, 10)

    fn forward(x: tensor<float,3x224x224>) -> tensor<float,10> {
        let h = relu1(conv1(x))
        return dense(h)
    }
}

// Contract consuming model output
contract RewardPool {
    asset<Token> pool

    fn reward(user: Address, score: int) {
        require(score > 0)
        let amount: Token = policy.reward_for(score)
        pool -= amount
        transfer(user, amount)
    }
}

Why DEXA exists

Today’s compute stack is split and fragile. AI runs on Python glued to C++ and CUDA. Smart contracts run on Solidity glued to unsafe VMs. Every layer adds risk, latency, and undefined behaviour. DEXA replaces this with one language, one toolchain, and one mental model.

AI / ML

Python without the bottlenecks

High-level syntax, tensor-native types, and compiler-level autograd — but compiled and optimized, not interpreted.

Contracts

Fundamentally safe smart contracts

Asset types, deterministic execution, and structural rules make reentrancy and asset-loss bugs impossible by design.

Runtime

Deterministic compute core

Actor-based concurrency, no undefined behaviour, and a locked-down subset for verifiable, on-chain workloads.

AI / ML without Python’s ceiling

DEXA gives you the expressiveness of a dynamic language in a compiled, statically typed environment. Write models at a high level; the compiler generates optimized tensor graphs and GPU kernels.

• First-class tensor<T, shape> types.
• Compiler-level autograd and graph optimisation.
• Planned support for CUDA, Metal, and Vulkan backends.
• No GIL, no interpreter, no ad-hoc bindings.

Early implementations may target a single GPU backend before expanding to others.

Example · Model definition

model Encoder {
    layer conv = Conv2D(3, 64, kernel=3, stride=2)
    layer norm = LayerNorm(64)
    layer act  = GELU()

    fn forward(x: tensor<float,3x256x256>) -> tensor<float,64x64x64> {
        let h = conv(x)
        h = norm(h)
        return act(h)
    }
}

Example · Asset-safe contract

contract Vault {
    asset<Token> balance

    fn deposit(amount: Token) {
        balance += amount
    }

    fn withdraw(to: Address, amount: Token) {
        require(balance >= amount)
        balance -= amount
        transfer(to, amount)
    }
}

Smart contracts that don’t bleed money

Most exploited contracts are symptoms of language and runtime design, not just developer mistakes. DEXA’s contract subset encodes safety directly into the type system and execution model.

• Asset types enforce conservation and prevent cloning.
• No unstructured external calls or reentrancy.
• Deterministic DX-VM with predictable cost.
• Hooks for static analysis and formal verification.

Architecture at a glance

DEXA compiles through a shared intermediate representation into multiple specialised backends. The same source can target native binaries, GPUs, or deterministic virtual machines.

Frontend

Language core

Lexer & parser
Static type checker
Ownership & asset rules
Deterministic mode flags

DX-IR

Tensors & operators
Actors & messages
Contract storage layout
Optimisation passes

Backends

Targets

LLVM (native)
GPU kernels
DX-VM bytecode
WASM (planned)

Roadmap

The language will ship in phases: first a stable core and CPU backend, then GPU and contract backends, then the broader ecosystem and tooling.

Phase 0.x

Core & CPU

Language spec & parser
Static type system
LLVM backend + CLI
Minimal stdlib

Phase 0.4–0.6

GPU & DX-VM

Tensor IR & GPU kernels
Deterministic DX-VM
Contract subset & asset types
Basic verification hooks

Phase 0.7–1.0

Ecosystem

Package manager & registry
Testing & property checks
Playground & docs site
Stabilisation & 1.0 release

Start shaping DEXA

DEXA is early and deliberately uncompromising. If you care about performance, determinism, and language design, this is the moment to get involved — before everything is locked in.

Questions or collaboration? Reach DX directly on Discord or Telegram.

GitHub Repository Sponsor Development

One language for intelligent & trustless compute.