LukeLang

Build native binaries and WASM from one codebase

LukeLang

mimo install · compile to C · ship anywhere

A reactive-native, full-stack language that compiles to native C and WebAssembly. One dependency graph from database row to screen pixel.

Start learning Download
LukeLang mark
Syntax v2 Native C · WebAssembly Designed & developed by Kaung Myat San
01

One graph,
end to end.

Mainstream stacks glue three worlds together with fetch, cache invalidation, subscriptions and diffing. LukeLang keeps one dependency graph that the compiler can see — so change travels on its own.

  1. Database rowUPDATE users …
  2. Server cellwatch user from db
  3. Wirepush watch user on req
  4. Client cellwatch user from "/watch"
  5. Pixelbind("name", user)

You never fetch.

You never invalidate.

You never subscribe.

You never diff.

You declare the dependency once — and exactly 1 region paints.

02

Reads like intent.
Runs like C.

Typed Build mode, arena memory, and no garbage collector on the ship path. The same source targets a native binary or the browser. 

print("Hello from Luke Build")
let name = "Luke"
print("My name is " + name)

fn add(a: float, b: float) -> float {
  return a + b
}

print(add(21, 21))  // 42 — native code, arena memory
signal price = 100
signal quantity = 3
derived total = price * quantity

effect on total {
  print("total=" + total)
}

price = 200          // total=600, one flush
batch {
  price = 120
  quantity = 5       // still one flush
}
import std/server
import std/sqlite

let db = dbOpen("/tmp/luke_live_graph.db")
watch user from db where "id = 1"

let server = httpListen(8798)
let req = httpAccept(server)

push watch user on req for 50 beats every 50 ms
import std/js

signal user = ""
bind("name", user)
watch user from "http://127.0.0.1:8798/watch"

// external UPDATE → one push → one write → one region paints
effect on user {
  print("region=" + region_paint_count)
}
03

Engineered, not assembled.

0
garbage collectors on the ship path — arena memory, freed at scope
1
dependency graph carries every change from row to pixel
10K
concurrent connections — event-loop I/O, keep-alive, REUSEPORT
2
compile targets from one source — native C and WebAssembly
04

What the language believes.

  1. Write like you talk. Ship like systems. The surface stays readable; the compiler keeps the guarantees.
  2. Build is the language of record. Types, layouts and arenas are decided at compile time, not guessed at runtime.
  3. The browser is the renderer. Compile to DOM and CSS; patch surgically, never repaint the world.
  4. One beachhead. Win reactive full-stack first. Everything else is earned later.
05

Three lines to your first binary.

git clone https://github.com/lucasdmarshall/LukeLang.git
cd LukeLang/vm && make
./build/luke BUILD ../examples/build/hello.luke -o hello && ./hello
Learn the language Download & requirements Documentation Examples