A systems language where the compiler places your memory and shows its work.
Prismio is a statically typed language that compiles to native code through LLVM. Instead of lifetime annotations or a tracing collector, the compiler infers where each allocation should live, and prismio aif --why explains every decision it makes.
Why the world needed another systems language.
For decades, systems engineers have been trapped in a triangle of compromises:
Unbounded Memory Risk
Fast and raw, but fraught with use-after-free, memory leaks, and buffer overflows that continue to represent over 70% of reported high-severity vulnerabilities in systems infrastructure.
Borrow Checker Friction
Affine types deliver memory safety, but fighting lifetime annotations, tricky borrow-checker rules, and graph/cyclic data architectures imposes steep cognitive fatigue and slows iteration cycles.
Unpredictable Tail Latency
High developer ergonomics, but stop-the-world collectors, runtime cache thrashing, and high memory multipliers make them unsuitable for real-time audio, embedded systems, and hyper-dense server loops.
Inference replaces annotation bureaucracy.
Instead of forcing you to annotate every reference lifetime or suffer garbage collector pauses, Prismio uses compiler-proven escape and ownership analysis to place data in the cheapest safe tier automatically—and lets you audit every decision with verifiable manifests.
What it does today.
Adaptive Inference Framework
Experimental. The compiler classifies each allocation site as stack, region, unique, reference-counted, or cycle-aware storage, and enforces moves and borrows for move-only values. You don't annotate lifetimes. To see why a site landed where it did: prismio aif main.psm --why=1.
Native code through LLVM
The typed AST lowers to LLVM IR and links with the platform toolchain. -g emits DWARF debug information, --target cross-compiles, and --freestanding builds programs that need no operating system.
Async, native threads and channels
async fn returns a Future<T>, scope { } and spawn { } start tasks that must finish together, and blocking Channel<T> values pass messages between them. A task is still an OS thread; there is no scheduler yet.
Direct C ABI calls
extern fn binds straight to C symbols. Prismio doesn't read headers or generate bindings, so you declare each function yourself, and anything with an uncertain layout (a String, for example) goes through a small C adapter.
What it doesn't do yet.
If you need any of these, v0.2.0 isn't ready for you.
- An
awaitthat gives its thread back, and a work-stealing scheduler - Mutexes, condition variables, and safe atomic types (raw pointer atomics exist in
std.raw) - Task cancellation and timeouts
- A stable AIF tier contract. The meaning and cost of each tier can still change
- Stable diagnostic codes
- A formally proven borrow checker
How it's run.
Prismio is open source and developed in the open. These are the terms the project runs on.
- Apache-2.0
- The compiler, standard library, and benchmark suite are all open source.
- Issue first
- Large changes start as a GitHub issue before any code is written.
- Losses get published
- Benchmarks compare identical algorithms against C++ and Rust and report medians, including the ones Prismio loses.
Ready to explore the next generation of systems code?
Read the complete language guide, test your code in our interactive playground, or install Prismio on your machine in seconds.