Build products, not plumbing
One language for servers, native interfaces, browsers and GPU code.
A systems language for making things
Dia
Maximum productivity.
No performance ceiling.
A statically compiled language for building native, web, and GPU-powered software with safe ownership, first-class C interoperability, reactive UI, and state-preserving hot reload.
Pre-alpha — under active development
01 / EXECUTION
A language shaped around the work.
import ui.{View, run, Column, Text, Button, state}
struct CounterState {
value: i32
}
fn Counter(): View {
let s = state(CounterState{ value: 0 })
<Column spacing=12>
<Text>"Count: ${s.value}"</Text>
<Button
label="Increment"
on_click=() => { s.value += 1 }
/>
</Column>
}
pub fn main(): void !{alloc, io} {
run(() => <Counter />)
}
Representative Dia syntax. The reactive UI implementation is currently under active development.
Compiler surface / evolving
02 / PRINCIPLES
The system, not just the syntax.
Native without lifetime annotations
Safe ownership using owning pointers, second-class borrows and arenas for cyclic structures. No tracing GC.
Use the existing world
Import real C headers directly. Manifests add ownership, errors and safety contracts without redeclaring the ABI.
Stay in flow
Incremental compilation, editor-oriented checking and state-preserving native hot reload are architectural features.
03 / STATUS
Current status
Dia is a pre-alpha research implementation. The compiler already has native and WebAssembly code generation, C-header interoperability, ownership checking, structured concurrency and an executable reactive runtime. The standard library, UI renderer and developer tooling are still being built.
It is not ready for production use yet.
04 / LOG
Latest development note
Building state-preserving hot reload for a statically compiled native language
Compiler architecture · Incremental systems