partykit/partykit

Features

• Real-Time Backend Hosting - Provides a serverless platform for deploying real-time backends with persistent state, scheduled tasks, and AI integration.
• Global Stateful Workers - Executes application logic on a globally distributed worker that maintains persistent state for real-time collaboration.
• Per-Room Server Isolations - Spins up an isolated server instance per unique room identifier, routing all connections for that ID to the same stateful worker.
• Collaborative Editors - Keeps a shared document in sync across all connected editors so changes appear instantly for every collaborator.
• Server Instance Definitions - Defines multiple server instances within a single deployment, each handling distinct functionality.
• Application State Synchronizations - Broadcasts state changes to all connected clients so every participant sees the same data without polling.
• Session-Surviving Document Persistence - Saves the latest document state to durable storage so it survives when all clients disconnect.
• Edge Runtime Deployments - Runs business logic on the platform using JavaScript or WebAssembly with local development tools and preview deployments.
• Edge Instance Scaling - Spins up lightweight server instances with near-zero startup time in hundreds of data centers, scaling automatically with traffic.
• Game State Synchronizations - Broadcasts every player's move to all connected clients, keeping the game board identical for everyone.
• Key-Value Persistence Stores - Stores and retrieves per-room data using transactional key-value storage that survives server restarts and redeployments.
• Chat Message Broadcasting - Sends chat messages to every connected participant in real time during a shared viewing session.
• WebSocket Connections - Accepts standard HTTP and WebSocket connections from browsers, mobile apps, and embedded devices without proprietary protocols.
• Server-Side Editor State Persistence - Saves the current editor content to a database so it survives server restarts and new joiners see the latest version.
• Transactional Key-Value Modifications - Saves room data to transactional key-value storage so it survives server restarts and redeployments.
• Programmatic Server Logic Definitions - Writes server logic in a class or module that the platform instantiates and runs as a Durable Object.
• Real-time Synchronization - Broadcasts local edits to all connected peers in real time, keeping every participant's document identical.
• Collaborative Application SDKs - Ships a client and server SDK with hooks, storage, and Yjs integration for building collaborative multiplayer features.
• Collaborative Real-Time Editing - Embeds Yjs-based collaborative editing so multiple users can edit shared documents in real time.
• WebSocket Client SDKs - Connects browser or Node.js clients to a real-time server using a dedicated WebSocket client library.
• Alarm-Based Schedulers - Sets timers that wake a room at a specified future time to run a callback, enabling periodic maintenance or reminders.
• Room Hibernation - Puts idle room processes to sleep while keeping client connections open, waking on message arrival to free memory.
• Edge Function Runtimes - Provides a globally distributed runtime for executing stateful server code close to users with automatic scaling.
• Application Behavior Configurations - Defines server behavior, connection limits, and runtime settings through a structured configuration file.
• Edge Network Deployment - Hosts server instances across hundreds of data centers worldwide for low-latency access.
• Edge Web - Deploys custom server logic written in TypeScript, JavaScript, or WebAssembly to a globally distributed runtime.
• Real-Time - Deploys the WebSocket server to the platform's infrastructure, producing a public URL for client connections.
• Serverless WebSocket - Deploys the server to a live domain, provisioning a unique URL for immediate access and sharing.
• Real-Time Backend Deployments - Packages and deploys serverless functions that handle WebSocket connections and state synchronization without managing infrastructure.
• Watch Party Hosting - PartyKit synchronizes video playback state across viewers so everyone sees the same frame at the same moment.
• WebSocket Backend Hosting - Provides a serverless backend that handles WebSocket connections, HTTP requests, and durable storage without infrastructure management.
• Serverless Deployment - Pushes the server to production so it is accessible over the internet.
• WebSocket Deployments - Deploys a programmable server that maintains persistent state and handles real-time WebSocket connections on a global edge network.
• Multi-User Chat Room Managers - Creates a chat application with multiple rooms, user avatars, and persistent message history for real-time conversations.
• Room-Based Message Routing - Sends incoming messages from one client to every other connected client in the same room.
• Broadcast Messaging - Broadcasts messages to all connected WebSocket clients in a room, with optional exclusion of specific connections.
• Websocket Connection Managers - Opens and maintains persistent WebSocket connections between clients and a server for live bidirectional data exchange.
• Hibernating Connection Managers - Puts idle room processes to sleep while keeping client connections open, waking on message arrival to free memory.
• React WebSocket Lifecycle Managers - Connects a WebSocket on component mount, disconnects on unmount, and cleans up event handlers automatically.
• Room-Based Connection Routers - Connects to a specific party instance by providing its name and a room identifier in the URL path.
• WebSocket Clients and Servers - Opens a WebSocket server that accepts connections and creates dedicated room instances per unique identifier.
• WebSocket Servers - Provides a server-side framework for managing WebSocket connections, room isolation, and state persistence.
• Edge - Runs WebSocket servers directly on a globally distributed edge network, maintaining persistent connections with near-zero cold starts.
• HTTP and WebSocket Clients - Accepts standard HTTP requests and WebSocket connections from any client for real-time bidirectional communication.
• Incoming Message Processors - Processes incoming server messages via WebSocket to update local component state and refresh the user interface.
• Independent Server Instance Hosting - Runs multiple independent server instances within a single project, each with its own entry point and state.
• Room-Based Client Grouping - Forwards messages from one client to every other client connected to the same room for real-time collaboration.
• Persistent Chat Rooms - Creates real-time chat rooms where multiple users can exchange messages simultaneously over WebSocket connections.
• Real-Time Multiplayer Frameworks - Provides a framework for building real-time multiplayer applications with synchronized state and WebSocket connections.
• State Synchronization - Keeps a shared data structure consistent across all connected clients by applying and broadcasting incremental changes in real time.
• Real-Time Connections - Opens persistent WebSocket connections from clients to server rooms using a React hook for live UI updates.
• Collaborative State Synchronization - Sets up WebSocket servers that broadcast messages and synchronize state across connected clients in real time.
• Multiplayer Application Infrastructure - Uses WebSocket connections to keep multiple clients in sync for multiplayer features without infrastructure management.
• Edge WebSocket Scaling - Routes and optimizes WebSocket connections across edge computing networks to support thousands of concurrent users.
• Server Entry Point Definitions - Defines the primary server file that handles WebSocket connections and state synchronization.
• State Change Broadcasting - Sends state changes to every WebSocket client in a room as soon as they occur, keeping all participants synchronized.
• Serverless Project Deployments - Publishes project code to the platform using a specified entry point and project name.
• Server-Side Logic Frameworks - Implements arbitrary business logic in TypeScript, JavaScript, or WebAssembly on the server side, using npm packages for common workflows.
• Collaborative Room Presence Tracking - Maintains a live list of currently connected users and notifies the room when someone joins or leaves.
• Real-Time Collaborative Editing - Broadcasts document edits to all participants so changes appear instantly across clients.
• Yjs-Based Collaborative Editing - Embeds Y.js-based collaborative editing into applications so multiple users can edit shared documents simultaneously.
• Collaborative Cursor Tracking - Ships a collaborative cursor tracking system that broadcasts pointer positions to all connected clients in real time.
• WebSocket Hooks - Provides a hook that manages the WebSocket connection and provider lifecycle inside a React application.
• Multiplayer Synchronization - Keeps all players' game state in sync in real time by broadcasting moves and updates over WebSocket connections.
• Presence Tracking - Broadcasts presence updates so every connected client sees who is currently online in a shared space.
• Server-Side State Persistence - Stores and retrieves data on the server so shared state survives client disconnections and page reloads.
• Collaboration Room Routing - Spins up an isolated, stateful server instance for each unique identifier, routing all connections for that ID to the same room.
• Yjs Document Synchronizations - Embeds a Yjs provider to synchronize shared data structures like text or JSON across clients using CRDT-based conflict resolution.
• Real-Time Chat Bot Integrations - Connects a room to an AI model so the bot participates in conversations alongside human users.
• Live Debugging Tools - Streams real-time logs and errors from the deployed server to diagnose issues in production.
• Frontend Integration Starters - Provides pre-configured project templates that wire the service into specific frontend frameworks.
• Autonomous Chat Agents - Integrates AI-driven non-player characters that can autonomously interact with users in chat rooms.
• Page View Tracking - Tracks and displays the number of users currently viewing each page in real time.
• Per-Mutation State Persisters - Writes updated data to storage every time a client creates or modifies a resource, keeping the persisted copy in sync with live changes.
• External Document Synchronization - Loads a document from an external service on first connection and pushes updates back via a callback.
• MessagePack Serializers - Serializes JavaScript objects into a compact binary format using MessagePack to reduce message size.
• Room State Restorers - Reads persisted data from storage when the first connection arrives or after a server restart, restoring the room's previous state.
• Build-Time Constants - Substitutes global identifiers with fixed values during the build process for configuration or feature flags.
• Framework-Specific Synchronizations - Connects a Remix application to a WebSocket server so multiplayer state updates are shared across all connected clients.
• Per-Environment Overrides - Overrides environment variable values for a specific deployment using a .env file or command-line arguments.
• Document Edit Histories - Records every change made to a document, enabling offline edits and later synchronization when clients reconnect.
• Typed Transactional Storage - Accepts any structured-clone-compatible value as a storage entry without requiring manual JSON serialization.
• Real-Time Chat Synchronizers - Starts a chat application that stores data locally and synchronizes updates across users in real time.
• Remote Server Synchronization - Synchronizes application state between a local cache and a remote server, enabling offline-capable, collaborative features.
• Secret Management - Stores and injects environment variables securely into the deployed server without exposing them in code.
• Room State Hibernation Persisters - Saves room state to storage or an external database so it can be reloaded when the room wakes from hibernation.
• Turn Managers - Coordinates turn order and validates moves on the server so only legal actions are applied to the shared game state.
• Playback Synchronizers - Keeps all participants' video players at the same timestamp so everyone watches in sync.
• Reaction Broadcasters - Synchronizes reaction counters across all connected clients in real time as users interact.
• AI Response Streams - Streams AI-generated text or data to connected clients in real time using integrated AI capabilities.
• Spatial Chat Room Maps - Arranges chat rooms spatially on a map interface so users can navigate between them.
• Multiplayer Game Servers - Manages game state and player actions over WebSockets so participants interact in real time.
• Live Polls - Creates a real-time poll where votes update instantly across all connected clients without page refreshes.
• HTTP Data Submission - Sends form data from client applications to the real-time server via HTTP requests for processing and storage.
• Real-Time Polls - Creates a poll via an HTTP request and broadcasts votes to all connected users in real time over WebSocket.
• Connection Lifecycle Notifications - Triggers custom logic on client join or leave events for room awareness and messaging.
• WebSocket Message Interception - Transmits user actions to the server through established WebSocket connections for immediate processing.
• Source Request Authentications - Verifies user identity on incoming HTTP requests by checking a session token in an Authorization header.
• Shared Secret Authentication - Uses a pre-shared secret key to authorize server-to-server communication without per-user tokens.
• JWT Authentications - Decodes and verifies JSON Web Tokens to authenticate requests in a serverless runtime.
• WebSocket Authentications - Verifies user identity before a WebSocket connection is established by checking a session token.
• Environment Variable Managers - Creates, updates, lists, removes, and syncs environment variable keys and values for deployed projects.
• Environment Variables - Defines key-value pairs available to the server at runtime through the room object.
• Data Schema Validation - Checks WebSocket messages and HTTP request payloads against a predefined schema, rejecting mismatches.
• Live Tally Displays - Collects and aggregates votes from connected clients in real time and displays the running tally to all participants.
• Active Connection Monitors - Reports the number of active WebSocket connections to a room at any given moment.
• Live Log Streaming - Streams real-time logs and errors from deployed projects to help debug issues during live traffic.
• Active - Displays avatars of users currently engaged with a shared resource, updating automatically as they join or leave.
• Server-Side Data Fetching - Retrieves data from a real-time server using HTTP requests and renders it in a client application.
• Binary Data Handling - Processes WebSocket messages as raw binary buffers instead of strings for efficient data transfer.
• HTTP Request Handling - Handles HTTP requests alongside WebSocket connections, enabling server components to interact with room data without persistent sockets.
• HTTP Response Handling - Handles HTTP responses alongside WebSocket connections for push/pull interactions with room state from non-WebSocket environments.
• Cursor Synchronization - Streams each user's cursor coordinates to all other participants for live collaborative awareness.
• Live Poll - Creates a reusable web component that displays poll results and updates them in real-time as users cast votes.

Star history