Developer tools

Graham Dumpleton builds Muru, a Rust server for Python apps

Graham Dumpleton, creator of mod_wsgi, is developing Muru, an AI-assisted Rust server designed to modernize how Python web applications are served in development and production.

Illustration of a Rust-based server with Python integration
Illustration generated for this article

Graham Dumpleton, the developer behind the long-standing mod_wsgi project, has introduced Muru, a new server for Python web applications. Announced in November 2026, this project represents a significant shift from his previous C-based work to a modern architecture built with Rust. The goal is to create a unified tool that handles both ASGI and WSGI protocols efficiently, leveraging artificial intelligence to accelerate development while maintaining high standards for production reliability.

What happened

Dumpleton began working on mod_wsgi twenty years ago, establishing it as a standard for serving Python applications via Apache. Over two decades, he has accumulated extensive experience with the complexities of production web serving. Muru is his response to the evolving landscape of Python web frameworks, aiming to replace fragmented toolchains with a single, robust server. He has documented the entire creation process in a series of detailed blog posts published over three weeks in November 2026, offering a transparent look at his engineering decisions.

The development process itself is notable for its heavy integration of AI tools. Dumpleton describes using generative AI not just for code generation, but as a core part of his workflow. However, he emphasizes that human judgment remains critical. He relies on his twenty years of experience to evaluate the output of AI models, ensuring that the resulting code meets the strict reliability requirements needed for production infrastructure. This approach allows him to iterate quickly without sacrificing the quality that made mod_wsgi a trusted component in many stacks.

How it works

Muru is built in Rust, a language chosen for its memory safety and performance characteristics. This choice addresses many of the stability issues inherent in older C-based servers. The server is designed to handle both WSGI (Web Server Gateway Interface) and ASGI (Asynchronous Server Gateway Interface) applications. This dual support means developers can run legacy synchronous apps alongside modern asynchronous frameworks like FastAPI or Starlette without needing separate server configurations or proxies.

A key architectural feature is the "import once, fork many" model. The server imports the Python application code only once in the main process and then forks worker processes. This reduces memory overhead and startup time significantly compared to loading the application independently in each worker. Additionally, Muru includes built-in support for HTTPS in development environments, removing the need for external reverse proxies during local testing. It also integrates observability tools directly, such as a toolbar that appears on every page and provides tracing information, helping developers debug issues without leaving their browser.

Key details

  • Creator: Graham Dumpleton, original author of mod_wsgi.
  • Language: Written in Rust for performance and safety.
  • Protocol Support: Handles both WSGI and ASGI applications natively.
  • Development Model: AI-assisted coding with rigorous human review based on decades of experience.
  • Documentation: Detailed daily build logs published from November 4 to November 21, 2026.
  • Features: Includes built-in HTTPS for development, zero-downtime releases, and integrated debugging toolbars.

Why it matters

For software engineers and technical leads, Muru offers a potential consolidation of the Python serving stack. Currently, teams often juggle multiple tools: Gunicorn or uWSGI for production, uvicorn for async apps, and various proxies for TLS termination. Muru aims to unify these roles into a single binary. This simplification can reduce configuration errors, lower operational complexity, and make it easier to manage deployments across different environments, from local laptops to Kubernetes clusters.

The project also highlights a mature approach to AI-assisted programming. Rather than treating AI as a magic button, Dumpleton demonstrates how it can be used to handle boilerplate and complex syntax while the engineer focuses on architecture and correctness. This model is particularly relevant for teams looking to adopt AI tools without compromising on code quality. It shows that experienced domain knowledge is still essential for guiding AI outputs toward reliable, production-grade results.

What you can do

  • Read Graham Dumpleton’s series of blog posts starting from November 4, 2026, to understand the design decisions behind Muru.
  • Evaluate your current Python serving stack to identify pain points that a unified Rust-based server might resolve.
  • Experiment with AI tools in your own workflow, but establish clear review criteria based on your team’s reliability standards.
  • Monitor the Muru repository for early releases if you are interested in testing new ASGI/WSGI serving technologies.
  • Consider how built-in observability features, like per-page tracing, could improve your development feedback loop.
  • Reflect on the "import once, fork many" pattern and whether it aligns with your application’s resource usage profiles.
  • #python
  • #rust
  • #web-server
  • #ai-assisted-dev
  • #wsgi
  • #asgi

Tools from the Bytechap store

Keep reading

All stories