Learn How Modern Infrastructure Is Built, in Rust

You already run Rust. Can you read it?

ruff, uv, Pydantic v2, Polars, orjson. The fast layer under your Python is Rust, and that layer keeps growing. Running it is easy. Debugging it, extending it, or understanding why it's fast is another skill entirely.

This cohort changes that. You learn to think like a systems engineer: where scripting languages hit their limits, how memory and performance actually work, and why the infrastructure under your AI stack keeps getting written in Rust. You build a JSON parser from scratch, wire it into Python with PyO3, and benchmark it against CPython and other JSON parser libraries. Six weeks of real code review from engineers who've shipped Rust in production. Co-led with Rust engineer Jim Hodapp.

Performance is only the first reason to learn Rust now. Its strictness (explicit errors, no nulls, ownership over who mutates what) trains a precision that carries straight back into your Python. And its compiler is one of the best guardrails you can put on AI-generated code: it refuses to compile the bugs an agent will happily write.

Who is this for?

Developers comfortable with Python (or another scripting language) who want to understand the systems layer beneath the apps they build. Not a "hello world" workshop. You build a parser, bridge it to Python, and measure the performance difference.

Time commitment: 6-10 hours per week.

What you'll build

A complete, fast JSON parser in Rust, callable from Python.

Parser from scratch

Tokenizer, recursive descent parser, full JSON spec. Enums, pattern matching, ownership, borrowing, learned by building, not reading.

PyO3 Python integration

The same FFI layer behind Pydantic and Polars. You create Python bindings, handle cross-language memory, and import your Rust code in Python.

Benchmarked performance

Measure your parser against Python's json module. Profile bottlenecks, optimize hot paths, and understand why Rust is fast, not just that it is.

What you build, week by week

Week 1

Setup & Tokenization

  • Project setup with cargo
  • Variables & mutability
  • Basic types: String vs &str
  • Build a JSON tokenizer
Week 2

Types & Errors

  • Enums & pattern matching
  • Option<T> and Result<T, E>
  • Error handling with the ? operator
  • Parse primitive JSON types
Week 3

Ownership & Borrowing

  • Structs and impl blocks
  • References: & and &mut
  • Ownership vs borrowing
  • Structured parser with state
Week 4

Collections & Recursion

  • Vec<T> and HashMap
  • Iterators and loops
  • Recursive data structures
  • Parse arrays & objects
Week 5

PyO3 & Python Bindings

  • Foreign Function Interface (FFI)
  • PyO3 crate and Python bindings
  • Cross-language memory management
  • Import and call Rust from Python
Week 6

Optimize & Benchmark

  • Performance profiling
  • String allocation optimization
  • Benchmark vs Python's json
  • Production-ready library

Tech stack: Rust, cargo, clippy, rustfmt, PyO3, maturin

Real results

Engineers finish this cohort with a real parser on their GitHub, built from scratch and reviewed weekly via PRs. Josh, Jochen, and Vikas each shared what they got out of it, from the engineering to how it changed the way they read Python.

"Building something real made Rust click in a way that tutorials never could, and honestly, it's made me a better Python developer too."
— Vikas Z., Python to Rust in 6 weeks

Join the cohort

Six weeks, two coaches, a portfolio-ready project. Capped small for high-touch, detailed PR review on every push: ownership, lifetimes, and idiomatic Rust, not just whether it compiles.

€2,000 · one-time · 6 weeks · capped at 6 developers

Book a call to reserve your seat →

Full curriculum and enrollment: scriptertorust.com. Prefer 1:1 on your own Rust project? Start here →