A native language for concurrent software

Build fast.
Keep the guarantees.

ProScript combines Go-like clarity and concurrency with expressive types, exhaustive pattern matching, and explicit mutation—compiled to native code.

Take the tour See the language

Pre-1.0 · built in the open

load_user.prcompiling

01  fn load_user(id: UserId) Result<User, LoadError> {
02      let profile = spawn find_profile(id);
03      let roles = spawn find_roles(id);
04      return Ok(User {
05          profile: profile.await()?,
06          roles: roles.await()?,
07      });
08  }

01sourcemain.pr✓

02typesResult<User, LoadError>✓

03mirverified · 0 violations✓

04nativearm64 · ready✓

STATICALLY TYPEDGARBAGE COLLECTEDNATIVE CODEGREEN TASKSEXPLICIT MUTATION

THE LANGUAGE

Simple enough to hold in your head.
Strong enough to trust.

ProScript is designed for the code behind your product: servers, APIs, workers, and command-line tools. You get managed memory and a small mental model without giving up expressive domain types.

Enums + exhaustive matching

Make impossible states visible

Model every outcome directly. When the model changes, the compiler shows every branch that needs your attention.

types.prPROSCRIPT

enum CreateUserError {
    InvalidEmail,
    Conflict(UserId, string),
    Storage(DatabaseError),
}

return match create_user(input) {
    Ok(user) => Response::created(user),
    Err(CreateUserError::Conflict(id, reason)) =>
        Response::conflict(id, reason),
    Err(error) => map_error(error),
};

NO BORROW CHECKERManaged memory.

NO ASYNC COLORINGOrdinary functions.

NO HIDDEN MUTATIONVisible authority.

NO SECOND RUNTIMENative all the way down.

CONCURRENCY, BUILT IN

Thousands of tasks.
One readable program.

Spawn ordinary calls into lightweight green tasks. Move typed values through channels. Protect the state that truly needs sharing. The compiler rejects writable caller state crossing a task boundary.

spawnstarts an independent green task
task.await()suspends only the current task
selectcommits exactly one ready operation
Shared<T>contains deliberate shared mutation

runtimesharded schedulerbounded work stealing

worker 01

worker 02

Channel<Event>↔

concurrent non-moving GC coordinates at native safepoints

BUILT FOR THE BACKEND

Business logic should look like business logic.

01 · RECEIVE

Parse once. Carry exact types forward.

JSON decoding, enums, options, and results keep invalid input out of the core of your program.

02 · COORDINATE

Run independent work concurrently.

Green tasks and typed channels express coordination without futures, promises, or colored function signatures.

03 · RESPOND

Handle every outcome explicitly.

Exhaustive matches make error paths part of the design rather than an afterthought.

DESIGNED WITH TASTE, NOT TRADITION

Learn from what works.
Keep one coherent language.

ProScript is not a Go superset, a Rust replacement, or Gleam on a different runtime. It takes lessons from languages developers already love and resolves them around one goal: reliable concurrent software without a systems-language tax.

01 · directness

Go

Concurrency and garbage collection should feel built in, not bolted on.

official site ↗02 · confidence

Rust

A rich type system can prevent whole categories of bugs before execution.

official site ↗03 · clarity

Gleam

Type-safe concurrent systems can still be friendly and approachable.

official site ↗04 · iteration

JavaScript

Fast feedback and expressive application code keep developers in flow.

official site ↗

THE PLAYGROUND

Read less.
Run something.

Edit real ProScript and execute it with the native Linux compiler. Every run happens in a disposable, network-isolated sandbox with strict resource limits.

main.pr25 lines

package main

import std.fmt

enum JobState {
    Queued(int),
    Running,
    Complete(string),
}

fn describe(state: JobState) string {
    return match state {
        JobState::Queued(position) => {
            let value = fmt.display(position);
            "queued at position ${value}"
        },
        JobState::Running => "running",
        JobState::Complete(result) => result,
    };
}

fn main() {
    fmt.println(describe(JobState::Queued(3)));
    return;
}

OUTPUT

Preparing the ProScript playground…

disposable sandboxno networkbounded execution

FROM SOURCE TO NATIVE

The fast path is also the verified path.

The compiler does not execute its own unchecked assumptions. Every major representation gains evidence before the next phase can consume it.

01Sourcelossless syntax

→

02Typed HIRexact semantics

→

03Native MIRindependently verified

→

04Machine codeCranelift

→

05Productauthenticated + loaded

~/hello-proscript

$ proscript init acme.hello
created proscript.toml

$ proscript check .
✓ program is valid

$ proscript run .
Hello from ProScript

$ proscript test .
3 passed · 0 failed

A COMPLETE TOOLCHAIN

One language.
One way to work.

The compiler, formatter, test runner, package workflow, diagnostics, and language server are developed together. A feature is not complete until every surface agrees.

proscript checkproscript runproscript testproscript fmtproscript packageproscript-lsp

PROSCRIPT · PRE-1.0

Your server language should help you think.

Explore the syntax, follow the compiler, and help shape a language built for clear, concurrent software.

Start the tour Follow development

Build fast.Keep the guarantees.

Simple enough to hold in your head.Strong enough to trust.