django/channels
Channels
Channels is an extension for the Django web framework that adds native support for WebSockets, background tasks, and long-running connections alongside standard HTTP requests. It provides a channel layer abstraction for passing messages between different parts of a Django application across processes, along with a protocol router that inspects incoming connections and dispatches them to the correct handler for HTTP, WebSocket, or custom protocols.
The project introduces an async consumer abstraction that wraps protocol-specific handling into a single callable, and a background worker pool that runs consumer instances in separate processes to process channel layer messages outside the request-response cycle. It includes a channel layer backend with a generic publish-subscribe interface backed by Redis or in-memory stores, and a test client simulator that emulates a full ASGI stack for testing virtual HTTP and WebSocket connections without a real server.
Channels handles WebSocket connection management, long-poll HTTP requests, and non-HTTP protocol connections through a protocol type router. It supports real-time client updates, multi-user chat room management, and cross-process communication for building live features like chat and notifications. The project also provides WebSocket user authentication and testing utilities for verifying consumer behavior in automated test suites.
The documentation covers installation, setup, and usage patterns for integrating these capabilities into a Django project.
Features
- Real-Time Extensions - An extension for Django that adds native support for WebSockets, background tasks, and long-running connections alongside HTTP.
- ASGI Servers - Implements the ASGI interface to handle low-level network I/O and lifecycle events for all connection types.
- Django Channel Workers - An abstraction for passing messages between different parts of a Django application across processes.
- WebSocket Push Updates - Sends live data from the server to connected browsers over WebSockets to display new events without polling.
- Redis-Backed Pub-Sub Layers - Provides a generic publish-subscribe interface backed by Redis or in-memory stores for cross-process message passing.
- Websocket Connection Managers - Manages persistent bidirectional WebSocket connections alongside standard HTTP requests in a single application.
- HTTP/2 and WebSocket Servers - Terminates both HTTP and WebSocket connections with a dedicated server that handles low-level network protocols.
- Multi-Protocol Handshake Routers - Inspects the connection's initial handshake and routes it to the correct consumer class for HTTP, WebSocket, or custom protocols.
- Application-Level Protocol Routers - Inspects incoming connections and dispatches them to the correct handler for HTTP, WebSocket, or custom protocols.
- WebSocket Authentication and Testing - Verifies user identity on WebSocket connections and simulates real-time connections in automated tests.
- WebSocket Authentications - Verifies the identity of a user on a WebSocket connection using the existing authentication system.
- WebSocket Extensions - Adds native WebSocket support to Django for real-time features like chat and notifications.
- Protocol-Specific Dispatchers - Wraps protocol-specific handling into a single async callable that dispatches events to user-defined methods.
- Async Task Processors - Processes background tasks and long-poll HTTP requests in an asynchronous style within a Django project.
- Background Task Execution - Runs asynchronous tasks outside the request-response cycle using a dedicated worker process.
- Multi-User Chat Room Managers - Builds chat rooms where multiple participants exchange messages that appear instantly for all connected users.
- Cross-Process Message Routing - Sends messages between different parts of an application using a channel layer to enable real-time features like chat and notifications.
- Django Channel Layer Bridges - Passes messages between different parts of a Django application across processes to enable real-time coordination.
- Non-HTTP Protocol Acceptors - Accepts and processes connections using protocols other than HTTP within a single application.
- Connection Simulators - Simulates WebSocket and HTTP connections in tests to verify how consumers and handlers behave.
- Arbitrary Protocol Handlers - Provides a flexible layer for handling arbitrary network protocols beyond HTTP and WebSocket.
- Background Task Offloading - Moves long-running work outside the request-response cycle so the HTTP layer stays responsive.
- ASGI Stack Simulators - Emulates a full ASGI stack in tests to send and receive messages over virtual HTTP and WebSocket connections.
- Background Processing Workers - Runs consumer instances in separate processes to process channel layer messages outside the request-response cycle.
- Channel-Based Workers - Runs long-running or periodic work outside the request-response cycle using a channel layer and worker processes.
- Real-Time Group Messaging - Creates a multi-user chat room where participants can send messages and see others' messages appear immediately.
- Testing Utilities - Verifies that asynchronous WebSocket handlers behave correctly using automated test utilities.
- Async and Real-time - Native asynchronous support and WebSocket handling.
- Websockets - Listed in the “Websockets” section of the Awesome Python awesome list.
- WebSocket - Developer-friendly asynchrony for Django.
- WebSocket Tools - Asynchronous tools for Django.
