Sillo

Build serious Python backends with one coherent application model.

Sillo is an async Python web framework for building APIs, web applications, real-time systems, and business backends. It focuses on practical enterprise application work: routing, request validation, dependency injection, middleware, sessions, authentication helpers, records, background work, WebSockets, OpenAPI, testing, and operational structure.

Sillo is the open framework layer of a larger platform vision: a cohesive developer ecosystem for creating, operating, and scaling serious software without stitching together unrelated tools for every project.

Status

Sillo is preparing for its first alpha release: 0.0.1a1.

Use it for exploration, prototypes, early applications, and feedback. APIs may still change before a stable release.

Requirements

• Python 3.10+
• uv for project and dependency management

Installation

uv add sillo

For optional feature groups:

uv add "sillo[cli]"
uv add "sillo[templating]"
uv add "sillo[jwt]"
uv add "sillo[cache]"
uv add "sillo[record]"
uv add "sillo[graphql]"

For a full development setup:

uv add "sillo[all]"

Hello World

from sillo import silloApp

app = silloApp(title="My API")


@app.get("/")
async def home(request, response):
    return response.json({"message": "Hello from Sillo"})

Run it with an ASGI server:

uv add uvicorn
uv run uvicorn main:app --reload

Request Validation

Sillo validates request bodies with Pydantic through request_model.

from pydantic import BaseModel
from sillo import silloApp

app = silloApp()


class CreateUser(BaseModel):
    name: str
    email: str


@app.post("/users", request_model=CreateUser)
async def create_user(request, response, user: CreateUser):
    return response.json(user.model_dump(), status_code=201)

The validated model is also available as request.validated_data.

Dependency Injection

Use Depend to inject request-scoped dependencies into handlers.

from sillo import Depend, silloApp

app = silloApp()


async def get_current_user():
    return {"id": "user_1", "name": "Ada"}


@app.get("/me")
async def me(request, response, user=Depend(get_current_user)):
    return response.json(user)

When a dependency needs the current request:

from sillo import Depend


def auth_header(request=Depend(get_request=True)):
    return request.headers.get("Authorization")

Routing

from sillo import Router, silloApp

app = silloApp()
api = Router(prefix="/api")


@api.get("/users/{user_id:int}")
async def get_user(request, response, user_id: int):
    return response.json({"id": user_id})


app.mount_router(api)

What Sillo Provides

• Async ASGI application core
• HTTP routing, route groups, and mounted routers
• Request and response helpers
• Pydantic request validation
• Dependency injection with nested dependencies
• Query, header, and cookie parameter helpers
• Middleware pipeline
• CORS and CSRF support
• Sessions and authentication utilities
• API keys, JWT helpers, users, permissions, and guards
• OpenAPI generation and interactive docs
• File uploads, streaming responses, static files, and frontend fallback serving
• WebSockets, consumers, channels, groups, events, and history helpers
• Cache abstraction with memory and Redis support
• Event system and background work primitives
• Record layer for database-backed models, transactions, scopes, casting, and pagination
• Mail service utilities
• Test client utilities
• CLI for running and inspecting applications

Platform Direction

Sillo Core is intended to become the technical foundation for a broader enterprise developer platform:

• Miko: visual admin studio for records, workflows, and internal operations
• Zoro: managed deployment for Sillo applications
• Koda: server management and deployment automation for customer-controlled infrastructure
• Nira: authentication, organisations, access control, and identity services
• Piko: logs, queues, jobs, releases, health, and application monitoring
• Template and integration marketplaces: reusable application foundations and verified integrations

The open-source framework should remain useful on its own. Commercial products should remove operational work, not lock normal application development behind a paywall.

Documentation

The documentation source lives in docs/docs.

Build it locally with:

cd docs/docs
bun run build

Testing

Run the core test suite with:

python3 -m pytest -q

Some optional integrations require their extras to be installed before their tests can run.

Release Principles

Sillo prioritizes:

• clear APIs and useful error messages
• strong defaults with replaceable internals
• production-oriented documentation
• compatibility, migration guidance, and honest release notes
• security and reliability before broad platform expansion

License

BSD-3-Clause