00 / A language in active development

Simple by nature.
Powerful by design.

Pop keeps code light, readable, and familiar—then gives every value a real type and every program a predictable native foundation.

Read the Pop Book Explore the source

pop Native · strongly typed · Luau-inspired

hello.popPOP

namespace Hellofunction main()    local release = "0.1.0-rc.3"    print(`🫧 Hello from Pop {release}!`)    print("Strong types. Native code. Small syntax.")end

Static without the noisePortable by architectureData firstNo dynamic fallbackTyped failuresStatic without the noisePortable by architectureData firstNo dynamic fallbackTyped failures

01 / Why Pop?

Nothing hiding
behind the syntax.

Lightweight languages often move complexity into the runtime. Pop makes a different trade: a small surface with explicit semantics that developers, editors, and compilers can all agree on.

Tour the language

Static, not noisy

Local inference keeps declarations short. There is no any or dynamic escape hatch underneath them.

scores.popPOP

namespace Scoresfunction main()    local score = 10    print(score)end

Real language shapes

Records are records. Classes are classes. Arrays, tables, modules, and namespaces keep distinct, dependable meanings.

player.popPOP

public record Player    name: String    score: Int = 0end

States must be handled

Tagged unions make every state visible. Exhaustive matching keeps new cases from slipping past callers.

search-result.popPOP

public union SearchResult    Found(value: String)    Missingend

Performance, by design

Simplicity with the performance of C, D, and Rust. Pop is designed for efficient native binaries across portable backends.

terminalPOP

pop check hello.poppop build hello.pop --output hello./hello

Native
foundation

Performance without the punctuation tax

Simplicity with the performance of C, D, and Rust.

Small, readable source on the front. Typed HIR, verified MIR, and portable native backends underneath.

source.pop → HIR → MIR → native

02 / The feel of Pop

Readable at a glance.
Strict all the way down.

Familiar end-based blocks, local inference, first-class functions, and collection literals—built for general-purpose software from day one.

A tagged union gives each state a name and shape.

match is exhaustive. Add a case and callers must handle it.

Types stay precise without repeating what the compiler already knows.

pattern-matching.popPOP

public union SearchResult    Found(value: String)    Missingendfunction describe(result: SearchResult)    match result    when SearchResult.Found(name) then        print(`Found {name}`)    when SearchResult.Missing then        print("Nothing was found")    endend

03 / A unit called Bubble

Structure that scales without becoming ceremony.

Every .pop file is a Module. Modules compile together inside a Bubble—the boundary for internal visibility and independent dependencies.

bubble.toml→clear ownership

Workspace

Package

Bubble

Module

Item

04 / One coherent toolchain

From first check
to final build.

One command, one vocabulary, stable structured output for editors and build systems.

01pop checkprove it

02pop buildcompile it

03pop runrun it

04pop testtrust it

05pop formatshape it

05 / Built in public

A language you can watch becoming.

Pop is under active development and is not production-ready yet. The source of truth is public: architecture decisions, compiler foundations, runtime work, and conformance tests.

Follow the work ↗Read the book ↗

01
Language architectureAccepted decisions and invariants
active
02
Compiler foundationParser, HIR, MIR, diagnostics
active
03
Native runtimeValues, GC, ABI, backends
active
04
Production readinessNot stable yet
later

Simple by nature.Powerful by design.