Every Joule counts.

Software has no idea
what it costs to run.

Compilers optimize for speed and size. None of them tell you the energy cost of a function call, a memory allocation, or a loop. We optimize for cycles. The grid pays in watts. And computing keeps growing.

Data-center figures follow IEA electricity estimates. Energy accounting is a first-class output of the Joule toolchain.

"You cannot optimize what you cannot measure. No language measured energy at the code level, so no language optimized for it." The blind spot

Joule makes energy
a first-class output.

Write ordinary, readable code. The compiler attributes an energy cost to every function and every operation, then compiles down to C for a fast native binary. The number is part of the build, not an afterthought.

// Every function carries an energy cost.
fn average(readings: [f32]) -> f32 {
    let sum = readings.fold(0.0, |a, x| a + x)
    return sum / readings.len() as f32
}

fn main() {
    let data = [21.4, 22.1, 20.8, 23.5]
    print("avg = {average(data):.2}")
    // receipt: 3.9 µJ  (compute 3.1 · mem 0.6 · io 0.2)
}

The compiler
compiles itself.

Joule's compiler is written in Joule. It compiles its own source to C, builds a new compiler, and that compiler produces a byte-for-byte identical result. A reproducible fixed point is a strong, concrete signal that the language is real and the compiler is stable.

Every build produces an
energy receipt.

An accounting of the energy your program spends, broken down by function, by category, and by target. Not a vibe, a number you can act on.

A broad corpus.
Not a toy.

Over 514 example programs exercise the language across the areas real software is made of. They double as the living test suite: if they stop compiling or running, the build knows.