awesome-repositories.com
Blog
MCP
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
partykit avatar

partykit/partykit

0
View on GitHub↗
5,644 estrellas·199 forks·TypeScript·MIT·13 vistasdocs.partykit.io↗

Partykit

PartyKit is a serverless WebSocket backend platform for building real-time multiplayer applications. It provides a globally distributed edge computing runtime that runs stateful server code close to users, with automatic scaling and hibernation for idle rooms. The platform handles WebSocket connections, HTTP requests, and durable storage without requiring infrastructure management, and includes a client and server SDK with hooks, storage, and Yjs integration for building collaborative features.

The platform distinguishes itself through per-room isolation using Durable Objects, where each unique room identifier gets its own isolated server instance that maintains persistent state. It supports hibernation-based resource management that puts idle room processes to sleep while keeping client connections open, and provides edge-native WebSocket servers with near-zero cold starts. PartyKit includes built-in Yjs document synchronization for CRDT-based conflict resolution, key-value state persistence that survives restarts, and MessagePack binary encoding for efficient data transfer.

The platform covers collaborative document editing with live presence and cursor tracking, real-time multiplayer applications with synchronized state, and serverless real-time backends with scheduled tasks and AI integration. It includes a CLI for project management and deployment, environment variable and secret management, preview environments, and CI/CD integration for automated deployments. Monitoring capabilities include live log tailing and connection tracking, while security features cover WebSocket and HTTP authentication, data validation, and rate limiting.

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.

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI
  • 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.

    • Historial de estrellas

    Gráfico del historial de estrellas de partykit/partykitGráfico del historial de estrellas de partykit/partykit

    Alternativas open-source a Partykit

    Proyectos open-source similares, clasificados según cuántas características comparten con Partykit.
    • ueberdosis/hocuspocusAvatar de ueberdosis

      ueberdosis/hocuspocus

      2,455Ver en GitHub↗

      Hocuspocus is a backend framework designed to facilitate real-time collaborative editing and state synchronization in web applications. It functions as a server-side infrastructure that manages persistent WebSocket connections, enabling multiple users to edit shared documents simultaneously while maintaining data consistency through a conflict-free replicated data type engine. The platform distinguishes itself through a modular, middleware-driven architecture that allows developers to intercept document lifecycle events, enforce custom access control policies, and integrate external services.

      TypeScriptcollaborative-editingcrdtprosemirror
      Ver en GitHub↗2,455
    • jsfiddle/togetherjsAvatar de jsfiddle

      jsfiddle/togetherjs

      7,006Ver en GitHub↗

      Togetherjs is a real-time collaboration framework designed to synchronize application state, cursors, and navigation across multiple user sessions. It provides a synchronization tool for shared browsing and a signaling server to facilitate peer-to-peer communication. The project integrates audio chat and media streaming via peer-to-peer technology, allowing collaborators to engage in live voice communication. It includes a presence and identity manager to map session participants to custom profiles, names, and avatars. The framework covers a broad surface of collaborative capabilities, inclu

      JavaScript
      Ver en GitHub↗7,006
    • liveblocks/liveblocksAvatar de liveblocks

      liveblocks/liveblocks

      4,438Ver en GitHub↗

      Liveblocks is a realtime collaboration infrastructure platform that synchronizes application state, documents, and user presence across multiple participants using conflict-free replicated data types. It provides a managed backend for collaborative text editors, threaded commenting and annotation systems, in-app notifications, and AI copilot deployment, all built on a WebSocket transport layer with server-side room management APIs. The platform distinguishes itself through a headless component primitive system that exposes unstyled React hooks and composable building blocks, allowing develope

      TypeScriptai-agentsai-copilotcollaboration
      Ver en GitHub↗4,438
    • ithewei/libhvAvatar de ithewei

      ithewei/libhv

      7,521Ver en GitHub↗

      libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

      Ccurlepollhttp-client
      Ver en GitHub↗7,521
    Ver las 30 alternativas a Partykit→

    Preguntas frecuentes

    ¿Qué hace partykit/partykit?

    PartyKit is a serverless WebSocket backend platform for building real-time multiplayer applications. It provides a globally distributed edge computing runtime that runs stateful server code close to users, with automatic scaling and hibernation for idle rooms. The platform handles WebSocket connections, HTTP requests, and durable storage without requiring infrastructure management, and includes a client and server SDK with hooks, storage, and Yjs integration for building…

    ¿Cuáles son las características principales de partykit/partykit?

    Las características principales de partykit/partykit son: Real-Time Backend Hosting, Global Stateful Workers, Per-Room Server Isolations, Collaborative Editors, Server Instance Definitions, Application State Synchronizations, Session-Surviving Document Persistence, Edge Runtime Deployments.

    ¿Qué alternativas de código abierto existen para partykit/partykit?

    Las alternativas de código abierto para partykit/partykit incluyen: jsfiddle/togetherjs — Togetherjs is a real-time collaboration framework designed to synchronize application state, cursors, and navigation… ueberdosis/hocuspocus — Hocuspocus is a backend framework designed to facilitate real-time collaborative editing and state synchronization in… liveblocks/liveblocks — Liveblocks is a realtime collaboration infrastructure platform that synchronizes application state, documents, and… ithewei/libhv — libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP,… loro-dev/loro — Loro is a conflict-free replicated data type (CRDT) framework and collaborative state engine designed for building… atom-archive/xray — Xray is a collaborative text editor and distributed workspace manager that utilizes conflict-free replicated data…