ignyx 3.1.0

Rust-powered Python web framework — 10x faster than FastAPI

Ignite your API. Built in Rust, runs in Python.

Ignyx

📖 Full Documentation

Ignyx is a next-generation Python web framework engineered for maximum throughput, utilizing a Rust-powered HTTP core built on Hyper and Tokio. It provides a familiar, FastAPI-like decorator syntax, allowing developers to build high-performance APIs with zero learning curve. In honest benchmarks, Ignyx operates 8-9x faster than standard Python async frameworks.

Features

• Blazing Fast: 8-9x faster than FastAPI in standard benchmarks.
• Zero Overhead: Owns the full HTTP pipeline — no ASGI overhead.
• Hot Reload: Blazing fast development with built-in file watcher.
• Pydantic v2: Deep integration for request body validation.
• Modern API Docs: Ships with Scalar at /scalar, plus Swagger UI and ReDoc.
• Advanced OpenAPI: Auto-generates schemas with Pydantic model support.
• Built-in Pagination: Standard limit/offset pagination with typed page envelopes.
• Dependency Injection: Familiar Depends() pattern for clean logic.
• WebSockets: Native, high-concurrency WebSocket support.
• Modular: Organize APIs with Router prefixes.
• Typed: Shipped with py.typed for perfect IDE autocompletion.

Benchmark

Apple M2, wrk -t4 -c100 -d10s

Endpoint	Ignyx	FastAPI	Speedup
/plaintext	51,771 req/s	5,846 req/s	🔥 8.8x
/json	37,138 req/s	4,844 req/s	🔥 7.6x
/users/{id}	43,261 req/s	5,306 req/s	🔥 8.1x

Note: Ignyx tested with native Rust core. FastAPI tested with Uvicorn single worker — standard config.

Installation

pip install ignyx==3.1.0

Or with uv:

uv add ignyx

Quickstart

from ignyx import Ignyx

app = Ignyx()

@app.get("/")
async def root(request):
    return {"message": "Hello from Ignyx!"}

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, reload=True)

When the app is running, Ignyx serves docs out of the box:

• Scalar API Reference: http://localhost:8000/scalar
• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc
• OpenAPI JSON: http://localhost:8000/openapi.json

What's New In 3.1

Modern API Docs

Ignyx now ships with a modern Scalar-powered API reference at /scalar by default, while keeping Swagger UI and ReDoc available for teams that want multiple documentation surfaces.

from ignyx import Ignyx

app = Ignyx()

# Defaults:
# /scalar       -> Scalar API reference
# /docs         -> Swagger UI
# /redoc        -> ReDoc
# /openapi.json -> OpenAPI schema

Built-in Pagination

Use paginate() to read limit and offset directly from the incoming request and return a consistent Page[T] response shape.

from ignyx import Ignyx
from ignyx.pagination import Page, paginate
from ignyx.request import Request
from pydantic import BaseModel

app = Ignyx()

class UserOut(BaseModel):
    id: int
    name: str

USERS = [
    UserOut(id=1, name="Ada"),
    UserOut(id=2, name="Linus"),
    UserOut(id=3, name="Grace"),
]

@app.get("/users")
def list_users(request: Request) -> Page[UserOut]:
    return paginate(request, USERS, default_limit=2)

Response shape:

{
  "total_items": 3,
  "next_page": "/users?limit=2&offset=2",
  "items": [
    {"id": 1, "name": "Ada"},
    {"id": 2, "name": "Linus"}
  ]
}

Feature Examples

Pydantic Validation

from ignyx import Ignyx
from pydantic import BaseModel

app = Ignyx()

class User(BaseModel):
    name: str
    age: int

@app.post("/users")
async def create_user(user: User):
    return {"status": "success", "data": user.model_dump()}

Path + Query Parameters

from ignyx import Ignyx

app = Ignyx()

@app.get("/users/{id}")
async def get_user(id: int, format: str = "json"):
    return {"id": id, "format": format}

Dependency Injection

from ignyx import Ignyx, Depends

app = Ignyx()

def get_db():
    db = Database()
    try:
        yield db
    finally:
        db.close()

@app.get("/users")
async def get_users(db = Depends(get_db)):
    return db.query("SELECT * FROM users")

WebSockets

from ignyx import Ignyx

app = Ignyx()

@app.websocket("/echo")
async def echo_server(ws):
    await ws.accept()
    while True:
        data = await ws.receive_text()
        await ws.send_text(f"Echo: {data}")

Comparison vs FastAPI

Feature	Ignyx	FastAPI
Pydantic v2 validation	✅	✅
Async/Await	✅	✅
Dependency Injection	✅	✅
WebSockets	✅	✅
Modular Routers	✅	✅
Performance (req/s)	~50k	~6k
ASGI overhead	❌ None	✅ Yes
Hot Reload	✅	✅
Native Rust Core	✅	❌

Contributing

We welcome contributions! Please see our Contributing Guide for details on how to set up your development environment.

Deployment Note

Ignyx manages its own Tokio runtime. No Uvicorn or Gunicorn needed. Just python app.py.

License

This project is licensed under the MIT License.

Documentation Site

The documentation site in docs/ is powered by MkDocs Material and published at:

• https://sakethdevx.github.io/ignyx/docs/

It now documents the new Scalar API reference and built-in pagination introduced in 3.1.0.