Build a Production Rust Library in 6 Weeks
The tools you use every day are written in Rust. Can you read them?
ruff, uv, Pydantic v2, Polars, orjson — you're already running Rust. You just can't debug it, extend it, or reason about why it's fast. This cohort changes that.
Build a JSON parser from scratch, wire it into Python with PyO3, and benchmark it against CPython. Six weeks of real code review from engineers who've shipped Rust in production. You leave thinking in two languages and writing better code in both.
Who is this for?
Developers comfortable with Python (or another scripting language) who want to learn Rust through a real project. Not a "hello world" workshop — you'll build a parser, bridge it to Python, and measure the performance difference.
Time commitment: ~10 hours per week.
What you'll build
A complete JSON parsing library in Rust — callable from Python — that you benchmark against the standard library.
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'll 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's fast.
Why Rust, why now
It will make you a better Python developer. Rust forces habits that Python lets you skip: explicit error handling, no nulls, ownership over who mutates what. Once you've written Rust for six weeks, you read Python differently. You see where state leaks, where errors are silently swallowed, where "it works" is doing a lot of work.
It makes you sharper with AI. When you're directing an AI to write code, vague thinking produces vague output. Rust's type system and ownership model train you to be precise about contracts, lifetimes, and failure modes. That precision transfers to every prompt you write and every AI-generated diff you review.
It's designed by exceptional engineers. The borrow checker, zero-cost abstractions, the trait system — Rust is one of the most carefully designed languages built in the last 20 years. Learning it is like reading the best code on the planet. That thinking rubs off.
Program overview
What you build, week by week
Setup & Tokenization
- Project setup with cargo
- Variables & mutability
- Basic types: String vs &str
- Testing with #[test]
- Build a JSON tokenizer
Types & Errors
- Enums & pattern matching
- Option<T> and Result<T, E>
- Error handling with ? operator
- Custom error types
- Parse primitive JSON types
Ownership & Borrowing
- Structs and impl blocks
- References: & and &mut
- Ownership vs borrowing
- Memory safety principles
- Structured parser with state
Collections & Recursion
- Vec<T> and HashMap
- Iterators and loops
- Recursive data structures
- Display trait for serialization
- Parse arrays & objects
PyO3 & Python Bindings
- Foreign Function Interface (FFI)
- PyO3 crate and Python bindings
- Cross-language memory management
- Build as Python extension module
- Import and call Rust from Python
Optimize & Benchmark
- Performance profiling
- String allocation optimization
- Benchmark vs Python's json
- Documentation & examples
- Production-ready library
Tech stack: Rust, cargo, clippy, rustfmt, PyO3, maturin
Code review that makes you a better engineer
This isn't a course where you watch videos and check boxes. Every week, you push code — and your coaches review it.
- GitHub PR reviews — detailed, line-by-line feedback on your Rust code
- Idiomatic Rust guidance — not just "it works" but "here's how a Rust developer would write it"
- Iterative improvement — multiple rounds of review push you toward clean, production-quality code
- Real engineering workflow — branches, PRs, code review, merge. The same process used at every serious software company.
You finish with a GitHub history that shows real engineering rigor — not a tutorial copy-paste.
Career impact
A JSON parser with FFI and Python bindings is not a toy project. It demonstrates:
- Systems programming — memory management, performance optimization, zero-cost abstractions
- Cross-language engineering — PyO3 is the bridge behind Pydantic, Polars, and cryptography. Knowing it is a career multiplier.
- Real commits, real tests, real benchmarks — a portfolio project that stands up to scrutiny
- Confidence — Rust is hard. Finishing this cohort proves you can tackle complex technical challenges
You leave thinking in two languages and writing better code in both.
What developers say
It's been a privilege being part of the Rust cohort — I genuinely enjoyed the work and the whole experience.
The hands-on approach made all the difference. Building something real made Rust click in a way that tutorials never could — and honestly, it's made me a better Python developer too.
I finished the parser last Thursday — my Rust implementation is only 0.8x slower than CPython's C and 10–12x faster than simplejson. Check it out: github.com/13hulk/rust-cohort
— Vikas Z.
This 6-weeks Rust cohort was awesome! Jim is an amazing and thoughtful teacher and mentor. He's great at helping me develop a mindset of mastering Rust. With Jim's friendly guidance, I successfully built a real world project to get experience about Rust's mental model, syntax and its ecosystem. The weekly code review was really insightful and helpful, Jim provided invaluable feedback on my code. Over several iterations he guided me to improve my code to succinct, clear, idiomatic Rust code. Cannot say enough good things about this Rust cohort!
— Ben L.
This has been hands down one of the best instructor-led courses I have done. Everything from the curriculum structuring to the methodology pushes you to learn and build smoothly from day one. The knowledge I generated set me up to continue learning more complex concepts of the language on my own and gave me a solid TDD ground for Rust projects.
— Victor S.
The Rust Cohort was a strong, concept-driven program. It helped me take ownership, mutability, error handling, and Rust's compilation model clear and practical. I left able to read real Rust, spot AI hallucinations, and apply the mental model at work. Great value for busy engineers.
— Tim F.
What's included
- Weekly group call with your coaches
- Code review via GitHub PRs — detailed, honest feedback
- Professional, portfolio-ready project on GitHub
- Structured 6-week curriculum with PyO3 integration
- Access to invite-only community
Price: €2,000 · Duration: 6 weeks · Format: Group cohort · Next start: May 11, 2026
Your coaches
Jim Hodapp — Seasoned Rust developer, open source contributor, and software engineering coach with over two decades of experience. He's worked across the stack — from GNOME and Ubuntu to embedded systems and startups — and now mentors developers through Refactor Coaching to level up both technically and professionally. Whether you're new to Rust or ready to deepen your systems programming skills, Jim brings the perspective, structure, and guidance to help you grow.
Bob Belderbos — Developer coach and builder with 11 years at Sun/Oracle and 6+ years coaching developers to ship maintainable software. Co-founded Pybites and built Pybites Platform (400+ Python exercises) and Rust Platform (60+ Rust exercises). 100+ developers coached. Bob brings the Python perspective and coaches on bridging Python and Rust — including PyO3 integration, when to reach for Rust, and writing clean code in both languages.
Frequently asked questions
Do I need Rust experience? No. You need to be comfortable programming in another language (Python is ideal). We start from Rust basics and build up through the project.
What if I fall behind? Sessions are recorded for catch-up. You also have async support from Jim and Bob throughout the week.
How much time per week? ~10 hours including the live session, coding exercises, and building your parser.
Do we work solo or in teams? Solo work on your own parser, but you learn together. The group format creates accountability and peer support.
Will this help my portfolio? Yes — a JSON parser with FFI and Python bindings is a serious Rust project. Real commits, real tests, real benchmarks.
Not ready yet? Start with 60+ Rust exercises first.