AI-first compiler

Programs as
meaning,
not syntax.

Name: DUUMBI
Author: DUUMBI

DUUMBI compiles semantic graphs — programs expressed in JSON-LD — directly to native code via Cranelift. No text. No parsing. Pure structure.

Get started → Read the docs

JSON-LD Graph format

Rust Core runtime

1000+ Tests passing

main.jsonld

{
  "@context": "https://duumbi.dev/ctx",
  "@type": "duumbi:Function",
  "@id": "fn:add",
  "params": ["x", "y"],
  "body": { "@type": "duumbi:Add",
    "lhs": "x", "rhs": "y" }
}

Graph-native IR

Programs are JSON-LD graphs. No parser, no tokenizer — structure is the source of truth.

Native output

Cranelift backend produces optimised native machine code — no VM, no interpreted layer.

Semantic types

Every node carries meaning via linked-data vocabulary. Types are URIs, not identifiers.

AI-composable

Graph programs are trivially generated, merged, and refactored by language models.

Showcases

See it in action

Three programs built entirely by AI — from intent description to running native binary.

$ duumbi intent create "build a calculator with add, sub, mul"

Graph

{
  "@type": "duumbi:Function",
  "@id": "fn:add",
  "params": [
    { "name": "a", "type": "i64" },
    { "name": "b", "type": "i64" }
  ],
  "body": [{
    "@type": "duumbi:Return",
    "value": {
      "@type": "duumbi:Add",
      "left": "a", "right": "b"
    }
  }]
}

$ duumbi intent execute calculator
  ✓ Created module calculator/ops
  ✓ Added function add(a: i64, b: i64) → i64
  ✓ Added function sub(a: i64, b: i64) → i64
  ✓ Added function mul(a: i64, b: i64) → i64
  ✓ Modified main — calls add(10, 5)
  ✓ Verifier: add(10, 5) = 15 ✓

$ duumbi build && ./output
  15

$ duumbi add "create a fibonacci function"

Graph

{
  "@type": "duumbi:Function",
  "@id": "fn:fibonacci",
  "params": [{ "name": "n", "type": "i64" }],
  "body": [{
    "@type": "duumbi:Branch",
    "condition": {
      "@type": "duumbi:Compare",
      "op": "le", "left": "n",
      "right": { "@type": "duumbi:Const", "value": 1 }
    },
    "then": [{ "@type": "duumbi:Return", "value": "n" }],
    "else": [{
      "@type": "duumbi:Return",
      "value": {
        "@type": "duumbi:Add",
        "left": { "@type": "duumbi:Call",
          "fn": "fibonacci", "args": [
            { "@type": "duumbi:Sub",
              "left": "n", "right": 1 }]},
        "right": { "@type": "duumbi:Call",
          "fn": "fibonacci", "args": [
            { "@type": "duumbi:Sub",
              "left": "n", "right": 2 }]}
  }}]}]
}

$ duumbi add "create a fibonacci function"
  ✓ AI generated fibonacci(n: i64) → i64
  ✓ Graph validated, 8 nodes, 0 errors

$ duumbi build && ./output 10
  55

$ duumbi intent create "build a traffic light state machine"

Graph

{
  "@type": "duumbi:Module",
  "@id": "mod:traffic",
  "functions": [{
    "@type": "duumbi:Function",
    "@id": "fn:next_state",
    "params": [{ "name": "state", "type": "i64" }],
    "body": [{
      "@type": "duumbi:Match",
      "value": "state",
      "arms": [
        { "pattern": 0, "body": {
          "@type": "duumbi:Const", "value": 1 }},
        { "pattern": 1, "body": {
          "@type": "duumbi:Const", "value": 2 }},
        { "pattern": 2, "body": {
          "@type": "duumbi:Const", "value": 0 }}
      ]
    }]
  }]
}

$ duumbi intent execute traffic-light
  ✓ Created module traffic/states
  ✓ Created module traffic/transitions
  ✓ Added fn next_state(state: i64) → i64
  ✓ Modified main — cycles through states
  ✓ Verifier: Green→Yellow→Red→Green ✓

$ duumbi build && ./output
  Green → Yellow → Red → Green

Architecture

From graph to native binary

Four stages transform a JSON-LD semantic graph into an optimized native executable. AI mutates the graph at any point — the compiler validates every change.

Parse

JSON-LD source files loaded and deserialized via serde_json into a typed AST.

Graph

AST nodes inserted into a petgraph StableGraph. Schema validation and type checking.

Lower

Graph nodes translated to Cranelift IR. One function per subgraph, SSA form.

Link

Object file emitted, linked with C runtime via cc. Native binary output.

Quick start

Running in 60 seconds

Install, create a project, let AI build your first program.

Install

$ cargo install duumbi

Create a project

$ duumbi init myproject
$ cd myproject

Build with AI

$ duumbi add "create a fibonacci function"
✓ AI generated fibonacci(n: i64) -> i64
$ duumbi build && ./output
55

Full documentation → View source

Programs asmeaning,not syntax.

Graph-native IR

Native output

Semantic types

AI-composable

See it in action

From graph to native binary

Parse

Graph

Lower

Link

Running in 60 seconds

Install

Create a project

Build with AI

Programs as
meaning,
not syntax.