Oxyde – Pydantic-native async ORM with a Rust core

Hi HN! I built Oxyde because I was tired of duplicating my models.If you use FastAPI, you know the drill. You define Pydantic models for your API, then define separate ORM models for your database, then write converters between them. SQLModel tries to fix this but it's still SQLAlchemy underneath. Tortoise gives you a nice Django-style API but its own model system. Django ORM is great but welded to the framework.I wanted something simple: your Pydantic model IS your database model. One class, full validation on input and output, native type hints, zero duplication. The query API is Django-style (.objects.filter(), .exclude(), Q/F expressions) because I think it's one of the best designs out there.Explicit over implicit. I tried to remove all the magic. Queries don't touch the database until you call a terminal method like .all(), .get(), or .first(). If you don't explicitly call .join() or .prefetch(), related data won't be loaded. No lazy loading, no surprise N+1 queries behind your back. You see exactly what hits the database by reading the code.Type safety was a big motivation. Python's weak spot is runtime surprises, so Oxyde tackles this on three levels: (1) when you run makemigrations, it also generates .pyi stub files with fully typed queries, so your IDE knows that filter(age__gte=...) takes an int, that create() accepts exactly the fields your model has, and that .all() returns list[User] not list[Any]; (2) Pydantic validates data going into the database; (3) Pydantic validates data coming back out via model_validate(). You get autocompletion, red squiggles on typos, and runtime guarantees, all from the same model definition.Why Rust? Not for speed as a goal. I don't do "language X is better" debates. Each one is good at what it was made for. Python is hard to beat for expressing business logic. But infrastructure stuff like SQL generation, connection pooling, and row serialization is where a systems languag

Hacker NewsMar 13ToolDevSource

FL score

out of 100

Verdict

VALIDATE

high confidence

Competition

competitors found, emerging market, funded players

Trend

No signal yet

A Pydantic-native async ORM with a Rust core, targeting FastAPI developers to eliminate model duplication and boost performance, faces high build complexity in a crowded market.

The pain

FastAPI developers currently suffer from model duplication (Pydantic for API, separate ORM models), complex converters, performance overheads, and surprise N+1 queries with existing async ORMs. This leads to wasted development time, increased bug surface, and slower applications.

The gap

While many ORMs exist, none combine true Pydantic-nativeness (one model definition for API and DB) with a performance-oriented Rust core, explicit query loading (preventing N+1), and a Django-style API. Existing solutions like SQLModel are still SQLAlchemy-based, and others lack strong documentation or full Pydantic integration, creating a specific whitespace for developers prioritizing type safety, performance, and simplicity.

Build angle

Focus on being the absolute simplest, most performant Pydantic-native async ORM for FastAPI + Postgres users, with a clear migration path and superior developer experience by eliminating boilerplate and N+1 queries 'by design'.

Strengths

Addresses a deeply felt, specific pain for FastAPI/async Python developers (model duplication, N+1 queries, performance).
Strong technical differentiation with a Rust core and Pydantic-native design.

Questions about this idea?

FlyBot reads the scoring and gives you a second opinion on “Oxyde – Pydantic-native async ORM with a Rust core”.

Open FlyBot

Fly Labs Method

Is the pain real, is there a gap, is it the right time, can one person build it.

Problem clarity: 26
Solution gap: 19
Willingness to pay: 19
Buildability: 5

This idea addresses significant pain points for FastAPI developers regarding model duplication and ORM performance, offering a unique Rust-powered, Pydantic-native solution. However, the market is crowded with strong incumbents, and the build/maintenance effort for a solo founder is exceptionally high.

Value Equation

Dream outcome and how likely it feels, against the time and effort it costs.

Addresses a clear developer pain in a growing market with a differentiated technical approach, but faces high build complexity and intense competition.

One-Person Business

Curiosity pull, identity fit, and a path from free value to paid for a solo creator.

Highly complex project with clear problem clarity but low solo creator fit, high build complexity, and challenging monetization in a crowded market.

Viral Frameworks

Hook strength, shareability, and how cheaply it can be tested.

Clear value proposition for a specific audience, but high risk due to open-source business model, build complexity, and crowded market.

Builder Lens

Evidence the problem exists, timing, defensibility, and a model that fits on a napkin.

Strong demand for solving a clear problem in a growing ecosystem, but the narrowest wedge for a solo founder is already quite large, and competitive forces are significant.

Why this verdict

The idea scores well on problem clarity, value proposition, and market potential, indicating a real need. However, the buildability for a solo founder is exceptionally low due to the complexity of an ORM with a Rust core. The market is also highly crowded, making it challenging to gain traction and monetize. While there's a clear 'gap' in the feature set, the sheer competitive landscape and the monumental effort required mean the project carries significant risks for a solo builder. It's too complex to 'just build' and requires careful validation of demand for a paid offering or significant community/contributor interest before committing further time.

Five lenses, one composite. How scoring works

The angle

This weekend

Conduct in-depth interviews with FastAPI developers currently using SQLModel, Tortoise, or SQLAlchemy to deeply understand specific breaking points and willingness to pay for a solution.
Focus on building a small, hyper-performant, and perfectly Pydantic-native core for a single common use case (e.g., simple CRUD for two related models) and get real users to try it.
Explore potential monetization models (e.g., enterprise features, managed services, support, commercial licenses) and validate demand for these before significant further investment.
Build a strong developer community around the project to help with maintenance and contributions, as solo effort is unsustainable for a project of this scope.

Who is already there, emerging market

SQLModel
Library that allows creating Pydantic models that are also SQLAlchemy ORM models, minimizing duplication for FastAPI apps. Supports async via SQLAlchemy async.
Pricing: free
Tortoise ORM
Async ORM for Python that uses Pydantic models for type safety and validation, compatible with FastAPI.
Pricing: free
Ormar
Async mini-ORM that extends SQLAlchemy models with Pydantic validation, reducing model duplication in async apps.
Pricing: free
Piccolo ORM
Async, type-safe ORM with Pydantic integration for FastAPI, focusing on performance.
Pricing: free
Masonite ORM Async (async-orm)
Async ORM built for FastAPI and other async frameworks, based on Masonite ORM.
Pricing: free
SQLAlchemyVisit
A well-known and widely used ORM for Python, providing extensive control over database models and behavior. It uses a two-level internal architecture with Core and ORM components.
Pricing: Open Source
Django ORMVisit
The ORM integrated with the Django web framework, known for its powerful features and migration management system.
Pricing: Open Source
Prisma (Python Client)FundedVisit
Prisma provides a modern DB toolkit to query, migrate, and model your database. The Python client offers a cleaner API to fetch data from databases and supports introspection.
Pricing: Open Source (with potential for commercial offerings from Prisma, Inc.)
PiccoloVisit
An async query builder and ORM that can auto-generate Pydantic models from database tables.
Pricing: Open Source
EdgyVisit
A modern, full-suite ORM built on Pydantic v2, offering migrations and automatic validations.
Pricing: Open Source
pydynoxVisit
A fast, async-first DynamoDB ORM for Python with a Rust core, offering Pydantic support and a class-based API.
Pricing: Open Source

Funded players

Gaps they leave open

Rust core for superior performance
Native async without SQLAlchemy overhead
Avoidance of common ORM pitfalls like N+1 queries at scale
Seamless Pydantic integration without extra configuration

Oxyde – Pydantic-native async ORM with a Rust core

Excessive CAPTCHA challenges degrading GitHub login UX for enterprise users

GTA modders tediously manually edit assembly files for modpacks

BreezePDF – Free, in-browser PDF editor