WSGI/ASGI Specifications vs. Gunicorn/Uvicorn Servers

1. Summary

The key distinction is:

WSGI and ASGI are specifications (or interfaces). They define how a web server should communicate with a Python web application. WSGI is synchronous, while ASGI is asynchronous. They don't run code themselves; they are like technical standards or blueprints.
Gunicorn and Uvicorn are server implementations. They are actual programs that you run. Gunicorn is primarily a WSGI server that adds concurrency via processes/threads. Uvicorn is primarily an ASGI server that handles concurrency via an asynchronous event loop. Servers implement the rules defined in the specifications.

These define the rules of communication.

WSGI (Web Server Gateway Interface):
- The older, widely adopted standard (PEP 333/3333).
- Defines a synchronous interface.
- An application implementing WSGI handles one request completely before starting the next (within its own execution context).
- Does not inherently include mechanisms for concurrency or protocols like WebSockets.
ASGI (Asynchronous Server Gateway Interface):
- The newer standard, designed for modern needs.
- Defines an asynchronous interface, built around Python's `async`/`await` and event loops.
- Allows applications to handle multiple I/O operations concurrently without blocking.
- Natively supports various protocols beyond HTTP (like WebSockets).

These are the runnable programs that manage connections and execute application code according to a specification.

Gunicorn:
- Primarily a WSGI server implementation.
- Provides the concurrency layer on top of synchronous WSGI applications, usually via:
  1. Multi-Processing: Running multiple independent worker processes (most common with `sync` workers).
  2. Multi-Threading: Using threads within worker processes (`gthread` worker).
- Known for being robust, simple, and excellent at process management in production.
- Can manage ASGI applications, but only by delegating the actual ASGI handling to a compatible worker (like UvicornWorker).
Uvicorn:
- Primarily an ASGI server implementation.
- Built from the ground up for asynchronous operations using an event loop (like `asyncio` or `uvloop`).
- Can handle many concurrent connections efficiently within a single process due to its non-blocking nature.
- Known for high performance with ASGI applications (like FastAPI, modern Django).
- Can be run standalone or used as a worker class managed by Gunicorn for production process management.

Feature/Aspect	WSGI (Specification)	ASGI (Specification)	Gunicorn (Server)	Uvicorn (Server)
Type	Interface Standard	Interface Standard	Server Software	Server Software
Purpose	Define Server <-> Sync App Communication	Define Server <-> Async App Communication	Run WSGI Apps, Manage Processes/Threads	Run ASGI Apps, Manage Async Event Loop
Nature	Synchronous	Asynchronous	Implementation (primarily WSGI)	Implementation (primarily ASGI)
Concurrency Model	None inherent	Event Loop based (inherent in concept)	Provided via Multi-Process / Multi-Thread	Provided via Event Loop (inherent in design)
Handles Concurrency?	No (App is sync)	Yes (App can be async)	Yes (Adds layer over WSGI app)	Yes (Natively async)
How Concurrency Works	N/A	Async/Await, Non-Blocking I/O, Event Loop	Manages multiple sync workers (processes/threads)	Manages async tasks on event loop(s)
Typical Application	Older Django, Flask, Pyramid (sync)	Modern Django, FastAPI, Starlette (async)	Runs WSGI apps	Runs ASGI apps
Key Role	Defines Sync Contract	Defines Async Contract	Process Mgmt, WSGI Execution	High-Perf Async Execution
Can run the other type?	No	Can wrap sync apps (with performance cost)	Yes (via ASGI worker like UvicornWorker)	Yes (can wrap WSGI apps, less common/ideal)

You choose a specification (WSGI or ASGI) based on whether your application code is primarily synchronous or asynchronous.
You choose a server (Gunicorn or Uvicorn) that implements your chosen specification.
Gunicorn implements the WSGI spec and adds concurrency (processes/threads) because WSGI apps can't do it themselves.
Uvicorn implements the ASGI spec and leverages the inherent concurrency potential of ASGI apps via its event loop.
You might use Gunicorn to manage Uvicorn workers in production to combine Gunicorn's robust process management with Uvicorn's high-performance ASGI handling.