RYNE

Fast, secure, full-stack Python backend framework with a native Rust core.

Write your entire application in pure Python. RYNE runs the HTTP server (HTTP/1.1 + HTTP/2), routing, JSON, validation, the SQLite driver and cryptography in compiled Rust — and installing it never requires a Rust toolchain:

pip install ryne

Why RYNE

Benchmarks

11 frameworks × 6 scenarios × 60 seconds per test, oha load generator, 50 concurrent connections, identical endpoints and payloads (full methodology and complete tables).

How to read this. RYNE is the fastest full-featured Python framework in 5 of 6 scenarios (within measurement noise in the 6th) while using the least memory. Native Rust frameworks (Actix, Axum, Hyper, Rocket — dark bars) are 5–8× faster still: that is the honest price of running user code in Python, and the trade-off RYNE makes to stay a pure-Python framework. In the validation scenario Sanic/Starlette edge ahead because their benchmark uses minimal hand-written checks, while RYNE runs its full Rust schema engine (parse → coerce → validate → convert).

Quickstart

pip install ryne
ryne startproject mysite
cd mysite
ryne makemigrations && ryne migrate
ryne run

Or in a single file:

from ryne import Ryne

app = Ryne()

@app.get("/hello/{name}")
async def hello(request, name: str):
    return {"message": f"Hello, {name}!"}

app.run()   # ryne run hello:app

The full stack

Validation — compiled to Rust at import time

import enum
from ryne import HTTPException
from ryne.validation import Schema, Str, Int, List, Enum, Object

class Color(enum.Enum):
    RED = "red"
    BLUE = "blue"

class Address(Schema):
    city: Str(max_length=80)

class CreateArticle(Schema):
    title: Str(min_length=1, max_length=200)
    tags: List(Str(), max_items=10) = []
    views: Int(ge=0) = 0
    color: Enum(Color)                  # -> Color.RED member on output
    author: Object(nested=Address)      # nested schema
    nickname: Str(max_length=30) = None # optional + nullable

@app.post("/articles")
async def create_article(request):
    data = CreateArticle.validate(request.json())  # raises ValidationError(422)
    ...

ORM + migrations — Django-style

from ryne.models import Model, CharField, IntField, ForeignKey

class Article(Model):
    title = CharField(max_length=200)
    views = IntField(default=0)
    author = ForeignKey(Author, null=True)

article = await Article.objects.create(title="Hi")
articles = await Article.objects.filter(views__gte=1).order_by("-id").limit(10)

ryne makemigrations   # schema diff -> reviewable Python migration files
ryne migrate          # applied atomically, recorded in ryne_migrations

SQLite ships compiled inside the wheel: WAL mode, a read connection pool and a single serialized writer connection (in-process writes never fight over SQLite's one-writer lock). The GIL is released during every query. PostgreSQL is planned.

Auth & sessions

from ryne.auth import authenticate, login, get_user, requires_login

@app.post("/login")
async def login_route(request):
    user = await authenticate(request.json()["username"], request.json()["password"])
    if user is None:
        raise HTTPException(401)
    await login(request, user)
    return {"ok": True}

@app.get("/me")
@requires_login
async def me(request):
    return {"user": (await get_user(request)).username}

Sessions are signed cookies (HMAC-SHA256, constant-time verification in Rust). Passwords are hashed with argon2id in native code.

Security defaults

• X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy on every response
• Per-IP rate limiting (token bucket in Rust) → 429 + Retry-After
• Backpressure: max_inflight caps concurrent dispatches → instant 503 instead of unbounded queues
• CSRF tokens for form submissions (JSON APIs unaffected)
• HttpOnly / SameSite cookies, opt-in HSTS and CSP
• 1 MiB request-body limit, enforced mid-stream in Rust
• DEBUG=False by default — unexpected errors never leak internals

For blocking sync workloads: settings.sync_pool = True runs sync handlers on a bounded blocking executor (sync_pool_size, default 64) so a slow handler can never starve the async runtime.

CLI

ryne startproject <name>     scaffold a project
ryne run [module:app]        run the server (Ctrl+C for graceful shutdown)
ryne makemigrations [--name] generate a migration from model changes
ryne migrate                 apply pending migrations
ryne createsuperuser         create an admin user
ryne shell [module:app]      interactive shell with your app loaded
ryne check [module:app]      validate configuration

Development

python -m venv .venv && .venv/Scripts/pip install maturin pytest httpx psutil
python -m maturin develop     # build the Rust core into the venv
python -m pytest              # full test suite
cargo test --workspace        # Rust unit tests

See CHANGELOG.md and the issue tracker for the roadmap (admin panel, templates, WebSockets, PostgreSQL).

License

MIT — see LICENSE.