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 and blazingly-fast JSON parser in Rust, callable from Python.
Not a "hello world" workshop. You ship a tokenizer, a recursive descent parser, PyO3 Python bindings, and a benchmark suite, all reviewed by production Rust engineers via GitHub pull requests.
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.
Real-world results
A parser that beats Python's stdlib on every test
After 6 weeks, Josh Engroff's Rust JSON parser beats CPython's stdlib json module on every fixture in his benchmark suite, including three real-world files from the simdjson and serde-json corpora.
Median throughput across 30 timed batches (~100 ms each, 3 warmup batches discarded). Linux x86-64, Python 3.14. Methodology.
Josh's parser sits mid-pack of the well-known faster-than-stdlib club (orjson, msgspec, ujson). Built from scratch in 6 weeks while reviewed weekly via GitHub PRs.
View the parser on GitHub · Full benchmark report
Why Rust, why now
Three reasons it's worth six weeks of your time
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.
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.
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
Book your 30-min call with Bob & Jim →
Want to learn more? Get Python-to-Rust tips and cohort updates by email.
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
Engineers who finished the cohort
Building something real made Rust click in a way that tutorials never could — and honestly, it's made me a better Python developer too. My Rust implementation is only 0.8x slower than CPython's C and 10–12x faster than simplejson.
— Vikas Z. · github.com/13hulk/rust-cohort
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.
Join the cohort
Six weeks, two coaches, a portfolio-ready project. What video courses can't give you: a human reading every PR you push.
€2,000 one-time · 6 weeks
- Detailed PR review on every push: ownership, lifetimes, and idiomatic Rust, not just whether it compiles
- Capped at 6 developers, the high-touch attention a typical bootcamp can't give you
- Weekly group call with both coaches
- Invite-only community for peers and accountability
- 6-week structured curriculum with PyO3 integration & a portfolio JSON parser
Prefer 1:1 on your own Rust project?
Some developers bring their own Rust project, adapted to their domain, not the cohort's JSON parser. That's the 1:1 tier with Jim. Ask about it on the call.
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 10+ years at Sun/Oracle and 6+ years coaching developers to ship maintainable software. Co-founded Pybites and built its Python and Rust coding platforms (500+ exercises). 150+ developers coached. Bob brings the Python perspective and coaches on bridging Python and Rust: 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.
Won't AI just write the Rust for me? It will, and that's exactly why you need to understand it. Devs who let Claude or Cursor write Rust without grasping ownership, lifetimes, and zero-cost abstractions ship code they can't debug. The premium goes to engineers who can read, review, and reason about what the AI produced. Six weeks here builds that muscle.
Stay in the loop
Python-to-Rust tips and cohort updates, straight to your inbox.
Ready to build a real Rust library?
Tell us what you want to get out of Rust. We'll get on a call, talk through your goals, and figure out whether this cohort is the right fit.