Django-Bolt: Why Django Learns Rust

Speaker: Dmitry Orlyakov

Django-Bolt embeds a high-performance Rust server (Actix Web) directly inside Django projects via PyO3, reaching throughput of over 60,000 RPS while preserving the full Django ecosystem – including the ORM, Admin, and middleware. In this talk, we’ll unpack how it works under the hood, how PyO3 bridges Python asyncio with the Rust runtime, and why msgspec is used over Pydantic. We’ll run benchmarks comparing Django-Bolt against FastAPI and DRF, followed by an honest breakdown of the risks and production trade-offs.

Abstract

This talk explores Django-Bolt, a new high-performance API framework that embeds a Rust-powered server (Actix Web) inside Django projects via PyO3, promising throughput of 60,000+ RPS while retaining the ORM, Admin, middleware, and third-party ecosystem.

We will break down the framework’s internal architecture:

• How the PyO3 bridge connects Python asyncio with the Rust runtime.
• Why msgspec is leveraged instead of Pydantic for high-efficiency serialization.
• How a fully async Django ORM bypasses GIL limitations without relying on heavy thread pools.

The practical session includes a live benchmark comparing Django-Bolt against FastAPI and Django REST Framework (DRF) on real-world endpoints involving database queries and JSON serialization. We will conclude with an honest evaluation of the pitfalls – project immaturity, evolving APIs, and lack of battle-tested production history – alongside its future potential, given that its author is a Django core contributor.

About Dmitry

I’m a Senior Backend Engineer with over 12 years of software development experience, specializing in Python-based backend architectures, performance optimization, and high-load systems.

Throughout my career, I’ve focused on solving complex performance bottlenecks, improving system observability, and refactoring mission-critical core architectures. My hands-on track record includes leading core API refactorings that tripled system throughput while cutting maintenance overhead in half, as well as significantly reducing CI build times and production debugging latency.

I believe that exceptional software comes from carefully evaluating the tradeoffs between raw execution performance and operational complexity. That’s why I advocate for pragmatic, targeted optimizations – whether that means embedding Rust extensions into hot Python code paths or adopting modern async runtimes – without sacrificing developer productivity or architecture maintainability.