ryx 0.1.4

A Django-style Python ORM powered by sqlx (Rust) via PyO3.

Ryx ORM

Django-style Python ORM. Powered by Rust.

---

Ryx gives you the query API you love — .filter(), Q objects, aggregations, relationships — with the raw performance of a compiled Rust core. Async-native. Zero event-loop blocking.

import ryx
from ryx import (
    Model, CharField, IntField, BooleanField, 
    DateTimeField, Q, Count, Sum
)

class Post(Model):
    title = CharField(max_length=200)
    slug = CharField(max_length=210, unique=True)
    views = IntField(default=0)
    active = BooleanField(default=True)
    created = DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created"]

# Setup once
await ryx.setup("postgres://user:pass@localhost/mydb")

# Query like Django, run like Rust
posts = await (
    Post.objects
        .filter(Q(active=True) | Q(views__gte=1000))
        .exclude(title__startswith="Draft")
        .order_by("-views")
        .limit(20)
)

# Aggregations
stats = await Post.objects.aggregate(
    total=Count("id"), avg_views=Avg("views"), top=Max("views"),
)

# Transactions with savepoints
async with ryx.transaction():
    post = await Post.objects.create(title="Atomic post", slug="atomic")
    await post.save()

Why Ryx

	Django ORM	SQLAlchemy	Ryx
API	Ergonomic	Verbose	Ergonomic
Runtime	Sync Python	Async Python	Async Rust
GIL blocking	Yes	Yes	Zero
Backends	All	All	PG · MySQL · SQLite
Migrations	Built-in	Alembic	Built-in

Architecture

Your Python queries are compiled to SQL in Rust, executed by sqlx, and decoded back — all without blocking the Python event loop.

Since v0.1.3, the query engine has been extracted into a standalone crate ryx-query. This decouples the SQL compilation logic from the PyO3 bindings, enabling extreme performance and independent testing.

Performance

Benchmark of 1 000 rows on SQLite (lower is better):

Operation	Ryx ORM	SQLAlchemy ORM	SQLAlchemy Core	Ryx raw
bulk_create	0.0074 s	0.1696 s	0.0022 s	0.0011 s
bulk_update	0.0023 s	0.0018 s	0.0010 s	0.0005 s
bulk_delete	0.0005 s	0.0012 s	0.0009 s	0.0004 s
filter + order + limit	0.0009 s	0.0019 s	0.0008 s	0.0004 s
aggregate	0.0002 s	0.0015 s	0.0005 s	0.0001 s

Ryx ORM is 16× faster than SQLAlchemy ORM on bulk inserts and 2× faster on deletes — while keeping the same Django-style API. The raw SQL layer (raw_execute / raw_fetch) gives you near-C speed when you need it.

Internal Compilation Speed: Our query compiler is blindingly fast, with simple lookups compiled in ~248ns and complex query trees in ~1µs.

Run the benchmark yourself:

Documentation

Full documentation with guides, API reference, and examples: docs

Contributing

See CONTRIBUTING.md for development setup, architecture details, and contribution guidelines.

License

Python code: MIT · Rust code: MIT OR Apache-2.0