Oxyde ORM is a type-safe, Pydantic-centric asynchronous ORM with a high-performance Rust core designed for clarity, speed, and reliability.

Inspired by the elegance of Django's ORM, Oxyde focuses on explicitness over magic, providing a modern developer-friendly workflow with predictable behavior and strong typing throughout.

---

Heads up! Oxyde is a young project under active development. The API may evolve between minor versions. Feedback, bug reports, and ideas are very welcome. Feel free to open an issue!

Features

• Django-style API — Familiar Model.objects.filter() syntax
• Pydantic v2 models — Full validation, type hints, serialization
• Async-first — Built for modern async Python with asyncio
• Rust performance — SQL generation and execution in native Rust
• Multi-database — PostgreSQL, SQLite, MySQL support
• Transactions — transaction.atomic() context manager with savepoints
• Migrations — Django-style makemigrations and migrate CLI

Performance

Benchmarks vs popular Python ORMs (avg ops/sec, higher is better):

Database	Oxyde	Tortoise	Piccolo	Django	SQLAlchemy	SQLModel	Peewee
PostgreSQL	1,433	896	956	733	455	433	79
MySQL	1,284	783	—	816	523	503	467
SQLite	2,575	1,884	468	1,283	592	560	553

Full benchmark report: Documentation

Installation

pip install oxyde

Quick Start

1. Initialize Project

oxyde init

This creates oxyde_config.py with your database settings and model paths.

2. Define Models

# models.py
from oxyde import Model, Field

class User(Model):
    id: int | None = Field(default=None, db_pk=True)
    name: str
    email: str = Field(db_unique=True)
    age: int | None = Field(default=None)

    class Meta:
        is_table = True

3. Create Tables

oxyde makemigrations
oxyde migrate

4. Use It

import asyncio
from oxyde import db
from models import User

async def main():
    await db.init(default="sqlite:///app.db")

    # Create
    user = await User.objects.create(name="Alice", email="alice@example.com", age=30)

    # Read
    users = await User.objects.filter(age__gte=18).all()
    user = await User.objects.get(id=1)

    # Update
    user.age = 31
    await user.save()

    # Delete
    await user.delete()

    await db.close()

asyncio.run(main())

Transactions

from oxyde.db import transaction

async with transaction.atomic():
    user = await User.objects.create(name="Alice", email="alice@example.com")
    await Profile.objects.create(user_id=user.id)
    # Auto-commits on success, rolls back on exception

FastAPI Integration

from fastapi import FastAPI
from oxyde import db

app = FastAPI(
    lifespan=db.lifespan(
        default="postgresql://localhost/mydb",
    )
)

@app.get("/users")
async def get_users():
    return await User.objects.filter(is_active=True).all()

Database Support

Database	Min Version	Status	Notes
PostgreSQL	12+	Full	RETURNING, UPSERT, FOR UPDATE/SHARE, JSON, Arrays
SQLite	3.35+	Full	RETURNING, UPSERT, WAL mode by default
MySQL	8.0+	Full	UPSERT via ON DUPLICATE KEY, FOR UPDATE/SHARE

Connection URLs:

postgresql://user:password@localhost:5432/database
sqlite:///path/to/database.db
sqlite:///:memory:
mysql://user:password@localhost:3306/database

Documentation

Full documentation: https://oxyde.fatalyst.dev/

• Quick Start — Get up and running
• User Guide — Models, queries, relations, transactions
• Cheatsheet — Quick reference for all methods

Contributing

If you have suggestions or find a bug, please open an issue or create a pull request on GitHub.

License

This project is licensed under the terms of the MIT license.