Every Joule Counts.

Systems software has
no idea what it costs to run.

C, C++, Zig, and Rust produce fast binaries. But none of them tell you the energy cost of a function call, a memory allocation, or a loop iteration. You optimize for cycles. The planet pays in watts.

"You can't optimize what you can't measure. No systems language measures energy. So no systems language optimizes for it." The blind spot

Joule makes energy
a first-class citizen.

Every function carries an energy signature. Every allocation is metered. The compiler knows the cost before the code ever runs.

use energy::{Budget, Receipt};
use io::stdout;

// Energy budget: 50 microjoules max
#[energy_budget(50_uJ)]
fn process_sensor_data(readings: &[f32]) -> Receipt {
    let avg = readings.iter()
        .sum::<f32>() / readings.len() as f32;

    stdout.write_line("avg: {avg:.2} pJ");

    // Compiler rejects if this exceeds 50 uJ
    Budget::receipt()
}

Not tested.
Proven.

The Joule compiler is formally verified using bounded model checking. Critical subsystems are proven correct for all possible inputs — not sampled, not tested, proven.

Every build produces an
energy receipt.

Not an estimate. Not a benchmark. An exact accounting of the energy your program will consume, broken down by function, module, and hardware target.

175 crates.
One compiler.