Serious performance.Friendly design.

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.

Install Prismio
$curl -fsSL https://prismio.org/install.sh | sh
Platforms
macOSLinuxWindows
Backend
LLVM 23 AOT + JIT
Interop
Direct C ABI
main.psm
1struct Point {
2 x: Int,
3 y: Int
4}
5
6fn sumLocal() -> Int {
7 let point = Point { x: 3, y: 4 }
8 return point.x + point.y
9}
$ prismio aif main.psm
Storage plan
Stack1Arena0Unique heap0Scoped heap0Shared heap0Cycle-managed heap0Cross-thread heap0
Your code
ID1Locationmain.psm:7:23TypePointStoragestack
Reason
small value does not escape
0 warnings·0 errors

0.2.0 · 10 November 2026

What’s new in 0.2.

The language reaches async code and bare metal, and the compiler now serves editors itself.

Read the release notes
  • Async and scoped tasks

    async fn, Future<T> and await, with scope { } and spawn { } so a scope cannot end while a task it started is still running.

  • A language server and a formatter

    prismio lsp and prismio fmt are part of the compiler, so an editor, a CI check and the command line agree on one answer.

  • Down to the metal

    Freestanding builds, std.syscall, and linux { }, macos { } and windows { } blocks reach kernels and bare-metal targets.

  • Integers of any width

    Int<N> and UInt<N> from 1 to 8,388,608 bits, five float types, and an index out of range now stops the program.

  • A larger standard library

    std.json, HashSet, token and byte input, std.poll for serving a client while supervising a child, and sizeOf and offsetOf for C layouts.

  • A smaller language to learn

    T? replaces Option<T>, HashMap replaces Map, and conditions need no parentheses. Breaking changes are listed in the release notes.

Performance claims with receipts.

The maintained suite contains 86 canonical workloads across 6 categories. 71 run equivalent Prismio, C++, and Rust implementations with checksum validation and median timing. The other 15 are listed as not measured yet, each with its reason, rather than hidden behind benchmark-only substitutes.

vs C++Clang++ -O3
0.81×19.2% faster

Geometric mean of the time ratio across 70 workloads. Lower is faster.

29 faster · 39 parity · 2 slower

vs Rustrustc opt-level 3
0.79×20.9% faster

Geometric mean of the time ratio across 70 workloads. Lower is faster.

30 faster · 34 parity · 6 slower

Implemented
71
Not measured
15
  • Each workload is written to express the same algorithm in all three languages and must produce the same checksum. Known differences are listed in the suite’s README. Fixtures are created outside the timed region.
  • Missing standard-library capabilities remain visible in the catalog instead of being replaced with private benchmark implementations.

Featured medians are from the latest checked-in 5-run result set (10 Nov 2026). Results vary by machine and toolchain.

Memory decisions you can inspect, diff, and verify.

The Adaptive Inference Framework is experimental in 0.2. 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.

T0–T4b
Graded storage tiers, not one allocation strategy. What each tier means can still change.
1.2 Draft
The current AIF policy. It is not a stable contract between compilers.
  1. Inspect the storage plan

    See every potential allocation site grouped by stack, compiler-placed arena, owned heap, shared heap, cycle management, and thread transfer.

    $prismio aif main.psm
    Storage plan
    Stack 1
    Arena 0
    Unique heap 0
    Cross-thread heap 0
  2. Ask why a decision was made

    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=1
    Allocation 1
    Location main.psm:7:23
    Type Point
    Storage stack
    Reason small value does not escape
  3. Check the emitted program

    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.

High-level expression.Systems-level control.

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.

Modern types, specialized at compile time

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.

Async code and ownership-aware concurrency

An async fn returns a Future<T> and await runs it. scope { } and spawn { } start tasks that must finish before the scope ends. Typed blocking Channel<T> values move messages between workers, while c.share() makes endpoint sharing explicit.

A task is still a native OS thread, and await blocks its thread when the task runs elsewhere. There are no mutexes and no work-stealing executor yet.

Layout control for real hot loops

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>. Int<N> and UInt<N> are integers of exactly N bits.

The compiler specializes the element type before choosing its container representation.

Down to the metal

