# Robyn: An Async Python Web Framework With a Rust Runtime

> Robyn pairs a Python routing API with an Actix/Tokio core compiled through PyO3. It suits developers who want FastAPI-style ergonomics without giving up control of the server process.

**sparckles/Robyn** — Robyn is a Super Fast Async Python Web Framework with a Rust runtime.

- Repository: https://github.com/sparckles/Robyn
- Website: https://robyn.tech/
- Stars: 7,408 · Forks: 342
- Language: Python
- License: BSD-2-Clause
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/sparckles-robyn

## What Robyn solves, and who it is actually for

Most Python web frameworks run your handlers on an asyncio event loop that the framework owns. Robyn inverts that: the HTTP server is Actix Web and Tokio, written in Rust, and your Python functions are called from it through PyO3. The README describes the project as a "Super Fast Async Python Web Framework with a Rust runtime," and the Cargo.toml confirms the dependency set (actix-web 4.4.2, tokio 1.40, pyo3 0.27.2).

The audience is narrower than a general web framework. You get value from Robyn if you already write async Python, you want multi-core scaling without putting a process manager in front of a single-threaded loop, and you accept that the request path crosses a language boundary. If your application is a CRUD service where database latency dominates, the runtime swap buys you less than the operational cost of a compiled extension. The repository classifies the package as "Development Status :: 3 - Alpha" in pyproject.toml, which is the honest signal about maturity regardless of the feature list.

## How the Rust runtime and the Python layer fit together

The repository layout makes the split visible. Python code lives in robyn/, Rust code in src/, and the build backend is maturin, with the crate declared as crate-type = ["cdylib", "rlib"]. Routing, middleware and request parsing are exposed to Python through pyo3, while the socket handling, HTTP parsing and connection management come from actix-http and actix-files. The matchit crate supplies the router, which is why the README can advertise dynamic URL routing as a first-class feature rather than a Python-side dispatch table.

Two details in Cargo.toml are worth reading before you commit. The release profile sets panic = "abort" and lto = "fat", which is a deliberate trade: smaller, faster binaries, but a Rust panic takes the process down rather than unwinding into a catchable Python exception. And the io-uring feature is gated behind actix-web/experimental-io-uring, enabled at build time with --features=io-uring. The README labels that path experimental, so treat it as a build-time experiment rather than a production default.

On the Python side, the declared runtime dependencies include orjson for serialization, uvloop on non-Windows CPython (excluding armv7l), multiprocess, watchdog for reload, and rustimport. Pydantic and Jinja2 are optional extras, installed through robyn[all]. That split matters: validation and templating are not in the base install.

## Installing Robyn and running a first route

The README gives pip as the primary installation path. The base install is enough to serve a route; add the extras only if you need Pydantic models or Jinja2 templates.

```bash
pip install robyn
```

For validation and templating together, the README documents a single extra:

```bash
pip install "robyn[all]"
```

A conda-forge channel is also listed in the README if that is your package manager of choice. Note that setup.py deliberately refuses to run: it writes an "Unsupported installation method" message and exits, instructing you to use python -m pip install . instead.

The minimal application is three lines of routing plus a start call. Create app.py:

```python
from robyn import Robyn

app = Robyn(__file__)

@app.get("/")
async def h(request):
    return "Hello, world!"

app.start(port=8080)
```

Run it with python3 app.py and the README states the server is available on localhost:8080. For iterative work, the CLI exposes a dev flag that restarts on file changes:

```bash
python3 app.py --dev
```

The same CLI handles process and worker counts (--processes, --workers, both defaulting to 1), --log-level with DEBUG, INFO, WARNING or ERROR, and --create for project scaffolding. If you want the browser to open on startup, --open-browser does that. OpenAPI generation is on by default and can be turned off with --disable-openapi.

## Where the design costs you: alpha status and the compiled boundary

The most concrete limitation is stated by the project itself. pyproject.toml carries the classifier "Development Status :: 3 - Alpha". That is not a documentation hedge; it is the packaging metadata, and it means the API surface can move. The release cadence supports that reading: v0.86.0, v0.87.0 and v0.88.0 all landed within roughly ten days in June 2026, and the changelog titles describe them as ergonomics and middleware changes rather than patch fixes.

The second cost is the build boundary. Because the extension is compiled, installing from source requires a Rust toolchain and a C compiler. The README lists exactly that under development prerequisites: Python >= 3.10 and <= 3.14, Rust latest stable, and gcc or clang. On platforms without a prebuilt wheel, that toolchain becomes your problem, and panic = "abort" means a fault in the Rust layer terminates the process instead of surfacing as a Python traceback you can catch.

