spikard 0.13.0

High-performance Python web framework with a Rust core. Build REST APIs, WebSockets, and SSE services with FastAPI/Litestar-style decorators backed by Axum and Tower-HTTP. 2.8x faster than FastAPI.

Spikard Python

High-performance Python web framework backed by a Rust core. Build REST APIs, WebSockets, and SSE services with FastAPI/Litestar-style decorators powered by Tokio, Hyper, and Tower middleware.

Features

• Multiple route styles: FastAPI-style (@app.get()) or Litestar-style (@get())
• Automatic validation: msgspec (default), Pydantic v2, dataclasses, TypedDict, NamedTuple
• Request/response streaming: WebSockets, Server-Sent Events, multipart uploads
• Middleware stack: Compression, rate limiting, request IDs, authentication, CORS
• Async-first: Full async/await with pyo3_async_runtimes
• OpenAPI generation: Automatic type introspection and documentation
• Dependency injection: Configurable container with singleton and factory support

Installation

pip install spikard

Pre-built wheels available for macOS, Linux, Windows. Building from source requires Rust 1.75+.

Development:

cd packages/python && uv sync

Requirements: Python 3.10+

Quick Start

from spikard import Spikard
from spikard.config import ServerConfig
from msgspec import Struct

class User(Struct):
    id: int
    name: str
    email: str

app = Spikard()

@app.get("/users/{user_id}")
async def get_user(user_id: int) -> User:
    return User(id=user_id, name="Alice", email="[e-mail]")

@app.post("/users")
async def create_user(user: User) -> User:
    # Automatic validation via msgspec
    return user

if __name__ == "__main__":
    app.run(config=ServerConfig(port=8000))

Core Concepts

Route Decorators:

from spikard import Spikard, get, post

app = Spikard()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id}

@post("/users")  # Standalone decorator style
async def create_user(user: User):
    return user
# Note: standalone decorators require app.include_router(get_default_router()) before app.run()

Validation with msgspec (recommended):

from msgspec import Struct

class User(Struct):
    name: str
    email: str

@app.post("/users")
async def create_user(user: User):
    return user  # Automatic validation

Dependency Injection:

from spikard.di import Provide

class DatabasePool:
    async def fetch(self, sql: str) -> list: ...

def create_pool() -> DatabasePool:
    return DatabasePool()

app.provide(DatabasePool, Provide(create_pool, singleton=True))

@app.get("/data")
async def get_data(pool: DatabasePool) -> dict:
    return {"data": await pool.fetch("SELECT * FROM items")}

WebSockets:

from spikard import websocket

@app.websocket("/ws")
async def chat_endpoint(message: dict) -> dict | None:
    return {"echo": message}

Server-Sent Events:

from spikard import sse

@sse("/events")
async def stream():
    for i in range(10):
        yield {"count": i}

Lifecycle Hooks:

@app.pre_validation
async def check_auth(request):
    if not request.headers.get("authorization"):
        return Response({"error": "Unauthorized"}, 401)
    return request

Configuration

from spikard import Spikard, ServerConfig, CompressionConfig, RateLimitConfig, JwtConfig

config = ServerConfig(
    host="0.0.0.0",
    port=8080,
    workers=4,
    compression=CompressionConfig(gzip=True, brotli=True),
    rate_limit=RateLimitConfig(per_second=100, burst=200),
    jwt=JwtConfig(secret="key", algorithm="HS256")
)

app = Spikard(config=config)

See the documentation for all options.

Performance

Benchmarked across 34 workloads at 100 concurrency (methodology):

Framework	Avg RPS	P50 (ms)	P99 (ms)
spikard	12,623	5.55	38.39
litestar	8,032	14.62	19.18
fastapi	6,418	16.43	21.72
robyn	6,012	16.85	24.18

Spikard is 1.6x faster than Litestar (throughput-based; see full results for latency breakdown), 2.0x faster than FastAPI, and 2.1x faster than Robyn (also Rust-backed).

Key optimizations:

• Zero-copy PyO3 type conversion (no JSON round-trips)
• Rust-powered HTTP server (Tokio + Hyper)
• GIL-friendly async design with pyo3_async_runtimes

Testing

from spikard.testing import TestClient

async def test_users():
    async with TestClient(app) as client:
        response = await client.get("/users/123")
        assert response.status_code == 200
        assert response.json()["id"] == 123

TestClient uses in-process Rust testing for speed. LiveTestClient starts a real subprocess server for WebSocket/SSE tests.

See the main documentation for WebSocket and SSE testing.

Examples

Runnable examples with dependency injection and database integration:

• Python examples
• GraphQL schema support
• OpenAPI code generation

See examples/README.md for all languages and code generation.

Documentation

Full documentation at spikard.dev. See also CONTRIBUTING.md.

Other Languages

• Rust: Crates.io
• Python: PyPI
• TypeScript: npm (@spikard/node)
• Ruby: RubyGems
• PHP: Packagist
• Elixir: Hex.pm

License

MIT - See LICENSE for details