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!

Click each section below to expand

Real Time Data

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

Collaboration Awareness

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

Chat & Messaging

Allow users to coordinate and achieve common goals through embedded chat and messaging.

Real Time Data

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.

Effortlessly Synchronize Data in Real Time

var domain = new ConvergenceDomain(url);
var modelService = domain.models();
modelService.openModel("people", "fred").then(model => {
// the model is {firstName: “Fred”, lastName: “Flanders”}// A real time string
var firstName = model.elementAt("firstName");
firstName.on("set", evt => {
console.log(firstName.value());
});

firstName.on("insert", evt => {
console.log(firstName.value());
});

firstName.on("remove", evt => {
console.log(firstName.value());
});

// Listen to course grained events
firstName.on("model_changed", evt => {
console.log('change');
});

// 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"
});

Collaboration Awareness

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.

Provide the visual cues users need to work together

domain.models().open(“collection”, model).then( model => {
var rtString = model.elementAt(“myString”);
// Create and publish a local cursor.
var localCursor = rtString.indexReference("cursor");
localCursor.set(3);
localCursor.publish();// Listen for remote references.
rtString.on("reference", refEvent => {
var 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”):
});
});
});

Chat & Messaging

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.

Fully-functional chat in minutes

// Join a chat room by Id.
var room = domain.chat().joinRoom('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
room.leave();
});

Presence

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

Users & Authentication

Use the built in user store, or integrate with your own identity management system using JWTs.
Real Time Data Types Icon

Real Time Administration

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

Model Presence

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.

See who is working on what in real time

domain.models().open(“collection”, model).then( model => {
// see who else is currently editing
console.log(model.collaborators());// listen for when someone opens a model
model.on(“collaborator_opened”, evt => {
console.log(evt);
});

// listen for when someone closes the model
model.on(“session_closed”, evt => {
console.log(evt);
});
});

Authentication

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.

Flexible authentication made easy

var domainUrl = "https://api.convergence.io/realtime/domain/demo/code-editor"// 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";
ConvergenceDomain.connectWithJwt(jwt);

Real Time Administration

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.

Powerful tools for users, data and more

Administration interface