deepstreamio/deepstream.io

★ 7,188TypeScriptAudience · developerComplexity · 3/5Setup · moderate

Mindmap

mindmap
  root((repo))
    Core Features
      Records live data
      Events pub/sub
      RPCs remote calls
    Security
      Auth built in
      Valve permissions
    Tech Stack
      TypeScript
      Node.js
      Docker
    Setup
      npm install
      npm start
      End-to-end tests

mindmap root((repo)) Core Features Records live data Events pub/sub RPCs remote calls Security Auth built in Valve permissions Tech Stack TypeScript Node.js Docker Setup npm install npm start End-to-end tests

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Build a collaborative editing app where multiple users see each other's changes instantly using deepstream Records

USE CASE 2

Add real-time event notifications or chat to a web app using deepstream pub/sub Events

USE CASE 3

Distribute task processing across multiple backend services using deepstream RPCs with automatic load balancing

Tech stack

TypeScriptNode.jsDockernpm

Getting it running

Difficulty · moderate Time to first run · 30min

Requires Node.js 10+ and TypeScript 3+, run npm install then npm start to get a local server running.

In plain English

deepstream.io is an open-source server that helps applications share data and communicate in real time. It was built drawing on concepts from financial trading systems, where speed and reliability across many simultaneous connections are critical. Clients and backend services connect to a deepstream server to sync data, exchange messages, and call remote functions at high speed. The server has three core building blocks. Records are persistent, schema-less documents: any connected client can read or update a record, and every change is pushed to all other clients and services within milliseconds. Records can reference each other and be organized into lists, which makes it possible to model relational data without a fixed schema. Events are the publish/subscribe layer: a client publishes a message on a topic, and any subscriber on that topic receives it. RPCs (remote procedure calls) let one part of a system ask another to perform a task and wait for a result, deepstream handles load balancing and routing so the caller does not need to know which server or process handles the request. Security is built in. The server supports multiple authentication mechanisms and ships a permission language called Valve, which lets developers write rules specifying which users can read, write, or subscribe to which data. The server is written in TypeScript and runs on Node.js. It can be installed as an npm package or run from a Docker image. Contributing to the project requires Node.js 10 or newer and TypeScript 3 or newer, cloning the repository and running npm install followed by npm start is enough to get a local server running. Unit tests and a separate end-to-end test suite are both available. The README notes the design is inspired by financial trading technology, and the core focus is low-latency synchronization across a large number of simultaneous connections.

Copy-paste prompts

Prompt 1

How do I install deepstream.io and write a JavaScript client that connects and syncs a shared Record so two browser tabs see each other's updates in real time?

Prompt 2

Show me how to use deepstream RPCs to send a task from a web client to one of several backend workers, with deepstream handling which worker picks it up

Prompt 3

How do I write a Valve permission rule in deepstream.io that allows only the record's owner to write to it, while any authenticated user can read it?

Open on GitHub → Explain another repo

← deepstreamio on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.