Robyn — High-Performance Python Web Framework with Rust Runtime

Introduction

Robyn is a Python web framework that achieves high throughput by running its HTTP server and async event loop in Rust. Developers write route handlers and middleware in Python while the framework handles connection management, request parsing, and response serialization in compiled Rust code. The result is a Flask-like API with performance closer to Go or Rust web servers.

What Robyn Does

• Serves HTTP requests using a multi-threaded Rust runtime under the hood
• Provides a decorator-based routing API similar to Flask and FastAPI
• Supports WebSocket connections for real-time communication
• Includes middleware, authentication, and dependency injection features
• Handles static file serving and templating with Jinja2

Architecture Overview

Robyn embeds a Rust HTTP server (built on Actix Web) that spawns worker threads to accept connections. Incoming requests are deserialized in Rust and passed to Python handlers through PyO3 bindings. Responses are serialized back in Rust before being sent to the client. This hybrid approach keeps Python in the application logic layer while offloading I/O-intensive work to compiled code. Multi-process scaling is supported through the --processes flag.

Self-Hosting & Configuration

• Install with pip install robyn (requires Python 3.8+)
• Run with python app.py or use the CLI with python -m robyn app.py --processes 4 --workers 2
• Configure CORS, logging, and other settings through the Robyn constructor or environment variables
• Deploy behind Nginx or directly as a standalone server
• Use the --dev flag for hot-reload during development

Key Features

• Rust-powered runtime delivering throughput competitive with Go frameworks
• Familiar decorator-based API that Python developers can adopt quickly
• Multi-process and multi-worker scaling with a single CLI flag
• Built-in WebSocket support with the same decorator pattern
• Hot-reload mode for rapid development iteration

Comparison with Similar Tools

• FastAPI — Feature-rich ASGI framework with auto-generated docs; Robyn trades OpenAPI integration for raw speed via its Rust runtime
• Flask — Classic synchronous framework; Robyn offers a similar API but with async support and higher throughput
• Sanic — Async Python framework; Robyn's Rust runtime handles connection management faster than pure-Python event loops
• Granian — Rust-based ASGI/WSGI server; Granian is a server for existing ASGI apps, while Robyn is a full framework

FAQ

Q: Do I need to know Rust to use Robyn? A: No. All application code is written in Python. Rust is only used internally by the framework.

Q: Is Robyn production-ready? A: Robyn is actively maintained and used in production by several teams. Check the GitHub repository for the latest stability status.

Q: Can I use SQLAlchemy or other Python ORMs with Robyn? A: Yes. Any Python library can be used in route handlers, including SQLAlchemy, Tortoise ORM, and Prisma Python.

Q: How does it compare to running FastAPI on Uvicorn with uvloop? A: Robyn's Rust runtime handles both the event loop and HTTP parsing in compiled code, which can reduce per-request overhead compared to a Python ASGI server.

Sources

• https://github.com/sparckles/Robyn
• https://robyn.tech