Prismio is a statically typed systems programming language that compiles to native machine code through LLVM. Its experimental Adaptive Inference Framework analyzes where values live and explains each decision.
$curl -fsSL https://prismio.org/install.sh | sh1struct Point {2x: Int,3y: Int4}56fn sumLocal() -> Int {7let point = Point { x: 3, y: 4 }8return point.x + point.y9}
The maintained suite contains 78 canonical workloads across 6 categories. 63 run equivalent Prismio, C++, and Rust implementations with checksum validation and median timing. The other 15 are published as unsupported capabilities rather than hidden behind benchmark-only substitutes.
Geometric mean of the time ratio across 62 workloads. Lower is faster.
20 faster · 39 parity · 3 slower
Geometric mean of the time ratio across 62 workloads. Lower is faster.
24 faster · 34 parity · 4 slower
Featured medians are from the latest checked-in 5-run result set (08 Oct 2026). Results vary by machine and toolchain.
The Adaptive Inference Framework is experimental in 0.1. It analyzes escape behavior, ownership, thread transfer, and layout before code generation. It chooses a safe placement and produces evidence for the decision.
Inference is not a black box when its output affects performance.
See every potential allocation site grouped by stack, compiler-placed arena, owned heap, shared heap, cycle management, and thread transfer.
$prismio aif main.psmStorage planStack 1Arena 0Unique heap 0Cross-thread heap 0
Trace the minimal cause of one placement and see which repairs are valid—and which would contradict facts already proven by the analysis.
$prismio aif main.psm --why=1Allocation 1Location main.psm:7:23Type PointStorage stackReason small value does not escape
Run the real binary against verifier shims that report allocations, releases, leaks, and invalid releases without changing the program’s code generation decisions.
$prismio build main.psm --verify
Use --manifest to create a diffable record for CI.
Prismio combines modern static abstraction with explicit systems boundaries: native code, visible mutability, direct foreign calls, specialized generics, and programmer-directed layout where it matters.
Structs, recursive enums, pattern matching, closures, overloaded methods, bounded generics, traits, associated types, default methods, impl Trait, and explicit dyn Trait objects are part of the shipped language surface.
Generic functions and types are specialized for the concrete programs that use them. Storing or returning a closure is not supported yet.
Experimental spawn and join run work on native OS threads. Typed blocking Channel<T> values move messages between workers, while c.share() makes endpoint sharing explicit.
There is no async/await, atomics, or locks in 0.1, and no work-stealing executor.
Flat values can live inline inside Vec<T>, and Slice<T> provides bounded views. Experimental soa and aos conversions give explicit structure-of-arrays access through checked DataView<T>.
The compiler specializes the element type before choosing its container representation.
Strings, vectors, maps, options, results, iterators, files, processes, ordering, equality, and display live in ordinary std.* modules, apart from a small built-in core such as Vec’s push and indexing. There is no prelude pulling unused facilities into a program.
Import only the behavior the program intends to carry.
Prismio’s compiler, project model, native linkage, diagnostics, and memory analysis form one development loop. The lexer, parser, import resolver, semantic analyzer, AIF engine, and LLVM IR generator are themselves written in Prismio. The runtime and the LLVM bridge are C.
build.ums declares project metadata, executable and test targets, dependencies, native link inputs, and project-defined commands. Prismio finds the nearest manifest and writes profile-specific artifacts under .prismio/build/.
1project {2name = "xefy"3version = "0.1.0"4prismio = "0.1.0"5license = "Apache-2.0"6}78targets {9executable("xefy") {10entry = "src/main.psm"11}12}1314commands {15command("verify") {16description = "Acceptance gate"17test("xefy")18}19}
A release seed builds the first local generation. Later generations compile themselves, and the build checks that the compiler reproduces its own output.
Declare C functions with extern fn. Ownership contracts such as borrow, consume, produce, and alias keep the foreign boundary visible to memory analysis.
Tools consume structured compiler output instead of scraping terminal prose.
prismio check runs the real frontend without generating code. JSON Lines diagnostics carry P#### codes, severity, files, and UTF-8 source spans. The codes are not stable yet and can change before 1.0.
-g emits DWARF line tables, functions, scopes, locals, and struct layouts for LLDB and GDB. On macOS, the compiler writes a .dSYM beside the binary.
dump-ast exposes parsed source structure. AIF manifests provide a separate, diffable account of inferred memory placement for CI and analysis tools.
Official Prismio support for IntelliJ IDEA, CLion, and other JetBrains IDEs.
Official Prismio support for IntelliJ IDEA, CLion, and the other JetBrains IDEs.
In your IDE open Settings → Plugins → Marketplace, search for
then press Install and restart the IDE if asked.
Prismio is developed openly as an independent systems language project, with no proprietary layers. Development is sustained through technical contributions and infrastructure sponsorship.
Prismio v0.1 is in active development. It self-hosts, emits native binaries, runs its project workflow, and ships the core language, memory analysis, standard containers, file and process APIs, native tasks, and typed channels.
Install Prismio, run an example, and ask AIF where each value lives and why. The compiler, standard library, benchmark suite, and design evidence are open for inspection.
Short answers about what Prismio is today. The documentation has the full detail.