Real time in no time:Collaborative App Development Made Easy

Introducing the revolutionary API for building realtime collaborative applications.

Everybody wants realtime collaboration in their apps, but few have it.  It’s been too hard.  We’re here to change that.  With Convergence, what used to take months to build now takes days.  We've solved the hard problems -- now what will you build?

Convergence Labs is looking for interested developers to join our private alpha.

Powering the Next Generation of Collaborative Software

  • Fine grained, live editing of shared data
  • See who is online and what they are doing
  • Shared cursors, pointers, and viewports
  • Flexible identity, authentication, and security
  • Coordinate through embedded messaging
  • History and playback of editing sessions
  • Zero setup required with an easy to use API

We believe it should be easy for everyone to share and collaborate with each other in real-time. Whether it be for work or play, real-time collaboration is the killer feature that will set your app apart from its competitors. Convergence provides all the features a modern developer needs to deliver effective collaboration in their apps, packaged into one convenient API. With Convergence you can build highly collaborative apps in hours, not months. Take a look at our key features below, and start hacking today!

data sync icon

Real Time Data

Bring your data to life through shared data structures that keep all clients in sync in real time.
moving cursor icon

Collaboration Awareness

Help users work together efficiently through awareness of what each person is doing.
chat bubble icon

Chat & Messaging

Allow users to coordinate and achieve common goals through embedded chat and messaging.
Real time data is at the heart of any collaborative app. Like other services, Convergence stores your data in the cloud and allows access to it from anywhere and any device. But it is the only platform designed from the ground up for highly interactive applications and real-time, shared, simultaneously modifiable data. As one client changes the data, all other clients are kept in sync and our concurrency control algorithms ensure data integrity is maintained. In the example to the right, we open a data model and get the “firstName” property: this is a RealTimeString object. From that we set some listeners on the firstName in order to see edits in real time. Then we do a series of mutations to the string.
const url = "<username>/<domain-id>/";
Convergence.connectAnonymously().then(domain => {
  const modelService = domain.models();
  modelService.openModel("people", "fred").then(model => { 
    // the model is {firstName: “Fred”, lastName: “Flanders”}
    // A real time string 
    const firstName = model.elementAt("firstName");
    firstName.on("set", evt => { 
    firstName.on("insert", evt => { 
    }); firstName.on("remove", evt => { 

    // Listen to course grained events
    firstName.on("model_changed", evt => { 

    // Set the string 
    firstName.set("Ted"); // "Ted", "change" 

    // Delete the "T" at index 1
    firstName.remove(0, 1); // "ed", "change" 

    // Insert an "N" at index 0. 
    firstName.insert("N", 0); // "Ned", "change"  

Provide the visual cues users need to work together

For users to effectively collaborate together, each user needs to know what every other user is doing. Shared cursors, selections, and pointers help users anticipate what others are about to do, helping them coordinate and avoid conflicts. These references are relative to the shared data and need to be aware of changes in state. Convergence greatly simplifies this and does the heavy lifting for you, making it easy to provide collaborative cues.
domain.models().open(“collection”, model).then( model => {
  const rtString = model.elementAt(“myString”);

  // Create and publish a local cursor.
  const localCursor = rtString.indexReference("cursor");
  localCursor.publish();// Listen for remote references.
  rtString.on("reference", refEvent => {
    const reference = refEvent.reference;
    reference.on("set", e => {
      console.log(“remote cursor set: ” + e.value);

    reference.on("cleared", e => {
    console.log(“remote cursor cleared”);

    reference.on("disposed", e => {
      console.log(“no more cursor”):

Fully-functional chat in minutes

Users of any social or collaborative software expect basic messaging or chat capabilities. Just look at Facebook, Google Docs, or even Stack Overflow. We recognize this and built in tools to make messaging brain-dead easy. Chat is a simple concept -- don't waste your time re-inventing the wheel.
// Join a chat room by Id.
const room ='my-chat-room').then(room => {
  // Receive Messages
  room.on("message", event => {
    console.log(new Date(event.timestamp) + " " event.username + ": " + event.message);

  // Send Messages
  room.send("Hello Chat Room");

  // Leave the room
buddy list icon


Easily track who is online and available to work with. Building and tracking buddy lists is simple.
Padlock icon

Users & Authentication

Use the built in user store, or integrate with your own identity management system using JWTs.
Easel icon

Real Time Administration

Monitor your App in real time. Interact with your data like never before.

See who is working on what in real time

Effective communication requires knowing who is online, available, and working on what data. We provide a convenient presence API so you can design an application where your users aren't stepping on one another's toes.
domain.models().open(“collection”, model).then( model => {
  // see who else is currently editing

  // listen for when someone opens a model
  model.on(“collaborator_opened”, evt => {

  // listen for when someone closes the model
  model.on(“session_closed”, evt => {

Flexible authentication made easy

Whether you are building something quickly from scratch or want to add collaborative features to an existing product, we have an authentication solution to meet your needs. If you don’t already have a user store, you can manage your users in Convergence and authenticate them using a username and password stored in our system. This is the easiest way to get started.If you already have an identity management system, you can integrate with Convergence by leveraging a JSON Web Token (JWT). When using a JWT, a trust relationship is set up between your authentication store and Convergence. Users are automatically created in Convergence when authenticated via JWTs.
const domainUrl = "<username>/<domain-id>/"

// Authenticate using a username and password stored in Convergence
ConvergenceDomain.connect(domainUrl, "username", "password");

// Authenticate anonymously
ConvergenceDomain.connectAnonymously("display name");

// Authenticate with a JWT
var jwt = "myJwt";

Powerful tools for users, data and more

Convergence provides access to an intuitive administration interface with every account. Organize your data models at three different levels, add users, and see your platform usage and plan details at a glance. Included in the web UI is the Sapphire Model Editor, our open-source data model viewer/editor. It is an indispensable tool for debugging your data and making granular modifications, much like a traditional database client but (of course) with real time updates.
Administration interface

Getting Started with Convergence

Check out these resources to get a taste of the API and the possibilities it allows!

Ten Minute Tutorial

See how easy it is to get browser-based collaboration up and running.

Start Coding

keep calm and try coding
Ready to start developing? Check out our getting started guide to get up and runing in now time.

Convergence Examples

Take a look at a few live functional examples that illustrate several core features, complete with source code.

Convergence Demos

Check out the collaborative UX you can achieve with Convergence in more full featured demonstration apps.