A freestanding build links no C library and no startup files, so a kernel or a boot image can be written in Prismio. std.syscall reaches the kernel directly, linux { }, macos { } and windows { } blocks choose code per target, and sizeOf and offsetOf match C’s layouts.

A freestanding program supplies its own allocator. Modules that need an operating system, such as std.fs and std.process, are not available.

A small, explicit standard surface

Strings, vectors, maps, sets, optionals, results, iterators, files, processes, JSON, ordering, and equality 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.

One toolchain, from source file to self-hosted project.

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.

Unified Manifest System

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/.

build.ums
manifest
1project {
2 name = "xefy"
3 version = "0.1.0"
4 prismio = "0.2.0"
5 license = "Apache-2.0"
6}
7
8targets {
9 executable("xefy") {
10 entry = "src/main.psm"
11 }
12}
13
14commands {
15 command("verify") {
16 description = "Acceptance gate"
17 test("xefy")
18 }
19}

Self-hosted by design

A release seed builds the first local generation. Later generations compile themselves, and the build checks that the compiler reproduces its own output.

Direct C interoperability

Declare C functions with extern fn. Ownership contracts such as borrow, consume, produce, and alias keep the foreign boundary visible to memory analysis.

Reliable interfaces for editors, CI, and coding agents.

Tools consume structured compiler output instead of scraping terminal prose.

Structured diagnostics

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.

Language server and formatter

prismio lsp speaks LSP 3.17 and reports the compiler’s own P#### diagnostics, with hover, go to definition, completion, and semantic tokens. prismio fmt --check gives CI the formatting an editor applies.

Native debugging

-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.

Compiler introspection

dump-ast exposes parsed source structure. AIF manifests provide a separate, diffable account of inferred memory placement for CI and analysis tools.

Editor support

The compiler ships its own language server, so any editor can get errors as you type, completion, hover, and go to definition. VS Code and the JetBrains IDEs have official extensions.

Official Prismio support for IntelliJ IDEA, CLion, and the other JetBrains IDEs, live on the Marketplace.

Recommended

  • IntelliJ IDEA
  • CLion

Also compatible

  • PyCharm
  • WebStorm
  • GoLand
  • RustRover
  • Rider
  • PhpStorm
  • RubyMine
  • DataGrip

A JetBrains IDE 2026.2 or newer, Prismio 0.2.0 or newer.

  • Syntax highlighting for .psm files and build.ums manifests
  • Completion that knows the type in front of the dot, with imports added for you
  • Compiler errors as you type, with a quick fix for a missing import
  • Go to declaration, find usages, and rename
  • Formatting, folding, brace matching, and live templates
  • Run, build, and test from the gutter and the run menu

In your IDE open Settings → Plugins → Marketplace and search for

Prismio

Press Install, and restart the IDE if asked.

Developed in the open.

Prismio is developed openly as an independent systems language project, with no proprietary layers. Development is sustained through technical contributions and infrastructure sponsorship.

License
Apache-2.0
Development
In the open on GitHub
CI
Linux, macOS, Windows

Next release

0.3.0 is planned for

Releases follow the work, so the date is where the project is aiming, not a contract. Progress is public: every change lands on GitHub, and the release notes list what shipped.

Status
Planned. Nothing in 0.3.0 has been announced yet.
The date
A target, not a promise. If it moves, this page says so.
Scope
Set by the open issues and the “Not yet” list on the roadmap.

A working compiler with a deliberately unfinished ecosystem.

Prismio v0.2 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, async functions, typed channels, and a language server.

Available today

  • Self-hosted native compiler
  • Experimental AIF storage plans and runtime verification
  • Generics, traits, closures, enums, and pattern matching
  • Vectors (Vec<T>), maps, sets, slices, files, processes, and JSON
  • async/await, scoped tasks, and typed blocking channels
  • A language server and formatter built into the compiler
  • Freestanding builds and direct system calls
  • UMS projects, native linking, JSON diagnostics, and DWARF

Not yet supported

  • Networking and an executor that suspends tasks
  • Regex
  • Mutexes, safe atomic types, and work-stealing pools
  • Reflection, derive generation, and explicit SIMD types
  • Memory-mapped files and custom container allocators

Build a program. Inspect what the compiler decided.

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.

Frequently asked questions

Short answers about what Prismio is today. The documentation has the full detail.