djox 0.1.0

Truly async Django ORM, with a Rust core.
Keep your models, migrations and admin. Make await Book.objects.aget(pk=1) really async, and fast.

Documentation · Quickstart · Benchmarks · How it works · Changelog

Django's async ORM isn't async underneath: aget(), acount() and async for run the sync ORM on one worker thread, and every request waits its turn for it. djox runs those queries on connections that Rust owns and wakes Python only when the answer is ready. Django keeps doing what it does well (models, migrations, the admin, the QuerySet language), so your code doesn't change.

• Really async. No query waits for Django's worker thread, so async views scale with concurrent requests.
• Faster, sync too. Simple queries skip Django's query compiler, and Rust builds the model instances.
• A drop-in. Two settings. Your models, migrations, tests and third-party apps keep working.
• Tested with Django's own tests. 2,395 of Django's ORM tests are ported to djox, and 2,390 pass, on every supported Django.

Speed

The same Django app on stock Django and on djox: one worker process, SQLite, requests per second, higher is better (method, Postgres and every number).

• Async views gain the most: 1.4 to 3.1 times the requests, on SQLite and Postgres.
• One ORM call (all of them): await Book.objects.aget() takes 132 µs against Django's 507, and a sync get() 61 against 216.
• DRF gains less (1.0 to 1.3 times): most of a DRF request is DRF's own code.

Quickstart

uv add djox  # or: pip install djox
uv add "djox[postgres]"  # on Postgres: adds psycopg 3 for Django's sync code

Python 3.11+, Django 5.2 to 6.1. Wheels for Linux, macOS and Windows, so no Rust needed. On Postgres, async connections don't support TLS yet, so servers that require it (most hosted ones) won't work.

Change two settings:

# settings.py
DATABASES = {
    "default": {
        "ENGINE": "djox.backends.sqlite3",  # or "djox.backends.postgresql"
        "NAME": BASE_DIR / "db.sqlite3",
    }
}
INSTALLED_APPS = [..., "djox"]  # every model's QuerySet now runs on djox

Then write async Django as usual:

import djox
from django.http import JsonResponse

from shop.models import Book, Order


async def book_detail(request, book_id):
    book = await Book.objects.aget(pk=book_id)  # on djox's connections, not Django's worker thread
    return JsonResponse({"title": book.title, "pages": book.pages})


async def long_books(request):
    titles = [book.title async for book in Book.objects.filter(pages__gt=400).order_by("title")]
    return JsonResponse({"titles": titles})


async def buy(request, book_id):
    async with djox.atomic():  # Django's atomic(), for async code
        book = await Book.objects.aget(pk=book_id)
        await Order.objects.acreate(book=book)
    return JsonResponse({"ok": True})

Anything djox doesn't run itself falls back to Django's own method, so nothing breaks. Next: the documentation.

What you get

Status: 0.1.0, the first release. Everything above works and is tested on every supported Django, on SQLite and Postgres. djox is young, though: expect rough edges, and check the roadmap.

How it works

await Book.objects.aget(pk=1)
  │  Django writes the SQL (once per query shape, then djox reuses it)
  ▼
djox ──► a Rust thread with its own connection (SQLite: one writer, a few readers; Postgres: a pool)
  │  Rust converts the rows and builds the Book
  ▼
your coroutine wakes up with the answer; the event loop never blocked

The Rust code is written for Python developers who have never seen Rust: plain names, straight-line code, and comments that explain each Rust feature and each database detail. Start with How it works and AGENTS.md.

Develop

uv sync                              # builds the Rust extension
uv run pytest                        # Python tests, Django's ported tests included
scripts/cargo-test.sh --workspace    # Rust tests
uv run prek install                  # git hooks: ruff, mypy, pyrefly, cargo fmt, clippy, tests
uv run --only-group docs zensical serve   # the docs, on http://localhost:8000

License

MIT