+
+ Home
+ Return to the homepage
+
+
+ Quickstart
+ Get started with Gunicorn
+
+
+ Settings
+ Configuration reference
+
+
+ Report Issue
+ Let us know about broken links
+
+
diff --git a/docs/content/asgi.md b/docs/content/asgi.md
new file mode 100644
index 00000000..8cc51b4b
--- /dev/null
+++ b/docs/content/asgi.md
@@ -0,0 +1,241 @@
+# ASGI Worker
+
+!!! warning "Beta Feature"
+ The ASGI worker is a beta feature introduced in Gunicorn 24.0.0. While it has been tested,
+ the API and behavior may change in future releases. Please report any issues on
+ [GitHub](https://github.com/benoitc/gunicorn/issues).
+
+Gunicorn includes a native ASGI worker that enables running async Python web frameworks
+like FastAPI, Starlette, and Quart without external dependencies like Uvicorn.
+
+## Quick Start
+
+```bash
+# Install gunicorn
+pip install gunicorn
+
+# Run an ASGI application
+gunicorn myapp:app --worker-class asgi --workers 4
+```
+
+For FastAPI applications:
+
+```bash
+gunicorn main:app --worker-class asgi --bind 0.0.0.0:8000
+```
+
+## Features
+
+The ASGI worker provides:
+
+- **HTTP/1.1** with keepalive connections
+- **WebSocket** support for real-time applications
+- **Lifespan protocol** for startup/shutdown hooks
+- **Optional uvloop** for improved performance
+- **SSL/TLS** support
+
+## Configuration
+
+### Worker Class
+
+Set the worker class to `asgi`:
+
+```bash
+gunicorn myapp:app --worker-class asgi
+```
+
+Or in a configuration file:
+
+```python
+# gunicorn.conf.py
+worker_class = "asgi"
+```
+
+### Event Loop
+
+Control which asyncio event loop implementation to use:
+
+| Value | Description |
+|----------|-------------|
+| `auto` | Use uvloop if available, otherwise asyncio (default) |
+| `asyncio`| Use Python's built-in asyncio event loop |
+| `uvloop` | Use uvloop (must be installed separately) |
+
+```bash
+gunicorn myapp:app --worker-class asgi --asgi-loop uvloop
+```
+
+To use uvloop, install it first:
+
+```bash
+pip install uvloop
+```
+
+### Lifespan Protocol
+
+The lifespan protocol lets your application run code at startup and shutdown.
+This is essential for frameworks that need to initialize database connections,
+caches, or background tasks.
+
+| Value | Description |
+|--------|-------------|
+| `auto` | Detect if app supports lifespan, enable if so (default) |
+| `on` | Always run lifespan protocol (fail if unsupported) |
+| `off` | Never run lifespan protocol |
+
+```bash
+gunicorn myapp:app --worker-class asgi --asgi-lifespan on
+```
+
+Example FastAPI application using lifespan:
+
+```python
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+ # Startup: initialize resources
+ print("Starting up...")
+ yield
+ # Shutdown: cleanup resources
+ print("Shutting down...")
+
+app = FastAPI(lifespan=lifespan)
+```
+
+### Root Path
+
+When running behind a reverse proxy that mounts your application at a subpath,
+set `root_path` so your application knows its mount point:
+
+```bash
+gunicorn myapp:app --worker-class asgi --root-path /api
+```
+
+This is equivalent to the `SCRIPT_NAME` in WSGI applications.
+
+### Worker Connections
+
+Control the maximum number of concurrent connections per worker:
+
+```bash
+gunicorn myapp:app --worker-class asgi --worker-connections 1000
+```
+
+!!! note
+ Unlike sync workers, the `--threads` option has no effect on ASGI workers.
+ Use `--worker-connections` to control concurrency.
+
+## WebSocket Support
+
+The ASGI worker supports WebSocket connections out of the box. No additional
+configuration is required.
+
+Example with Starlette:
+
+```python
+from starlette.applications import Starlette
+from starlette.routing import WebSocketRoute
+
+async def websocket_endpoint(websocket):
+ await websocket.accept()
+ while True:
+ data = await websocket.receive_text()
+ await websocket.send_text(f"Echo: {data}")
+
+app = Starlette(routes=[
+ WebSocketRoute("/ws", websocket_endpoint),
+])
+```
+
+## Production Deployment
+
+### With Nginx
+
+```nginx
+upstream gunicorn {
+ server 127.0.0.1:8000;
+}
+
+server {
+ listen 80;
+ server_name example.com;
+
+ location / {
+ proxy_pass http://gunicorn;
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header X-Forwarded-Proto $scheme;
+ }
+
+ # WebSocket support
+ location /ws {
+ proxy_pass http://gunicorn;
+ proxy_http_version 1.1;
+ proxy_set_header Upgrade $http_upgrade;
+ proxy_set_header Connection "upgrade";
+ proxy_set_header Host $host;
+ }
+}
+```
+
+### Recommended Settings
+
+For production ASGI deployments:
+
+```python
+# gunicorn.conf.py
+worker_class = "asgi"
+workers = 4 # Number of worker processes
+worker_connections = 1000 # Max connections per worker
+keepalive = 5 # Keepalive timeout
+timeout = 120 # Worker timeout
+graceful_timeout = 30 # Graceful shutdown timeout
+
+# Performance tuning
+asgi_loop = "auto" # Use uvloop if available
+asgi_lifespan = "auto" # Auto-detect lifespan support
+```
+
+## Comparison with Other ASGI Servers
+
+| Feature | Gunicorn ASGI | Uvicorn | Hypercorn |
+|---------|---------------|---------|-----------|
+| Process management | Built-in | External | Built-in |
+| HTTP/2 | No | No | Yes |
+| WebSocket | Yes | Yes | Yes |
+| Lifespan | Yes | Yes | Yes |
+| uvloop support | Yes | Yes | Yes |
+
+Gunicorn's ASGI worker provides the same process management, logging, and
+configuration capabilities you're familiar with from WSGI deployments.
+
+## Troubleshooting
+
+### Lifespan startup failed
+
+If you see "ASGI lifespan startup failed", your application may not properly
+implement the lifespan protocol. Either fix the application or set
+`--asgi-lifespan off`.
+
+### Connection limits
+
+If you're hitting connection limits, increase `--worker-connections` or add
+more workers with `--workers`.
+
+### Slow responses under load
+
+Try using uvloop for better performance:
+
+```bash
+pip install uvloop
+gunicorn myapp:app --worker-class asgi --asgi-loop uvloop
+```
+
+## See Also
+
+- [Settings Reference](reference/settings.md#asgi_loop) - All ASGI-related settings
+- [Deploy](deploy.md) - General deployment guidance
+- [Design](design.md) - Worker architecture overview
diff --git a/docs/content/assets/gunicorn.svg b/docs/content/assets/gunicorn.svg
new file mode 100644
index 00000000..073f2029
--- /dev/null
+++ b/docs/content/assets/gunicorn.svg
@@ -0,0 +1,119 @@
+
+
+
+
diff --git a/docs/content/assets/javascripts/toc-collapse.js b/docs/content/assets/javascripts/toc-collapse.js
new file mode 100644
index 00000000..6b2dc6f9
--- /dev/null
+++ b/docs/content/assets/javascripts/toc-collapse.js
@@ -0,0 +1,79 @@
+// Collapsible TOC for settings page
+(function() {
+ function initCollapsibleTOC() {
+ // Only apply to pages with many TOC items (like settings)
+ var tocNav = document.querySelector('.md-nav--secondary');
+ if (!tocNav) return;
+
+ // Skip if already initialized
+ if (tocNav.dataset.tocCollapse === 'true') return;
+ tocNav.dataset.tocCollapse = 'true';
+
+ var tocItems = tocNav.querySelectorAll('.md-nav__item');
+ if (tocItems.length < 20) return;
+
+ // Find all top-level TOC items that have nested lists
+ var topList = tocNav.querySelector('.md-nav__list');
+ if (!topList) return;
+
+ var sections = topList.children;
+
+ for (var i = 0; i < sections.length; i++) {
+ (function(section) {
+ var nestedNav = section.querySelector('.md-nav');
+ if (!nestedNav) return;
+
+ var link = section.querySelector('.md-nav__link');
+ if (!link) return;
+
+ // Skip if already has toggle
+ if (link.querySelector('.toc-toggle')) return;
+
+ // Collapse by default
+ nestedNav.style.display = 'none';
+
+ // Create toggle button
+ var toggle = document.createElement('span');
+ toggle.className = 'toc-toggle';
+ toggle.innerHTML = '+';
+ toggle.style.float = 'right';
+ toggle.style.marginRight = '0.5rem';
+ toggle.style.fontWeight = 'bold';
+ toggle.style.cursor = 'pointer';
+ toggle.style.userSelect = 'none';
+ link.appendChild(toggle);
+
+ // Toggle function for this specific section
+ function toggleSection(e) {
+ if (e) {
+ e.preventDefault();
+ e.stopPropagation();
+ }
+
+ if (nestedNav.style.display === 'none') {
+ nestedNav.style.display = 'block';
+ toggle.innerHTML = '−';
+ } else {
+ nestedNav.style.display = 'none';
+ toggle.innerHTML = '+';
+ }
+ }
+
+ // Click on toggle button
+ toggle.onclick = toggleSection;
+ })(sections[i]);
+ }
+ }
+
+ // Run on DOM ready
+ if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', initCollapsibleTOC);
+ } else {
+ initCollapsibleTOC();
+ }
+
+ // Re-run on instant navigation (MkDocs Material)
+ if (typeof document$ !== 'undefined') {
+ document$.subscribe(initCollapsibleTOC);
+ }
+})();
diff --git a/docs/content/assets/stylesheets/home.css b/docs/content/assets/stylesheets/home.css
new file mode 100644
index 00000000..5f1748ef
--- /dev/null
+++ b/docs/content/assets/stylesheets/home.css
@@ -0,0 +1,439 @@
+/* ============================================
+ Gunicorn Landing Page
+ Inspired by Caddy: minimal, spacious, clean
+ ============================================ */
+
+.home {
+ --accent: #00a650;
+ --accent-hover: #00c853;
+ --accent-dark: #008542;
+ --teal: #00bfa5;
+ --text: #1a1a2e;
+ --text-muted: #555;
+ --bg: #fff;
+ --bg-alt: #f8faf8;
+ --border: #e0e6e0;
+ --code-bg: #0d1117;
+ --max-width: 900px;
+
+ width: 100%;
+ max-width: none;
+ margin: 0;
+ padding: 0;
+ font-size: 1.0625rem;
+ line-height: 1.7;
+ color: var(--text);
+}
+
+[data-md-color-scheme="slate"] .home {
+ --text: #e6e6e6;
+ --text-muted: #aaa;
+ --bg: #0d1117;
+ --bg-alt: #161b22;
+ --border: #30363d;
+}
+
+/* Remove MkDocs constraints */
+.md-main__inner { margin: 0; max-width: none; }
+.md-content { max-width: none; }
+.md-content__inner { margin: 0; padding: 0; }
+
+/* ============================================
+ Sections - Caddy-style vertical flow
+ ============================================ */
+.home section {
+ padding: 5rem 2rem;
+}
+
+.home section:nth-child(even) {
+ background: var(--bg-alt);
+}
+
+.home .container {
+ max-width: var(--max-width);
+ margin: 0 auto;
+}
+
+/* ============================================
+ Hero
+ ============================================ */
+.hero {
+ text-align: center;
+ padding: 6rem 2rem 5rem;
+}
+
+.hero .container {
+ max-width: 700px;
+}
+
+.hero__logo {
+ width: 350px !important;
+ max-width: 350px !important;
+ min-width: 350px;
+ height: auto;
+ margin-bottom: 2rem;
+}
+
+.hero h1 {
+ font-size: 3rem;
+ font-weight: 700;
+ line-height: 1.15;
+ margin: 0 0 1.5rem 0;
+ letter-spacing: -0.02em;
+ white-space: nowrap;
+}
+
+.hero__tagline {
+ font-size: 1.25rem;
+ color: var(--text-muted);
+ margin: 0 0 2.5rem 0;
+ max-width: 550px;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+.hero__buttons {
+ display: flex;
+ gap: 1rem;
+ justify-content: center;
+ flex-wrap: wrap;
+ margin-bottom: 3rem;
+}
+
+.btn {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.5rem;
+ padding: 0.875rem 1.75rem;
+ font-size: 1rem;
+ font-weight: 500;
+ text-decoration: none;
+ border-radius: 6px;
+ transition: all 0.15s ease;
+}
+
+.btn--primary {
+ background: linear-gradient(135deg, var(--accent) 0%, var(--accent-hover) 100%);
+ color: #fff;
+ box-shadow: 0 4px 12px rgba(0, 166, 80, 0.3);
+}
+
+.btn--primary:hover {
+ box-shadow: 0 6px 20px rgba(0, 166, 80, 0.4);
+ transform: translateY(-2px);
+}
+
+.btn--secondary {
+ background: transparent;
+ color: var(--text);
+ border: 1px solid var(--border);
+}
+
+.btn--secondary:hover {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+/* Terminal */
+.terminal {
+ background: var(--code-bg);
+ border-radius: 8px;
+ overflow: hidden;
+ text-align: left;
+ max-width: 500px;
+ margin: 0 auto;
+ box-shadow: 0 8px 30px rgba(0,0,0,0.12);
+}
+
+.terminal__header {
+ background: #161b22;
+ padding: 0.75rem 1rem;
+ display: flex;
+ gap: 6px;
+}
+
+.terminal__dot {
+ width: 12px;
+ height: 12px;
+ border-radius: 50%;
+}
+
+.terminal__dot--red { background: #ff5f56; }
+.terminal__dot--yellow { background: #ffbd2e; }
+.terminal__dot--green { background: #27c93f; }
+
+.terminal__body {
+ padding: 1.25rem 1.5rem;
+ font-family: 'SF Mono', Monaco, Consolas, monospace;
+ font-size: 0.9rem;
+ line-height: 1.8;
+ color: #c9d1d9;
+}
+
+.terminal__line {
+ display: block;
+}
+
+.terminal__prompt {
+ color: var(--accent-hover);
+ user-select: none;
+}
+
+.terminal__comment {
+ color: #6e7681;
+}
+
+/* ============================================
+ Why Gunicorn - 3 pillars
+ ============================================ */
+.why h2 {
+ text-align: center;
+ font-size: 2rem;
+ margin: 0 0 3rem 0;
+}
+
+.pillars {
+ display: grid;
+ grid-template-columns: repeat(3, 1fr);
+ gap: 2rem;
+}
+
+.pillar h3 {
+ font-size: 1.125rem;
+ margin: 0 0 0.5rem 0;
+}
+
+.pillar p {
+ color: var(--text-muted);
+ margin: 0;
+ font-size: 0.9375rem;
+}
+
+/* ============================================
+ Frameworks
+ ============================================ */
+.frameworks h2 {
+ text-align: center;
+ font-size: 1.75rem;
+ margin: 0 0 0.5rem 0;
+}
+
+.frameworks__subtitle {
+ text-align: center;
+ color: var(--text-muted);
+ margin: 0 0 2rem 0;
+}
+
+.frameworks__list {
+ display: flex;
+ flex-wrap: wrap;
+ justify-content: center;
+ gap: 0.75rem;
+}
+
+.framework-tag {
+ padding: 0.5rem 1rem;
+ background: var(--bg);
+ border: 1px solid var(--border);
+ border-radius: 100px;
+ font-size: 0.875rem;
+ font-weight: 500;
+ transition: all 0.15s ease;
+}
+
+[data-md-color-scheme="slate"] .framework-tag {
+ background: var(--bg-alt);
+}
+
+.framework-tag:hover {
+ border-color: var(--accent);
+ color: var(--accent);
+}
+
+.framework-tag--new {
+ background: var(--accent);
+ color: #fff;
+ border-color: var(--accent);
+}
+
+/* ============================================
+ Workers
+ ============================================ */
+.workers h2 {
+ font-size: 1.75rem;
+ margin: 0 0 2rem 0;
+}
+
+.workers__grid {
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ gap: 1rem;
+}
+
+.worker {
+ padding: 1.5rem;
+ background: var(--bg);
+ border: 1px solid var(--border);
+ border-radius: 8px;
+ text-decoration: none;
+ color: inherit;
+ transition: border-color 0.15s ease;
+}
+
+[data-md-color-scheme="slate"] .worker {
+ background: var(--bg-alt);
+}
+
+.worker:hover {
+ border-color: var(--accent);
+}
+
+.worker h3 {
+ font-size: 1rem;
+ margin: 0 0 0.25rem 0;
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+}
+
+.worker p {
+ color: var(--text-muted);
+ font-size: 0.875rem;
+ margin: 0;
+}
+
+.badge {
+ font-size: 0.625rem;
+ font-weight: 700;
+ padding: 0.125rem 0.375rem;
+ background: var(--accent);
+ color: #fff;
+ border-radius: 3px;
+ text-transform: uppercase;
+ letter-spacing: 0.05em;
+}
+
+/* ============================================
+ Quick Links
+ ============================================ */
+.quick-links {
+ text-align: center;
+}
+
+.quick-links h2 {
+ font-size: 1.75rem;
+ margin: 0 0 2rem 0;
+}
+
+.quick-links__grid {
+ display: grid;
+ grid-template-columns: repeat(4, 1fr);
+ gap: 1rem;
+ text-align: left;
+}
+
+.quick-link {
+ padding: 1.25rem;
+ background: var(--bg);
+ border: 1px solid var(--border);
+ border-radius: 8px;
+ text-decoration: none;
+ color: inherit;
+ transition: border-color 0.15s ease;
+}
+
+[data-md-color-scheme="slate"] .quick-link {
+ background: var(--bg-alt);
+}
+
+.quick-link:hover {
+ border-color: var(--accent);
+}
+
+.quick-link strong {
+ display: block;
+ margin-bottom: 0.25rem;
+}
+
+.quick-link span {
+ font-size: 0.875rem;
+ color: var(--text-muted);
+}
+
+/* ============================================
+ Footer CTA
+ ============================================ */
+.home-footer {
+ text-align: center;
+}
+
+.home-footer h2 {
+ font-size: 1.75rem;
+ margin: 0 0 1rem 0;
+}
+
+.home-footer p {
+ color: var(--text-muted);
+ margin: 0 0 2rem 0;
+}
+
+.home-footer__links {
+ display: flex;
+ justify-content: center;
+ gap: 2rem;
+}
+
+.home-footer__links a {
+ color: var(--text-muted);
+ text-decoration: none;
+ font-size: 0.9375rem;
+}
+
+.home-footer__links a:hover {
+ color: var(--accent);
+}
+
+/* ============================================
+ Responsive
+ ============================================ */
+@media (max-width: 768px) {
+ .home section {
+ padding: 3.5rem 1.5rem;
+ }
+
+ .hero h1 {
+ font-size: 2.25rem;
+ }
+
+ .pillars {
+ grid-template-columns: 1fr;
+ gap: 1.5rem;
+ }
+
+ .workers__grid {
+ grid-template-columns: 1fr;
+ }
+
+ .quick-links__grid {
+ grid-template-columns: 1fr 1fr;
+ }
+}
+
+@media (max-width: 480px) {
+ .hero h1 {
+ font-size: 1.875rem;
+ }
+
+ .hero__buttons {
+ flex-direction: column;
+ }
+
+ .btn {
+ width: 100%;
+ justify-content: center;
+ }
+
+ .quick-links__grid {
+ grid-template-columns: 1fr;
+ }
+}
diff --git a/docs/content/community.md b/docs/content/community.md
new file mode 100644
index 00000000..e9996b9d
--- /dev/null
+++ b/docs/content/community.md
@@ -0,0 +1,40 @@
+# Community
+
+Connect with the project through these channels.
+
+## Project management & discussions
+
+Project maintenance guidelines live on the
+[wiki](https://github.com/benoitc/gunicorn/wiki/Project-management).
+
+GitHub is used for:
+
+- [Bug reports](https://github.com/benoitc/gunicorn/issues) — search before
+ opening a new issue.
+- [Discussions](https://github.com/benoitc/gunicorn/discussions) — Q&A and usage
+ tips.
+- [Feature planning](https://github.com/benoitc/gunicorn/issues) — development
+ and project management topics.
+
+## IRC
+
+Join the Gunicorn channel on [Libera Chat](https://libera.chat/) at
+[`#gunicorn`](https://web.libera.chat/?channels=#gunicorn).
+
+## Issue tracking
+
+File bugs, enhancements, and tasks in the
+[GitHub issue tracker](https://github.com/benoitc/gunicorn/issues).
+
+## Security issues
+
+Report security vulnerabilities privately to
+[`security@gunicorn.org`](mailto:security@gunicorn.org); only core developers
+subscribe to this list.
+
+## Contributing
+
+Start with the
+[contributing guide](https://github.com/benoitc/gunicorn/blob/master/CONTRIBUTING.md)
+for development workflow, code style, and review expectations. New contributors
+are welcome—open a draft pull request early to gather feedback.
diff --git a/docs/content/configure.md b/docs/content/configure.md
new file mode 100644
index 00000000..1698fba5
--- /dev/null
+++ b/docs/content/configure.md
@@ -0,0 +1,78 @@
+
+# Configuration Overview
+
+Gunicorn reads configuration from five places, in increasing order of priority:
+
+1. Environment variables, for settings that support them.
+2. Framework-specific configuration (currently Paste Deploy only).
+3. A Python configuration file `gunicorn.conf.py` (default in the working directory).
+4. The `GUNICORN_CMD_ARGS` environment variable.
+5. Command-line arguments.
+
+If a configuration file is provided both via `GUNICORN_CMD_ARGS` and the CLI,
+only the file specified on the command line is used.
+
+!!! note
+ Print the fully resolved configuration:
+
+bash
+gunicorn --print-config APP_MODULE
+```
+
+Validate configuration and exit:
+
+```bash
+gunicorn --check-config APP_MODULE
+```
+
+This is also a quick way to confirm that your application can start.
+```
+
+## Command line
+
+Options set on the command line override framework settings and values from the
+configuration file. Not every setting has a command-line flag; run
+
+```bash
+gunicorn -h
+```
+
+for the complete list. The CLI also exposes `--version`, which is not part of
+the main [settings reference](reference/settings.md).
+
+
+## Configuration file
+
+Provide a Python file (for example `gunicorn.conf.py`). Gunicorn executes the
+file on every start or reload, so any valid Python is allowed:
+
+```python
+import multiprocessing
+
+bind = "127.0.0.1:8000"
+workers = multiprocessing.cpu_count() * 2 + 1
+```
+
+Every configuration key is documented in the [settings reference](reference/settings.md).
+
+## Framework settings
+
+At present only Paste Deploy applications expose framework-specific settings.
+If you have ideas for Django or other frameworks, open an
+[issue](https://github.com/benoitc/gunicorn/issues).
+
+### Paste applications
+
+Reference Gunicorn as the server in your INI file:
+
+```ini
+[server:main]
+use = egg:gunicorn#main
+host = 192.168.0.1
+port = 80
+workers = 2
+proc_name = brim
+```
+
+Gunicorn merges any recognised parameters into the base configuration. Values
+from the configuration file and command line still override these defaults.
diff --git a/docs/content/custom.md b/docs/content/custom.md
new file mode 100644
index 00000000..f2bdfb73
--- /dev/null
+++ b/docs/content/custom.md
@@ -0,0 +1,62 @@
+
+# Custom Application
+
+!!! info "Added in 19.0"
+ Use Gunicorn as part of your own WSGI application by subclassing
+ `gunicorn.app.base.BaseApplication`.
+
+
+
+Example: create a tiny WSGI app and load it with a custom application:
+
+```text
+--8<-- "examples/standalone_app.py"
+```
+
+
+
+## Using server hooks
+
+Provide hooks through configuration, just like a standard Gunicorn deployment.
+For example, a `pre_fork` hook:
+
+```python
+def pre_fork(server, worker):
+ print(f"pre-fork server {server} worker {worker}", file=sys.stderr)
+
+if __name__ == "__main__":
+ options = {
+ "bind": "127.0.0.1:8080",
+ "workers": number_of_workers(),
+ "pre_fork": pre_fork,
+ }
+```
+
+## Direct usage of existing WSGI apps
+
+Run Gunicorn from Python to serve a WSGI application instance at runtime—useful
+for rolling deploys or packaging with PEX. Gunicorn exposes
+`gunicorn.app.wsgiapp`, which accepts any WSGI app (for example a Flask or
+Django instance). Assuming your package is `exampleapi` and the application is
+`app`:
+
+```bash
+python -m gunicorn.app.wsgiapp exampleapi:app
+```
+
+All CLI flags and configuration files still apply:
+
+```bash
+# Custom parameters
+python -m gunicorn.app.wsgiapp exampleapi:app --bind=0.0.0.0:8081 --workers=4
+# Using a config file
+python -m gunicorn.app.wsgiapp exampleapi:app -c config.py
+```
+
+For PEX builds use `-c gunicorn` at build time so the packaged app accepts the
+entry point at runtime:
+
+```bash
+pex . -v -c gunicorn -o compiledapp.pex
+./compiledapp.pex exampleapi:app -c gunicorn_config.py
+```
diff --git a/docs/content/deploy.md b/docs/content/deploy.md
new file mode 100644
index 00000000..bb78674e
--- /dev/null
+++ b/docs/content/deploy.md
@@ -0,0 +1,322 @@
+# Deploying Gunicorn
+
+We strongly recommend running Gunicorn behind a proxy server.
+
+## Nginx configuration
+
+Although many HTTP proxies exist, we recommend [Nginx](https://nginx.org/).
+When using the default synchronous workers you must ensure the proxy buffers
+slow clients; otherwise Gunicorn becomes vulnerable to denial-of-service
+attacks. Use [Hey](https://github.com/rakyll/hey) to verify proxy behaviour.
+
+An example configuration for fast clients with Nginx
+([source](https://github.com/benoitc/gunicorn/blob/master/examples/nginx.conf)):
+
+```nginx title="nginx.conf"
+--8<-- "examples/nginx.conf"
+```
+
+
+
+To support streaming requests/responses or patterns such as Comet, long
+polling, or WebSockets, disable proxy buffering and run Gunicorn with an async
+worker class:
+
+```nginx
+location @proxy_to_app {
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header Host $http_host;
+ proxy_redirect off;
+ proxy_buffering off;
+
+ proxy_pass http://app_server;
+}
+```
+
+To ignore aborted requests (for example, health checks that close connections
+prematurely) enable
+[`proxy_ignore_client_abort`](http://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_ignore_client_abort):
+
+```nginx
+proxy_ignore_client_abort on;
+```
+
+!!! note
+ The default value for `proxy_ignore_client_abort` is `off`. If it remains off
+ Nginx logs will report error 499 and Gunicorn may log `Ignoring EPIPE` when the
+ log level is `debug`.
+
+
+
+Pass protocol information to Gunicorn so applications can generate correct
+URLs. Add this header to your `location` block:
+
+```nginx
+proxy_set_header X-Forwarded-Proto $scheme;
+```
+
+If Nginx runs on a different host, tell Gunicorn which proxies are trusted so it
+accepts the `X-Forwarded-*` headers:
+
+```bash
+gunicorn -w 3 --forwarded-allow-ips="10.170.3.217,10.170.3.220" test:app
+```
+
+When all traffic comes from trusted proxies (for example Heroku) you can set
+`--forwarded-allow-ips='*'`. This is **dangerous** if untrusted clients can
+reach Gunicorn directly, because forged headers could make your application
+serve secure content over plain HTTP.
+
+Gunicorn 19 changed the handling of `REMOTE_ADDR` to conform to
+[RFC 3875](https://www.rfc-editor.org/rfc/rfc3875), meaning it now records the
+proxy IP rather than the upstream client. To log the real client address, set
+[`access_log_format`](reference/settings.md#access_log_format) to include `X-Forwarded-For`:
+
+```text
+%({x-forwarded-for}i)s %(l.md)s %(u.md)s %(t.md)s "%(r.md)s" %(s.md)s %(b.md)s "%(f.md)s" "%(a.md)s"
+```
+
+When binding Gunicorn to a UNIX socket `REMOTE_ADDR` will be empty.
+
+## Using virtual environments
+
+Install Gunicorn inside your project
+[virtual environment](https://pypi.python.org/pypi/virtualenv) to keep versions
+isolated:
+
+```bash
+mkdir ~/venvs/
+virtualenv ~/venvs/webapp
+source ~/venvs/webapp/bin/activate
+pip install gunicorn
+deactivate
+```
+
+Force installation into the active virtual environment with `--ignore-installed`:
+
+```bash
+source ~/venvs/webapp/bin/activate
+pip install -I gunicorn
+```
+
+## Monitoring
+
+!!! note
+ Do not enable Gunicorn's daemon mode when using process monitors. These
+ supervisors expect to manage the direct child process.
+
+
+
+### Gaffer
+
+Use [Gaffer](https://gaffer.readthedocs.io/) with *gafferd* to manage Gunicorn:
+
+```ini
+[process:gunicorn]
+cmd = gunicorn -w 3 test:app
+cwd = /path/to/project
+```
+
+Create a `Procfile` if you prefer:
+
+```procfile
+gunicorn = gunicorn -w 3 test:app
+```
+
+Start Gunicorn via Gaffer:
+
+```bash
+gaffer start
+```
+
+Or load it into a running *gafferd* instance:
+
+```bash
+gaffer load
+```
+
+### runit
+
+[runit](http://smarden.org/runit/) is a popular supervisor. A sample service
+script (see the
+[full example](https://github.com/benoitc/gunicorn/blob/master/examples/gunicorn_rc)):
+
+```bash
+#!/bin/sh
+
+GUNICORN=/usr/local/bin/gunicorn
+ROOT=/path/to/project
+PID=/var/run/gunicorn.pid
+
+APP=main:application
+
+if [ -f $PID ]; then rm $PID; fi
+
+cd $ROOT
+exec $GUNICORN -c $ROOT/gunicorn.conf.py --pid=$PID $APP
+```
+
+Save as `/etc/sv/
+
+
+
+## Worker Types
+
+Choose a worker type based on your application's needs.
+
+=== "Sync"
+
+ The **default** worker. Handles one request at a time per worker.
+
+ - Simple and predictable
+ - Errors affect only the current request
+ - No keep-alive support (connections close after response)
+ - Requires a buffering proxy (nginx, HAProxy) for production
+
+ ```bash
+ gunicorn myapp:app
+ ```
+
+=== "Gthread"
+
+ Threaded worker with a **thread pool** per worker process.
+
+ - Supports keep-alive connections
+ - Good balance of concurrency and simplicity
+ - Threads share memory (lower footprint than workers)
+ - Idle connections close after keepalive timeout
+
+ ```bash
+ gunicorn myapp:app -k gthread --threads 4
+ ```
+
+=== "ASGI"
+
+ Native **asyncio** support for modern async frameworks.
+
+ - For FastAPI, Starlette, Quart, and other ASGI apps
+ - Full async/await support
+ - See the [ASGI Guide](asgi.md) for details
+
+ ```bash
+ gunicorn myapp:app -k uvicorn.workers.UvicornWorker
+ ```
+
+=== "Gevent"
+
+ **Greenlet-based** async worker using [Gevent](http://www.gevent.org/).
+
+ - Handles thousands of concurrent connections
+ - Supports keep-alive, WebSockets, long-polling
+ - May require patches for some libraries (e.g., `psycogreen` for Psycopg)
+ - Not compatible with code that relies on blocking behavior
+
+ ```bash
+ gunicorn myapp:app -k gevent --worker-connections 1000
+ ```
+
+=== "Eventlet"
+
+ **Greenlet-based** async worker using [Eventlet](http://eventlet.net/).
+
+ - Similar capabilities to Gevent
+ - Handles high concurrency for I/O-bound apps
+ - Some libraries may need compatibility patches
+
+ ```bash
+ gunicorn myapp:app -k eventlet --worker-connections 1000
+ ```
+
+=== "Tornado"
+
+ Worker for [Tornado](https://www.tornadoweb.org/) applications.
+
+ - Designed for Tornado's async framework
+ - Can serve WSGI apps, but not recommended for that use case
+ - Use when running native Tornado applications
+
+ ```bash
+ gunicorn myapp:app -k tornado
+ ```
+
+## Comparison
+
+| Worker | Concurrency Model | Keep-Alive | Best For |
+|--------|-------------------|------------|----------|
+| `sync` | 1 request/worker | ❌ | CPU-bound apps behind a proxy |
+| `gthread` | Thread pool | ✅ | Mixed workloads, moderate concurrency |
+| ASGI workers | AsyncIO | ✅ | Modern async frameworks (FastAPI, etc.) |
+| `gevent` | Greenlets | ✅ | I/O-bound, WebSockets, streaming |
+| `eventlet` | Greenlets | ✅ | I/O-bound, long-polling |
+| `tornado` | Tornado IOLoop | ✅ | Native Tornado applications |
+
+!!! tip "Quick Decision Guide"
+
+ - **Simple app behind nginx?** → `sync` (default)
+ - **Need keep-alive or moderate concurrency?** → `gthread`
+ - **WebSockets, streaming, long-polling?** → `gevent` or `eventlet`
+ - **FastAPI, Starlette, or async framework?** → ASGI worker
+
+## When to Use Async Workers
+
+Synchronous workers assume your app is CPU or network bound and avoids
+indefinite blocking operations. Use async workers when you have:
+
+- Long blocking calls (external APIs, slow databases)
+- Direct internet traffic without a buffering proxy
+- Streaming request/response bodies
+- Long polling or Comet patterns
+- WebSockets
+
+!!! info "Testing Slow Clients"
+
+ Tools like [Hey](https://github.com/rakyll/hey) can simulate slow responses
+ to test how your configuration handles them.
+
+## Scaling
+
+### How Many Workers?
+
+!!! warning "Don't Over-Scale"
+
+ Workers ≠ clients. Gunicorn typically needs only **4–12 workers** to handle
+ heavy traffic. Too many workers waste resources and can reduce throughput.
+
+Start with this formula and adjust under load:
+
+```
+workers = (2 × CPU cores) + 1
+```
+
+Use `TTIN`/`TTOU` signals to adjust the worker count at runtime.
+
+### How Many Threads?
+
+With the `gthread` worker, you can combine workers and threads:
+
+```bash
+gunicorn myapp:app -k gthread --workers 4 --threads 2
+```
+
+!!! info "Threads vs Workers"
+
+ - **Threads** share memory → lower footprint
+ - **Workers** isolate failures → better fault tolerance
+ - Combine both for the best of both worlds
+
+Threads can extend request time beyond the worker timeout while still
+notifying the arbiter. The optimal mix depends on your runtime (CPython vs
+PyPy) and workload.
+
+## Configuration Examples
+
+```bash
+# Sync (default) - simple apps behind nginx
+gunicorn myapp:app
+
+# Gthread - keep-alive and thread concurrency
+gunicorn myapp:app -k gthread --workers 4 --threads 4
+
+# Gevent - high concurrency for I/O-bound apps
+gunicorn myapp:app -k gevent --workers 4 --worker-connections 1000
+
+# Eventlet - alternative async worker
+gunicorn myapp:app -k eventlet --workers 4 --worker-connections 1000
+
+# ASGI - FastAPI/Starlette with Uvicorn worker
+gunicorn myapp:app -k uvicorn.workers.UvicornWorker --workers 4
+```
+
+
+
+!!! note "Third-Party AsyncIO Workers"
+
+ For asyncio frameworks, you can also use third-party workers. See the
+ [aiohttp deployment guide](https://docs.aiohttp.org/en/stable/deployment.html#nginx-gunicorn)
+ for examples.
diff --git a/docs/content/faq.md b/docs/content/faq.md
new file mode 100644
index 00000000..f26f1797
--- /dev/null
+++ b/docs/content/faq.md
@@ -0,0 +1,160 @@
+
+# FAQ
+
+## WSGI bits
+
+### How do I set `SCRIPT_NAME`?
+
+By default `SCRIPT_NAME` is an empty string. Set it via an environment variable
+or HTTP header. Because the header contains an underscore it is only accepted
+from trusted forwarders listed in [`forwarded_allow_ips`](reference/settings.md#forwarded_allow_ips).
+
+!!! note
+ If your application should appear under a subfolder, `SCRIPT_NAME` typically
+ starts with a single leading slash and no trailing slash.
+
+
+
+## Server stuff
+
+### How do I reload my application in Gunicorn?
+
+Send `HUP` to the master process for a graceful reload:
+
+```bash
+kill -HUP masterpid
+```
+
+### How might I test a proxy configuration?
+
+Use [Hey](https://github.com/rakyll/hey) to confirm that your proxy buffers
+responses correctly for synchronous workers:
+
+```bash
+hey -n 10000 -c 100 http://127.0.0.1:5000/
+```
+
+That benchmark issues 10,000 requests with a concurrency of 100.
+
+### How can I name processes?
+
+Install [setproctitle](https://pypi.python.org/pypi/setproctitle) to give
+Gunicorn processes meaningful names in tools such as `ps` and `top`. This helps
+when running multiple Gunicorn instances. See the
+[`proc_name`](reference/settings.md#proc_name) setting for details.
+
+### Why is there no HTTP keep-alive?
+
+The default sync workers target Nginx, which uses HTTP/1.0 for upstream
+connections. If you need to serve unbuffered internet traffic directly, pick an
+async worker instead.
+
+## Worker processes
+
+### How do I know which type of worker to use?
+
+Read the [design guide](design.md) for guidance on worker types.
+
+### What types of workers are available?
+
+See the [`worker_class`](reference/settings.md#worker_class) configuration reference.
+
+### How can I figure out the best number of worker processes?
+
+Follow the recommendations for tuning the [`number of workers`](design.md#how-many-workers).
+
+### How can I change the number of workers dynamically?
+
+Send `TTIN` or `TTOU` to the master process:
+
+```bash
+kill -TTIN $masterpid # increment workers
+kill -TTOU $masterpid # decrement workers
+```
+
+### Does Gunicorn suffer from the thundering herd problem?
+
+Potentially, when many sleeping handlers wake simultaneously but only one takes
+the request. There is ongoing work to mitigate this
+([issue #792](https://github.com/benoitc/gunicorn/issues/792)). Monitor load if
+you use large numbers of workers or threads.
+
+### Why don't I see logs in the console?
+
+Gunicorn 19.0 disabled console logging by default. Use `--log-file=-` to stream
+logs to stdout. Console logging returned in 19.2.
+
+## Kernel parameters
+
+High-concurrency deployments may need kernel tuning. These Linux-oriented tips
+apply to any network service.
+
+### How can I increase the maximum number of file descriptors?
+
+Raise the per-process limit (remember sockets count as files). Running `sudo
+ulimit` is ineffective—switch to root, adjust the limit, then launch Gunicorn.
+Consider managing limits via systemd service units or init scripts.
+
+### How can I increase the maximum socket backlog?
+
+Increase the queue of pending connections:
+
+```bash
+sudo sysctl -w net.core.somaxconn="2048"
+```
+
+### How can I disable the use of `sendfile()`?
+
+Pass `--no-sendfile` or set the `SENDFILE=0` environment variable.
+
+## Troubleshooting
+
+### Django reports `ImproperlyConfigured`
+
+Asynchronous workers may break `django.core.urlresolvers.reverse`. Use
+`reverse_lazy` instead.
+
+### How do I avoid blocking in `os.fchmod`?
+
+Gunicorn's heartbeat touches temporary files. On disk-backed filesystems (for
+example `/tmp` on some distributions) `os.fchmod` can block if I/O stalls or the
+filesystem fills up. Mount a `tmpfs` and point `--worker-tmp-dir` to it.
+
+Check whether `/tmp` is RAM-backed:
+
+```bash
+df /tmp
+```
+
+If not, create a new `tmpfs` mount:
+
+```bash
+sudo cp /etc/fstab /etc/fstab.orig
+sudo mkdir /mem
+echo 'tmpfs /mem tmpfs defaults,size=64m,mode=1777,noatime,comment=for-gunicorn 0 0' | sudo tee -a /etc/fstab
+sudo mount /mem
+```
+
+Verify the result:
+
+```bash
+df /mem
+```
+
+Then start Gunicorn with `--worker-tmp-dir /mem`.
+
+### Why are workers silently killed?
+
+If a worker vanishes without logs, check for `SIGKILL`. Reverse proxies may show
+`502` responses while Gunicorn logs only new worker startups (for example,
+`[INFO] Booting worker`). A common culprit is the OOM killer in cgroups-limited
+environments.
+
+Inspect kernel logs:
+
+```bash
+dmesg | grep gunicorn
+```
+
+If you see messages similar to `Memory cgroup out of memory ... Killed process
+(gunicorn.md)`, raise memory limits or adjust OOM behaviour.
diff --git a/docs/content/guides/docker.md b/docs/content/guides/docker.md
new file mode 100644
index 00000000..036b38b1
--- /dev/null
+++ b/docs/content/guides/docker.md
@@ -0,0 +1,339 @@
+# Docker Deployment
+
+Running Gunicorn in Docker containers is the most common deployment pattern
+for modern Python applications. This guide covers best practices for
+containerizing Gunicorn applications.
+
+## Basic Dockerfile
+
+```dockerfile
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Run gunicorn
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"]
+```
+
+Build and run:
+
+```bash
+docker build -t myapp .
+docker run -p 8000:8000 myapp
+```
+
+## Production Configuration
+
+### Environment Variables
+
+Use environment variables for configuration:
+
+```dockerfile
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# Configuration via environment
+ENV GUNICORN_WORKERS=4
+ENV GUNICORN_BIND=0.0.0.0:8000
+
+CMD gunicorn app:app \
+ --workers ${GUNICORN_WORKERS} \
+ --bind ${GUNICORN_BIND}
+```
+
+Or use `GUNICORN_CMD_ARGS`:
+
+```dockerfile
+ENV GUNICORN_CMD_ARGS="--workers=4 --bind=0.0.0.0:8000"
+CMD ["gunicorn", "app:app"]
+```
+
+### Worker Count
+
+In containers, determine workers based on available CPU:
+
+```python
+# gunicorn.conf.py
+import multiprocessing
+
+workers = multiprocessing.cpu_count() * 2 + 1
+bind = "0.0.0.0:8000"
+```
+
+Or let Kubernetes/Docker limit CPU and calculate accordingly:
+
+```bash
+# At runtime
+gunicorn app:app --workers $(( 2 * $(nproc) + 1 ))
+```
+
+### Non-Root User
+
+Run as a non-root user for security:
+
+```dockerfile
+FROM python:3.12-slim
+
+# Create non-root user
+RUN useradd --create-home appuser
+WORKDIR /home/appuser/app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=appuser:appuser . .
+
+USER appuser
+
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"]
+```
+
+### Health Checks
+
+Add a health check endpoint and Docker health check:
+
+```dockerfile
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+ CMD curl -f http://localhost:8000/health || exit 1
+```
+
+## Multi-Stage Build
+
+Reduce image size with multi-stage builds:
+
+```dockerfile
+# Build stage
+FROM python:3.12 AS builder
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip wheel --no-cache-dir --wheel-dir /wheels -r requirements.txt
+
+# Runtime stage
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Copy wheels and install
+COPY --from=builder /wheels /wheels
+RUN pip install --no-cache-dir /wheels/* && rm -rf /wheels
+
+COPY . .
+
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "4"]
+```
+
+## Docker Compose
+
+Example `docker-compose.yml`:
+
+```yaml
+services:
+ web:
+ build: .
+ ports:
+ - "8000:8000"
+ environment:
+ - DATABASE_URL=postgres://db:5432/myapp
+ depends_on:
+ - db
+ deploy:
+ resources:
+ limits:
+ cpus: '2'
+ memory: 512M
+
+ db:
+ image: postgres:15
+ environment:
+ - POSTGRES_DB=myapp
+ - POSTGRES_PASSWORD=secret
+ volumes:
+ - postgres_data:/var/lib/postgresql/data
+
+ nginx:
+ image: nginx:alpine
+ ports:
+ - "80:80"
+ volumes:
+ - ./nginx.conf:/etc/nginx/nginx.conf:ro
+ depends_on:
+ - web
+
+volumes:
+ postgres_data:
+```
+
+## Kubernetes Deployment
+
+Example Kubernetes deployment:
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+ name: myapp
+spec:
+ replicas: 3
+ selector:
+ matchLabels:
+ app: myapp
+ template:
+ metadata:
+ labels:
+ app: myapp
+ spec:
+ containers:
+ - name: myapp
+ image: myapp:latest
+ ports:
+ - containerPort: 8000
+ env:
+ - name: GUNICORN_WORKERS
+ value: "4"
+ resources:
+ limits:
+ cpu: "1"
+ memory: "512Mi"
+ requests:
+ cpu: "500m"
+ memory: "256Mi"
+ livenessProbe:
+ httpGet:
+ path: /health
+ port: 8000
+ initialDelaySeconds: 10
+ periodSeconds: 10
+ readinessProbe:
+ httpGet:
+ path: /health
+ port: 8000
+ initialDelaySeconds: 5
+ periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+ name: myapp
+spec:
+ selector:
+ app: myapp
+ ports:
+ - port: 80
+ targetPort: 8000
+```
+
+## Graceful Shutdown
+
+Gunicorn handles `SIGTERM` gracefully by default. Configure the timeout:
+
+```dockerfile
+CMD ["gunicorn", "app:app", \
+ "--bind", "0.0.0.0:8000", \
+ "--graceful-timeout", "30", \
+ "--timeout", "120"]
+```
+
+Match Docker's stop timeout:
+
+```yaml
+# docker-compose.yml
+services:
+ web:
+ stop_grace_period: 30s
+```
+
+## Logging
+
+Log to stdout/stderr for Docker log collection:
+
+```python
+# gunicorn.conf.py
+accesslog = "-"
+errorlog = "-"
+loglevel = "info"
+```
+
+Use JSON logging for log aggregation:
+
+```python
+# gunicorn.conf.py
+import json
+import datetime
+
+class JsonFormatter:
+ def format(self, record):
+ return json.dumps({
+ "timestamp": datetime.datetime.utcnow().isoformat(),
+ "level": record.levelname,
+ "message": record.getMessage(),
+ })
+
+logconfig_dict = {
+ "version": 1,
+ "formatters": {
+ "json": {"()": JsonFormatter}
+ },
+ "handlers": {
+ "console": {
+ "class": "logging.StreamHandler",
+ "formatter": "json",
+ "stream": "ext://sys.stdout"
+ }
+ },
+ "root": {
+ "handlers": ["console"],
+ "level": "INFO"
+ }
+}
+```
+
+## Troubleshooting
+
+### Worker Timeout
+
+If workers are killed with `[CRITICAL] WORKER TIMEOUT`, increase the timeout:
+
+```bash
+gunicorn app:app --timeout 120
+```
+
+Or investigate slow requests in your application.
+
+### Out of Memory
+
+If containers are OOM-killed:
+
+1. Reduce worker count
+2. Use `--max-requests` to restart workers periodically
+3. Increase container memory limits
+
+```bash
+gunicorn app:app --workers 2 --max-requests 1000 --max-requests-jitter 100
+```
+
+### Connection Reset
+
+If you see connection resets, ensure:
+
+1. Load balancer health checks match your `/health` endpoint
+2. Graceful timeout is sufficient for in-flight requests
+3. Keepalive settings match between Gunicorn and upstream proxy
+
+## See Also
+
+- [Deploy](../deploy.md) - General deployment patterns
+- [Settings](../reference/settings.md) - All configuration options
diff --git a/docs/content/index.md b/docs/content/index.md
new file mode 100644
index 00000000..7a9136b5
--- /dev/null
+++ b/docs/content/index.md
@@ -0,0 +1,127 @@
+---
+template: home.html
+title: Gunicorn - Python WSGI HTTP Server
+---
+
+
+
+
+⚖️
+
+### Arbiter
+
+Orchestrates the worker pool. Listens for signals (`TTIN`, `TTOU`, `CHLD`,
+`HUP`) to adjust workers, restart them on failure, or reload configuration.
+
+
+
+⚙️
+
+### Worker Pool
+
+Each worker handles requests independently. Worker types determine
+concurrency model: sync, threaded, or async via greenlets/asyncio.
+
+
+
+📡
+
+### Signal Communication
+
+`TTIN`/`TTOU` adjust worker count. `CHLD` triggers restart of crashed
+workers. `HUP` reloads configuration. See [Signals](signals.md).
+
+ 
+
+
+ The Python WSGI Server
++ Battle-tested. Production-ready. One command to serve your Python apps. +
+ +
+
+
+
+
+
+
+
+ $ pip install gunicorn
+ $ gunicorn myapp:app
+ # Listening at http://127.0.0.1:8000
+
+
+
+Why Gunicorn?
+
+
+
+
+ Production-Proven
+Trusted by thousands of companies. The pre-fork worker model handles traffic spikes gracefully.
+
+
+ Lightweight
+Minimal dependencies, simple configuration. Efficient from containers to bare metal.
+
+
+ Compatible
+Works with any WSGI or ASGI framework. Django, Flask, FastAPI—it just runs.
+
+
+Works With Your Stack
+WSGI and ASGI frameworks, no changes needed
+
+ Django
+ Flask
+ FastAPI
+ Pyramid
+ Starlette
+ Falcon
+ Bottle
+ Quart
+
+
+
+Choose Your Worker
+
+
+
+ Sync
+The default. One request per worker. Simple and predictable.
+ + +Async (Gevent/Eventlet)
+Thousands of concurrent connections for I/O-bound workloads.
+ + +Threads
+Multiple threads per worker. Balance concurrency and simplicity.
+ + +ASGI Beta
+Native asyncio for FastAPI, Starlette, and async frameworks.
+ +