Chirp vs Flask vs FastAPI — When Free-Threading Matters

from flask import Flask, request, render_template

app = Flask(__name__)

@app.route("/search")
def search():
    q = request.args.get("q", "")
    books = find_books(q)
    if request.headers.get("HX-Request"):
        return render_template("search.html", books=books, block="results")
    return render_template("search.html", books=books)

# Manual branch. Forget the HX-Request check once and you get
# full page inside a div. No type-level contract.

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/search")
async def search(request: Request, q: str = ""):
    books = find_books(q)
    if request.headers.get("hx-request"):
        return templates.TemplateResponse(
            "partials/results.html",
            {"request": request, "books": books}
        )
    return templates.TemplateResponse(
        "search.html", {"request": request, "books": books}
    )

# Same manual branch. FastAPI typically uses separate partial templates
# (partials/results.html) rather than block rendering. Two templates
# to maintain for one logical view.

@app.route("/contacts", methods=["POST"])
def add_contact():
    form = request.form
    errors = validate_contact(form)
    if errors:
        return render_template("partials/form.html", errors=errors, form=form), 422
    add_contact(form["name"], form["email"])
    contacts = get_contacts()
    # Must render two partials, add hx-swap-oob to each, concatenate
    table = render_template("partials/table.html", contacts=contacts)
    count = render_template("partials/count.html", count=len(contacts))
    return table + count  # or use a wrapper that adds OOB attributes
# No built-in OOB. You manually add hx-swap-oob="target:id" to each fragment.

@app.post("/contacts")
async def add_contact(request: Request):
    form = await request.form()
    errors = validate_contact(form)
    if errors:
        return templates.TemplateResponse("partials/form.html", {...}, status_code=422)
    add_contact(form["name"], form["email"])
    contacts = get_contacts()
    table = templates.TemplateResponse("partials/table.html", {...})
    count = templates.TemplateResponse("partials/count.html", {...})
    # HTMX OOB requires concatenating HTML with hx-swap-oob on each part
    # No built-in OOB type. Manual concatenation or custom response builder.

@app.route("/")
def index():
    # No native streaming with concurrent I/O. Options:
    # 1. Block: stats, feed = sync_fetch_both() — no concurrency
    # 2. ThreadPool: run async in thread, block — awkward
    # 3. SSE: different pattern, not progressive HTML
    stats = load_stats_sync()
    feed = load_feed_sync()
    return render_template("dashboard.html", stats=stats, feed=feed)

@app.get("/")
async def index():
    stats, feed = await asyncio.gather(load_stats(), load_feed())
    return templates.TemplateResponse("dashboard.html", {"request": request, "stats": stats, "feed": feed})
# Can do concurrent fetch, but no progressive HTML streaming.
# For StreamingResponse you'd build a custom generator.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello, World!"

# Run: gunicorn -w 4 app:app

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def index():
    return "Hello, World!"

# Run: uvicorn app:app --workers 4