Updating a Python web application often means coordinating a reverse proxy, an application server, process supervision and deployment automation without dropping requests. The Muru Rust server approaches that problem as one integrated, release-aware platform. Created by Graham Dumpleton, the developer behind mod_wsgi, Muru combines a Rust routing and management layer with Python workers that run existing WSGI and ASGI applications.
The important idea is not simply that Muru is another fast web server. It is designed to manage an application’s complete serving lifecycle: accept connections, start and monitor Python processes, deploy a new release beside the old one, test it, shift traffic gradually and roll back quickly if something fails. Muru also exposes an MCP server through which AI coding agents can perform operational tasks.
As of November 2026, however, Muru remains alpha software distributed through pre-release versions. Its commands, configuration and architecture may change. It should be evaluated through independent testing before anyone treats it as production-ready, and no performance advantage should be assumed without representative benchmarks.
What is Muru?
Muru is an application-serving platform for Python rather than a framework developers use to write application code. A Django, Flask, FastAPI, Starlette or other compatible application can continue exposing its normal WSGI or ASGI entry point. Muru supplies the infrastructure around that entry point.
Dumpleton’s involvement gives the project a notable lineage. His mod_wsgi work addressed the difficult boundary between web servers, Python interpreters and long-running application processes. Muru revisits similar operational concerns using a Rust web server, release-oriented deployment and a control interface designed for both people and AI coding agents.
The project’s scope is broader than a direct Gunicorn alternative or Uvicorn alternative. Those servers focus primarily on executing applications and serving requests. Muru attempts to combine that job with routing, process management and deployment coordination.
Three components that cooperate
The Muru architecture separates connection handling, operational control and Python execution into three cooperating parts.
1. A Rust routing edge
The edge accepts client connections and handles the HTTP-facing work. It supports HTTP/1.1 and HTTP/2, TLS termination, static files, uploads and response compression. It then routes application requests to the appropriate Python workers.
Crucially, routing is release-aware. The edge can distinguish between old and new application releases rather than forwarding every request to one interchangeable pool. That capability underpins previews, weighted canary releases and immediate traffic changes during rollback.
2. A control plane
The control plane manages application releases and worker processes. It knows which release is active, starts workers for a candidate release, checks whether they become ready and tells the edge how traffic should be distributed.
This is also where Muru’s Python-aware process management matters. Instead of relying entirely on an external supervisor, the platform can manage worker counts, enforce memory limits and scale workers. The aim is to make process health and release state part of one operational model.
3. Python application workers
Python remains responsible for running application code. WSGI workers execute synchronous applications, while ASGI workers support asynchronous applications and their corresponding interface semantics. Muru therefore does not ask teams to rewrite Python business logic in Rust.
This division keeps the language boundary pragmatic: Rust handles persistent connections, routing and management, while Python retains its frameworks, packages and developer ecosystem.
One Python application server for WSGI and ASGI
Supporting both interfaces is significant for organizations with mixed Python estates. WSGI remains common in mature Django and Flask deployments. ASGI is central to FastAPI, Starlette, asynchronous Django features and applications that need long-lived or concurrent connections.
A conventional stack might use Gunicorn for WSGI and Uvicorn for ASGI, with Nginx, HAProxy or a cloud load balancer in front. Additional tools then handle service supervision, health checks and deployment. Muru aims to provide one platform capable of hosting both interface types while applying the same release and process-management model.
That does not make WSGI asynchronous or erase behavioral differences between the standards. Application concurrency, blocking calls, framework behavior and worker sizing still need to be understood. Muru unifies operations around the interfaces; it does not change how Python code fundamentally executes.
Deployment without replacing the live release immediately
Muru’s most distinctive feature is its deployment model. A traditional update often replaces or restarts the processes serving the current application. Graceful restart mechanisms reduce disruption, but operators still have to coordinate readiness, traffic draining and failure recovery.
Muru instead treats a deployment as a new release that can coexist with the current one:
- The existing release continues serving normal traffic.
- Muru starts Python workers containing the new application release.
- The new workers initialize and become ready before receiving general traffic.
- Operators or automation preview the release or send it a limited traffic share.
- Traffic moves to the new release when its behavior is acceptable.
- The previous release remains available for a rapid rollback.
This resembles blue green deployment because two releases can run side by side. Weighted routing also permits canary releases, where only a chosen proportion of requests reaches the candidate. A preview can expose the candidate for validation without making it the default release.
The result is a stronger foundation for zero downtime deployment, although the label is not an unconditional guarantee. Database migrations, background tasks, shared caches, session formats and external dependencies can still cause downtime or incompatibility. Teams must design releases so old and new code can operate simultaneously.
Containers and Kubernetes
Muru can be used in containerized environments and deployed with Kubernetes, but it changes where some responsibilities sit. In a conventional Kubernetes design, Deployments, ReplicaSets, Services and ingress components collectively implement rollout and routing behavior. Muru brings release routing and Python process management into its own application-serving layer.
That does not make Kubernetes redundant. A cluster can still provide scheduling, networking, persistent configuration, resource isolation and recovery for Muru’s components. Teams should decide carefully whether Muru’s release model complements or duplicates their existing controllers, service mesh and ingress strategy.
The same scrutiny applies to containers outside Kubernetes. Memory limits at the Muru worker level must make sense alongside container limits, and shutdown behavior must allow requests to drain. Alpha software deserves failure testing under actual orchestration conditions rather than assumptions based on a local demonstration.
How the MCP server works with AI coding agents
Muru includes an MCP server, using the Model Context Protocol to expose controlled operational capabilities to compatible AI coding agents. An agent can deploy a change, run tests, inspect a failed release and request a rollback through structured tools instead of attempting to operate a terminal only from generated text.
This design connects the coding loop with the release loop. An agent might modify an endpoint, deploy a candidate, invoke tests against its preview, examine logs or failure information and revise the code without disturbing the active release. If validation fails after traffic is introduced, it can direct Muru to restore the prior release.
Access still needs strict boundaries. An MCP tool capable of deploying code or changing traffic is operationally powerful. Authentication, authorization, audit records, secret handling and environment separation remain essential. Human approval should be retained where the potential impact warrants it.
Muru compared with Gunicorn, Uvicorn and traditional stacks
Gunicorn
Gunicorn is a mature pre-fork WSGI server with well-understood worker management. It can also participate in ASGI deployments through compatible worker arrangements, but release-aware routing is not its central abstraction. Teams typically combine it with a proxy, a supervisor or container orchestrator, and a separate deployment system.
Uvicorn
Uvicorn is an ASGI server commonly used directly or under another process manager. It is focused, familiar and well integrated with asynchronous Python frameworks. Blue green deployment, canary weighting and cross-release rollback generally come from infrastructure around it rather than Uvicorn itself.
Reverse proxy plus application server
A traditional stack offers modularity. Teams can independently choose Nginx or HAProxy, Gunicorn or Uvicorn, systemd or Kubernetes, and a deployment controller. Those components are mature and replaceable, but operators must connect their health, configuration, observability and release behavior.
Muru trades some of that modular separation for an integrated model. Its edge knows about application releases, and its control plane knows about both traffic and Python workers. The potential benefit is simpler coordination, not automatically greater speed. The potential cost is adopting a newer platform with fewer years of production use, integrations and operational knowledge.
Why combine Rust and Python?
Rust is a logical choice for the routing and management layer because it offers memory safety without garbage collection, strong concurrency tools and predictable native execution. Those properties suit software that maintains many connections and coordinates long-running processes.
Python remains the right execution environment for Python applications. Moving routing to Rust does not eliminate the global interpreter lock, optimize inefficient application queries or make synchronous code asynchronous. It isolates infrastructure work from application execution while preserving access to Python frameworks and libraries.
Any performance conclusion still requires benchmarks using realistic response sizes, TLS settings, worker counts, application behavior and failure scenarios. Muru’s architecture is interesting, but architecture alone is not proof of superior throughput or latency.
Installation and a first deployment
The current project documentation uses muructl to install and interact with Muru. A minimal local flow has the following shape:
uv tool install muructl
muructl install
muructl deploy .The first command installs the CLI with uv. muructl install installs Muru’s required local components, and muructl deploy . submits the application in the current directory as a release. The application must expose a supported WSGI or ASGI entry point and use the configuration expected by the current release.
Because Muru is alpha and published through pre-release versions, readers should check the repository’s current instructions before copying these commands into automation. Flags, package installation steps and configuration formats may change between builds. Test in an isolated environment and pin the exact version used by a team.
AI helped build Muru, but engineering judgment remains central
AI coding agents played a meaningful role in building the project, making Muru an example of agent-assisted systems development as well as an agent-operable platform. That is noteworthy, but generated code does not remove the need for experienced technical direction.
Graham Dumpleton’s background in Python hosting helps define the architecture, identify process-lifecycle problems and evaluate proposed implementations. Humans still need to design invariants, review security boundaries, test protocol behavior, reproduce failures and decide whether operational trade-offs are acceptable.
For adopters, the same rule applies: let agents accelerate experiments, but require observable tests and accountable release decisions. A successful demo cannot substitute for load testing, failure injection, security review and recovery exercises.
Should developers try the Muru Python server?
Muru is worth exploring for teams interested in unified WSGI and ASGI hosting, release-aware routing or agent-assisted deployment. Its side-by-side release model directly addresses weaknesses in restart-based workflows, and its Rust-and-Python split is technically coherent.
It is not yet a drop-in reason to retire proven infrastructure. Alpha status, pre-release packaging and changing interfaces should keep initial use focused on evaluation and non-critical environments. The authoritative details are available in the Muru GitHub repository, while Simon Willison’s overview of Muru provides additional context on the project and its AI-assisted development.
Frequently asked questions
Is Muru a replacement for Gunicorn or Uvicorn?
Muru overlaps with both because it executes WSGI and ASGI applications. Its scope is wider, adding an HTTP edge, release management, process control, canary routing and rollback. Whether it replaces an existing server depends on a team’s architecture and tolerance for alpha software.
Does Muru guarantee zero downtime deployment?
No platform can guarantee that for every application. Muru can keep old and new releases running together and move traffic after readiness, but incompatible database migrations, shared state and external services can still interrupt users.
Is Muru ready for production?
The project is currently in alpha and uses pre-release versions. It should not be described as proven production infrastructure without independent security, reliability and performance testing under the intended workload.
Do applications need to be rewritten in Rust?
No. Rust powers Muru’s routing and management layers, while application code continues running in Python workers through WSGI or ASGI. Existing applications may still need configuration or packaging changes to fit Muru’s deployment model.