Introducing Nexios: The Simple Yet Powerful Alternative to FastAPI

If you’re a Python developer working with web frameworks, you’ve probably used Flask for its simplicity or FastAPI for its performance and type safety. But what if you could have the best of both worlds? Enter Nexios — a high-performance Python web framework that combines the simplicity of Flask with the power of modern Python features, all while giving FastAPI a run for its money.

Why Another Python Web Framework?

In the world of Python web development, we’ve had to choose between:

• Flask: Simple but can get unwieldy for larger applications
• FastAPI: Powerful but with a steeper learning curve
• Django: Batteries-included but opinionated and heavy

Nexios was born from the need for a framework that’s as easy to use as Flask but with modern features like async support, automatic OpenAPI documentation, and Pydantic validation out of the box.

Nexios at a Glance

from nexios import NexiosApp
app = NexiosApp()@app.get("/")
async def home(request, response):
    return response.json({"message": "Hello, Nexios!"}))

Just like that, you have a fully functional API with automatic OpenAPI documentation at /docs and /redoc!

Why Developers Are Switching to Nexios

1. Intuitive Handler Signature

@app.get("/users/{user_id}")
async def get_user(request, response, user_id: int):
    user = await get_user_by_id(user_id)
    return response.json(user)

2. Chainable Response Methods

@app.get("/api/data")
async def get_data(request, response):
    return (
        response
        .status(200)
        .header("X-Custom-Header", "value")
        .json({"data": "Hello, Nexios!"})
    )

3. Powerful Response Building

@app.get("/user-profile")
async def user_profile(request, response):
    user = await get_current_user(request)
    if not user:
        return response.status(401).json({"error": "Unauthorized"})
    return (
        response
        .status(200)
        .header("Cache-Control", "public, max-age=3600")
        .json({"user": user, "timestamp": datetime.utcnow().isoformat()})
    )

4. Built-in Error Handling

@app.get("/protected")
async def protected_route(request, response):
    if not request.headers.get("Authorization"):
        return response.status(401).json_error("Authentication required")

    try:
        data = await fetch_protected_data()
        return response.json(data)
    except Exception as e:
        return response.status(500).json_error(str(e))

5. Full-Stack Ready

Nexios isn’t just for APIs. It comes with built-in support for:

• WebSockets for real-time features
• File uploads and static file serving
• Template rendering
• Session management
• JWT Authentication
• Built-in CORS support
• Custom error handling
• Middleware support

Dependency Injection

from nexios import Depend
async def get_db_connection():
    db = await create_db_connection()
    try:
        yield db
    finally:
        await db.close()
async def get_current_user(request):
    token = request.headers.get("Authorization")
    return await verify_token(token)
@app.get("/profile")
async def user_profile(
    request,
    response,
    db = Depend(get_db_connection),
    current_user = Depend(get_current_user)
):
    profile = await db.get_user_profile(current_user.id)
    return response.json(profile)

Templating

from nexios import NexiosApp
from nexios.templating import render, TemplateEngine
app = NexiosApp()
engine = TemplateEngine()
engine.setup_environment(template_dir="templates")
def add_global_context():
    return {"version": "1.0.0", "year": 2023}
engine.add_context_processor(add_global_context)
@app.get("/")
async def home(request, response):
    return await render(
        "index.html",
        {"title": "Welcome to Nexios"},
        request=request
    )

Real-World Example: Building an E-commerce API

from typing import List
from pydantic import BaseModel
from nexios import NexiosApp
app = NexiosApp()
class Product(BaseModel):
    id: int
    name: str
    price: float
    in_stock: bool = True
class Order(BaseModel):
    id: int
    user_id: int
    products: List[Product]
    status: str = "pending"
class ProductService:
    def __init__(self):
        self.products = {
            1: Product(id=1, name="Laptop", price=999.99),
            2: Product(id=2, name="Smartphone", price=499.99),
        }
    async def get_product(self, product_id: int):
        return self.products.get(product_id)
@app.get("/products/{product_id}")
async def get_product(request, response, product_id: int):
    product = await ProductService().get_product(product_id)
    if not product:
        return response.status(404).json_error("Product not found")
    return response.json(product)
@app.post("/orders")
async def create_order(request, response, product_ids: List[int]):
    products = []
    for pid in product_ids:
        product = await ProductService().get_product(pid)
        if not product or not product.in_stock:
            return response.status(400).json_error(f"Product {pid} not available")
        products.append(product)
    order = Order(id=1, user_id=1, products=products)
    return response.json({"order": order.dict()})

Why Choose Nexios Over FastAPI?

1. Simpler Learning Curve
2. More Flexible DI
3. Built-in Best Practices
4. Lighter Weight
5. Better Developer Experience

Getting Started

pip install nexios
python -m uvicorn main:app --reload

Then visit http://localhost:8000/docs to explore your API docs!

Join the Nexios Community

• GitHub Repository
• Documentation
• Discord Community

Have you tried Nexios yet? What was your experience like? Let me know in the comments below!