=^..^= Pounce

Pure Python ASGI server for Python 3.14t, with a frozen config model and a low-overhead HTTP/1.1 fast path.

import pounce

pounce.run("myapp:app")

What is Pounce?

Pounce is a Python ASGI server for Python 3.14+, with a worker model designed for free-threaded Python 3.14t. It runs standard ASGI applications, supports streaming responses, and gives you a clear upgrade path from process-based servers such as Uvicorn.

Pounce's built-in HTTP/1.1 parser is optimized for the sync worker hot path, its ServerConfig object is frozen after construction, and thread-worker reloads use generational worker swaps with drain behavior.

On Python 3.14t, worker threads share one interpreter and one copy of your app. On GIL builds, Pounce falls back to forked multi-process workers automatically. Apps used with multiple process workers must keep pre-fork state fork-safe: create thread-, executor-, and connection-owning resources in pounce.worker.startup, or use workers=1. See the worker guide.

Why people pick it:

• ASGI-first — Runs standard ASGI apps with CLI and programmatic entry points
• Free-threading native — True thread parallelism with a frozen shared ServerConfig
• Fast-path parsing — Built-in HTTP/1.1 parser for sync workers with tested smuggling and header-limit checks
• Protocol extras — HTTP/2, HTTP/3, and WebSocket are install-gated optional paths with protocol-specific support boundaries
• Thread-worker reloads — Rolling restart uses generational worker swap with drain behavior on supported worker modes
• Observable surfaces — Typed lifecycle events, optional Prometheus metrics, OpenTelemetry, and Server-Timing headers
• Optional helpers — TLS, compression, static files, middleware, rate limiting, and request queueing stay opt-in
• Migration path — Familiar CLI for teams moving from Uvicorn-style deployments

See docs/design/core-contract.md for the supported core, optional helpers, and proof required for public claims.

Use Pounce For

• Serving ASGI apps — Tunable workers, TLS, graceful shutdown, and deployment controls
• Free-threaded Python deployments — Shared-memory worker threads on Python 3.14t
• Streaming workloads — Server-sent events, streamed HTML, and token-by-token responses
• Teams migrating from Uvicorn — Similar CLI shape with a different worker model

Framework Compatibility

Tested in CI with 48 integration tests across every major ASGI framework:

Pounce achieves compatibility through correct ASGI 3.0 implementation — no framework-specific code or workarounds.

Performance

Pounce is designed to make the pure-Python request path competitive while keeping the server core free of C extensions. In a sustained Chirp-shaped GitHub Actions snapshot, four Pounce workers completed every request at a fixed 1,000 req/s target:

The thread-mode sample used about 45% less aggregate peak RSS than the process sample. These are medians from three 120-second samples on GitHub-hosted Ubuntu runners with four persistent connections, not maximum-throughput results or universal targets. The benchmark evidence notes include the uvicorn, Hypercorn, and Granian results, scheduler drops, commands, and raw artifact caveats.

Run pounce bench --workers 4 --compare to reproduce on your machine. For release or PR evidence, use python benchmarks/run_benchmark.py --repeat 5 --artifact-output results.json so the run carries the metadata required by benchmarks/artifact-schema.json and grouped variance across samples. The scheduled/release workflow adds two-minute fixed-rate p50/p99/p999 evidence for Python 3.14 process workers and Python 3.14t thread workers, with uvicorn, Hypercorn, and Granian comparisons where supported.

Key optimizations in the sync worker path:

• Fast HTTP/1.1 parser — Direct bytes parsing is benchmarked separately from h11 and covers method validation, header size limits, duplicate Content-Length, and Content-Length/Transfer-Encoding ambiguity
• Keep-alive connections — Connection reuse eliminates TCP handshake overhead
• Shared socket distribution — Single accept queue for thread workers avoids macOS SO_REUSEPORT limitations

Installation

pip install bengal-pounce

Requires Python 3.14+

Optional extras:

pip install bengal-pounce[h2]     # HTTP/2 stream multiplexing
pip install bengal-pounce[ws]     # WebSocket via wsproto
pip install bengal-pounce[tls]    # TLS with truststore
pip install bengal-pounce[h3]     # HTTP/3 (QUIC/UDP, requires TLS)
pip install bengal-pounce[full]   # All protocol extras

Quick Start

Most settings also live in pounce.toml or pyproject.toml under [tool.pounce]. Run pounce config schema --output-format toml-template for every available field.

Features

📚 Full documentation: lbliii.github.io/pounce | Complete Feature List →

Usage

import pounce

pounce.run(
    "myapp:app",
    host="0.0.0.0",
    port=8000,
    workers=4,
)

from pounce.testing import RoundRobinTestProxy, TestServer
import httpx

def test_homepage(my_app):
    with TestServer(my_app) as server:
        resp = httpx.get(f"{server.url}/")
        assert resp.status_code == 200

def test_api(pounce_server, my_app):
    server = pounce_server(my_app)
    resp = httpx.get(f"{server.url}/health")
    assert resp.status_code == 200

Key Ideas

• Free-threading first. Threads, not processes. One interpreter, N event loops, and a frozen shared ServerConfig. On GIL builds, falls back to multi-process automatically.
• Pure Python. No Rust, no C extensions in the server core. Debuggable, hackable, readable.
• Typed end-to-end. Frozen config, typed ASGI definitions, and no new type suppressions without review.
• Lean dependencies. Two required runtime deps: h11 for HTTP/1.1 parsing and milo-cli for the CLI. The request hot path depends only on h11; everything else is optional.
• Observable by design. Lifecycle events are public API — from pounce import BufferedCollector, ResponseCompleted. Frameworks build dashboards on typed events, not log parsing.
• Framework tested. Verified against FastAPI, Starlette, Django, and Litestar with 48 integration tests.
• Optional helpers. Static files, middleware, rate limiting, request queueing, Prometheus metrics, Sentry, and OpenTelemetry are available without becoming mandatory request-path dependencies.

Documentation

📚 lbliii.github.io/pounce

Development

git clone https://github.com/lbliii/pounce.git
cd pounce
uv sync --group dev
pytest

See CONTRIBUTING.md for setup, feedback loops, and recipes (how to add a test, a config field, or an error). Read AGENTS.md for the project's design philosophy and stop-and-ask escape hatches.

The Bengal Ecosystem

A structured reactive stack — every layer written in pure Python for 3.14t free-threading.

Python-native. Free-threading ready. No npm required.

License

MIT