The input
is a type.

One screen, whether you asked to stop or the program did.

Write :bp at the end of a statement and the program pauses after it runs; index out of bounds, division by zero or a parse mismatch and it stops on its own. Either way it is the same full-screen debugger over the same snapshot: every frame, the selected frame's source with the line it is on marked — and at a fault the subexpression that failed — and its locals and the compiler's temporaries, each labelled with the expression that produced it. The last temp with a real value is the last thing that worked.

The recording below is one run: two stops at the one marker, then the division the second stop was standing in front of.

Small enough to hold in your head at 6am.

var is the only binding form. Types are inferred and only written when you want them read. A match must be exhaustive, and the compiler writes the missing arms for you.

var readings = [3, -1, 4, 1, -5, 9, 2, 6]

var answer = readings
    .filter(|x| x > 0)
    .map(|x| x * x)
    .sum()

out(answer)

var maze = read grid(char)
var wall = '#'

// The search never sees the grid. It only asks
// what is next to here.
fn open(g: Grid[Char], w: Char, p: (Int, Int)) {
    g.neighbors4(p).filter(|q| g[q.0, q.1] != w)
}

out(bfs_distance(
    (0, 0),
    |p| open(maze, wall, p),
    |p| p == (4, 4),
))

struct Point { x: Int, y: Int }

var points = [
    Point { x: 1, y: 2 },
    Point { x: 3, y: 4 },
]

for { x, y } in points {
    out(x * y)
}

// No struct declared anywhere: the template
// derived the type and the literal writes it.
var points = read lines(`{x:int},{y:int}`)
var origin = { x: 2, y: 5 }

fn area(r) -> Int { r.x * r.y }

out(area(points[0]) + area(origin))

you write   fn foo(a, b)
you read    fn foo(a: Int, b: Int)

Fast enough that the puzzle is the slow part.

Eight benchmarks, each written three times — in Praxis, in Rust and in Python — with byte-identical output enforced. Wall clock, whole process, best of five.

Read the last two columns as how many times longer than: below 1.0 means Praxis was faster. The JIT is not hiding in these numbers — the whole fixed cost of praxis run, lexing through Cranelift codegen, is between 0.41% and 3.92% of each measured run.

Everything the language does, in one place.

A manual rather than a tour: every construct has a chapter, every chapter has programs you can paste and run, and the appendices carry the complete grammar and a set of worked solutions.

• Getting started installing, a first program, the command line
• The language bindings through pipelines, grids and graphs, the prelude, the method catalog
• Reading input the read expression, templates and captures, a cookbook of input shapes
• Type inference generalization, method resolution, capabilities, and how to read a type error
• The crash debugger the fault model, breakpoints, the full-screen UI, a walkthrough
• Tooling editor support, and every diagnostic code the compiler can emit
• Under the hood the compiler pipeline and the object heap

Install it, then solve something.

$ cargo install praxis-cli
# the crate is `praxis-cli`; the binary
# it puts in ~/.cargo/bin is `praxis`

$ praxis run day05.px < input.txt
$ praxis run day05.px --input in.txt
$ praxis check day05.px
$ praxis run day05.px --debug never