v1.5 — Educational Language with JIT

Write Code Like You Think

A programming language designed for learning, with intuitive syntax that reads like textbook pseudocode. Perfect for students and educators, with a high skill ceiling for advanced users.

Get VS Code Extension View on GitHub

Why Pseudocode?

An educational language that grows with you — from first program to advanced algorithms.

Built for Learning

Syntax mirrors textbook pseudocode. Perfect for teaching algorithms, data structures, and programming concepts.

Real-World Power

Not just for learning — build real projects with HTTP APIs, file I/O, JSON, and 80+ built-in functions.

High Performance

Tracing JIT compiler generates native machine code. Match C performance in tight loops.

Readable by Design

No semicolons, no braces. Code flows naturally with if/then/end and for/in/do blocks.

High Skill Ceiling

Closures, pattern matching, classes, and functional programming. Grow from beginner to expert.

VS Code Integration

Full IDE support with IntelliSense, diagnostics, debugging, and 50+ code snippets.

Examples

See how Pseudocode makes complex algorithms readable and concise.

fibonacci.pseudo

// Recursive Fibonacci
fn fib(n)
    if n <= 1 then
        return n
    end
    return fib(n - 1) + fib(n - 2)
end

print(fib(30))

http_client.pseudo

// Fetch user data from API
fn fetch_user(username)
    let url = "https://api.github.com/users/" + username
    let response = http_get(url)
    return json_parse(response)
end

let user = fetch_user("octocat")
print(user["name"])

Performance

The tracing JIT compiler generates native x86-64 code for hot loops.

10M Increment Loop

C (gcc -O2)

33ms

Pseudocode (JIT)

32ms

Pseudocode (VM)

Python 3.11

Tracing JIT Compiler

Pseudocode uses a tracing JIT that records hot loop execution paths and compiles them to native x86-64 machine code.

For simple numeric loops, the JIT achieves performance comparable to optimized C. Complex operations like string manipulation run through the VM.

View All Benchmarks

Technical Innovations

Built from scratch with a focus on simplicity and performance.

Tracing JIT Architecture

Records execution traces at runtime and compiles hot paths to native machine code with register allocation.

NaN-Boxing Value Representation

Efficient 64-bit tagged values that pack type information and data into a single word.

Function Inlining

Small functions are automatically inlined during JIT compilation for reduced call overhead.

One-pass Bytecode Compiler

Single-pass compilation from source to bytecode with constant folding and peephole optimizations.

Supported Platforms

JIT Compilation: x86-64 (Intel/AMD 64-bit) — macOS, Linux, Windows

Interpreter: All platforms with a C99 compiler — ARM64, ARM32, RISC-V, WebAssembly

Get Started

Clone Repository

Get the source code from GitHub

git clone github.com/NagusameCS/Pseudocode

Build VM

Compile the virtual machine

cd cvm && make

Run Code

Execute your first program

./pseudo hello.pseudo