Third, uvloop is a conditional dependency. It is installed only when the platform is not Windows, the implementation is CPython, and the machine is not armv7l. If you are targeting Windows or an ARMv7 board, you are running without it, and the performance characteristics differ from the benchmark chart the README shows from TechEmpower Round 22.

## Robyn against FastAPI and the ASGI stack

The obvious comparison is FastAPI, and the difference is architectural rather than cosmetic. FastAPI is a framework on top of ASGI; the server is a separate process (uvicorn, hypercorn) that speaks the ASGI protocol to your application. Robyn is the server. There is no ASGI boundary between the HTTP layer and your handler, which is precisely why the Rust runtime can call your coroutine directly.

That changes what you can swap. With FastAPI you can move between ASGI servers without touching application code, and you inherit the ASGI middleware ecosystem. With Robyn, the server is the framework: middleware is Robyn's before and after request hooks, and the runtime is whatever the crate ships. The README lists sub-routers, dependency injection, WebSockets, streaming and SSE responses, CORS configuration, static file serving and authentication support, so the feature surface overlaps heavily with FastAPI. What does not overlap is portability of the runtime.

There is also a second axis. Robyn's README advertises AI agent routing and MCP (Model Context Protocol) support as built-in features, with examples/agents.py and examples/mcp.py in the repository. FastAPI reaches the same territory through separate libraries. If you want the model-context server and the HTTP API in one process, that is a genuine reason to pick Robyn; if you want a stable, widely deployed ASGI contract, it is a reason not to.

## Maintenance, licensing and what an upgrade actually costs

The repository is not archived, and the last push was on 2026-09-21, one day before this writing. The most recent tagged release is v0.88.0 from 2026-06-25. Between the release tag and the latest push there is roughly three months of commits that are not in a tagged release, so pinning to v0.88.0 means running code that predates the current main branch.

Upgrade cost is driven by the versioning. The project is pre-1.0 and classified as alpha, so minor version bumps (0.86 to 0.87 to 0.88) are where breaking changes live. The release titles describe middleware chains and sub-routers arriving in v0.87.0 and sessions plus binary WebSockets in v0.88.0, which suggests feature work is still landing in areas that touch application code. A team adopting Robyn should expect to read CHANGELOG.md before each bump rather than assuming semver compatibility.

The licence is BSD-2-Clause, declared in the LICENSE file and referenced from pyproject.toml and Cargo.toml. That is a permissive licence with no copyleft obligation, but the two-clause form omits the patent grant that BSD-3-Clause includes. Whether that matters depends on your organisation's policy; the repository does not discuss it, so this is a question for your own review rather than something the project answers.

## Conclusion

Robyn fits teams that want an async Python API server whose HTTP layer is Actix and Tokio rather than asyncio, and who are comfortable tracking a project whose own pyproject.toml still classifies it as Development Status 3 - Alpha. It is the wrong choice if you need a frozen, long-term-support runtime or if your deployment target is Windows with uvloop expectations, since uvloop is only pulled in on non-Windows CPython. Before adopting it, run python3 app.py --dev on your target platform, confirm the compiled extension installs from a wheel without a Rust toolchain, and read the BSD-2-Clause LICENSE file for the terms that apply to your distribution.

## FAQ

### What is Robyn, the Python web framework?

Robyn is an async Python web framework with a Rust runtime, described in its README as a "Super Fast Async Python Web Framework with a Rust runtime." The HTTP layer is built on Actix Web and Tokio, and Python handlers are called through PyO3.

### How do I install Robyn?

The README documents pip install robyn for the base package, or pip install "robyn[all]" to add Pydantic validation and Jinja2 templating. A conda-forge channel is also listed. Installing from source requires Rust and a C compiler.

### Which Python versions does Robyn support?

The README states Python >= 3.10, and the packaging classifiers list 3.10 through 3.14. The development prerequisites give the same range, Python >= 3.10 and <= 3.14.

### Does Robyn support hot reloading during development?

Yes. The CLI has a --dev flag described as development mode that restarts the server based on file changes, and watchdog is listed as a runtime dependency in pyproject.toml.

### What is Robyn's licence?

Robyn is released under BSD-2-Clause, declared in the LICENSE file and referenced from both pyproject.toml and Cargo.toml. The README's licence badge reads BSD 2.0.

## Sources

- [License: BSD-2-Clause](https://github.com/sparckles/Robyn/blob/main/LICENSE)
- [Project website](https://robyn.tech/)
- [README](https://github.com/sparckles/Robyn/blob/main/README.md)
- [Releases](https://github.com/sparckles/Robyn/releases)
- [sparckles/Robyn on GitHub](https://github.com/sparckles/Robyn)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/sparckles-robyn