Flaxon

Principal Author: Aldane Hutchinson

Flaxon is an async-first ASGI framework for JSON APIs, WebSockets, and server-rendered applications. It provides the HTTP boundary; you choose the database, frontend, queue, and deployment platform.

i Would love for other Developers to help me maintain this codebase

Run full test suite well make sure if add or change something it not broken and benchmarks as well .

Status: Production/stable.

it says Stable but am adding things still and api may change a little but not alot.

check out Teloce-py it complier that complies .vel single components to vanilla js for browser serving. is works well with flaxon or flask or any.

Install

Flaxon requires Python 3.11 or newer.

pip install "flaxon[standard]"

standard installs the recommended ASGI server and template dependencies. For framework development, install pip install -e ".[standard,dev]" instead.

Your first API

Create app.py:

from flaxon import Flaxon

app = Flaxon("hello-api", debug=True)


@app.get("/")
async def home():
    return {"message": "Hello from Flaxon"}


@app.get("/users/<int:user_id>")
async def get_user(user_id: int):
    return {"id": user_id, "name": "Example User"}

Start the development server:

flaxon run app:app --reload

Open http://127.0.0.1:8000/. For a production process, use flaxon run without --reload or run the same ASGI application with Uvicorn.

Validate JSON input

Use Schema parameters for JSON request bodies. Field names use the full *Field spelling.

from flaxon.validation import Schema, fields


class CreateUser(Schema):
    name = fields.StrField(required=True, min_length=2, max_length=80)
    email = fields.EmailField(required=True)
    age = fields.IntField(minimum=13, maximum=120)


@app.post("/users")
async def create_user(data: CreateUser):
    return {"user": data.to_dict()}

Available field classes are StrField, IntField, FloatField, BoolField, EmailField, DateField, DateTimeField, DecimalField, UUIDField, ListField, ChoiceField, NestedField, and AnyField.

WebSockets

from flaxon.websocket import WebSocket


@app.websocket("/ws/chat/<room_id>")
async def chat(socket: WebSocket, room_id: str):
    await socket.accept()
    await socket.join(room_id)
    try:
        async for message in socket.iter_json():
            await socket.broadcast_json(room_id, {"event": "chat.message", "data": message})
    finally:
        await socket.leave(room_id)

The default room manager is in-process. Use shared infrastructure for cross-worker or multi-instance broadcasts.

Server-rendered HTML with Jinax

Install the template extra if it is not already included through standard:

pip install "flaxon[templates]"

from flaxon.jinax import Jinax

app.use_templates(Jinax("templates", auto_reload=True))


@app.get("/")
async def home(request):
    return await request.render("home.html", {"title": "Welcome"})

Jinax uses Jinja2 autoescaping for HTML templates. Only mark content safe when it has been produced by a trusted sanitizer.

What Flaxon includes

• HTTP routing, typed path parameters, request parsing, responses, and streams.
• Schema validation and validation decorators.
• Middleware for CORS, request IDs, security headers, trusted hosts, body limits, compression, logging, recovery, sessions, and timeouts.
• Sessions, JWT, API keys, authentication, roles, permissions, CSRF, and rate limiting.
• WebSocket routes, JSON messaging, rooms, and broadcast helpers.
• Jinax templates, caching helpers, database adapters/transactions, background tasks, plugins, OpenAPI, GraphQL, health checks, and metrics.
• TestClient and AsyncWebSocketClient for application tests.
• Built in admin and Cms and Plugins there some not alot search flaxon and find some plugins.

Documentation and examples

• Documentation home
• Quick start
• Growing a 200-page application
• Deployment
• Security
• Examples

The runnable example applications live in docs/examples/: a basic API, React backend, Android backend, and Jinax site.

Production checklist

• Set DEBUG=False and a strong FLAXON_SECRET_KEY.
• Use explicit allowed origins and trusted hosts.
• Run multiple workers only after moving shared state (sessions, cache, task coordination, and WebSocket fan-out) to durable/shared infrastructure.
• Run behind TLS and a reverse proxy or managed load balancer.
• Add database migrations, backups, health checks, metrics, structured logs, and load tests for your deployment topology.

See the deployment guide for the complete checklist.

Contributing

git clone https://github.com/aldanedev-create/Flaxon-Backend-Framework.git
cd Flaxon-Backend-Framework
python -m venv .venv
# Activate the environment, then:
pip install -e ".[standard,dev]"
pytest

Flaxon is released under the MIT License.