Note: This page is a work in progress. I plan to update this page with new technologies as I find them and increase the information on each as I find the time. If you have any questions or find a technology that should be listed please email me.

You can also contribute to the list by making a pull request to the Realtime Web Technologies Guide github repo.

Hosted Realtime Services

General Messaging & PubSub

Fanout

Build and scale realtime APIs. Fanout’s push CDN makes it easy. Add live updates to your websites and web services using REST, HTTP streaming, WebSockets, Webhooks, and XMPP

  • WebHooks
  • PubSub
  • XMPP
  • REST
  • WebSockets
  • HTTP Streaming
  • HTTP Long-Polling

Hydna

Hydna is a hosted backend into which you can send data and have it instantly appear on other devices.

  • Real-Time messaging
  • Binary
  • WebSockets
  • Comet
  • Flash
  • HTTP/REST
  • Behaviors
  • Routing
  • Authentication
  • Room partitioning
  • Presence
  • .NET
  • Erlang
  • Java
  • Node.js
  • Objective-C
  • PHP
  • Python
  • Ruby
  • Multiplexing
Subscribe
JavaScript (client)
var channel = new HydnaChannel('public.hydna.net/my-channel', 'r');

channel.onmessage = function(event) {
  // handle update
};
Publish
JavaScript (client)
var channel = new HydnaChannel('public.hydna.net/my-channel', 'w');

channel.onopen = function(event) {
  channel.send('Hello world');
};
Authentication

Developers can deploy Behaviors (small snippets of code) to Hydna. Behaviors instruct Hydna how to behave when certain actions take place (when a channel is opened for example). This is useful when you want to keep state, authenticate users, connect with external services etc.

The following example describes how authentication can be added to a channel.

Behavior (Hydna BeMachine)
// Create rules for channel "/admin" 
behavior('/admin', {
  open: function (event) {
    if (event.token == 'password) {
      event.allow();
    } else {
      event.deny('Incorrect password');
    }
  }
});
JavaScript (client)
var channel = new HydnaChannel('public.hydna.net/admin?password', 'w');

channel.onopen = function (event) {
  // Granted to open channel, handle update
};

channel.onclose = function (event) {
  if (event.wasDenied && event.data == 'Incorrect password') {
    // Incorrect password
  }
};

PubNub

Pubnub is the fastest cloud-hosted realtime messaging system for web and mobile apps.

  • BOSH
  • Fallback-support
  • Real-Time Client Push
  • Real-Time messaging
  • Real-Time data
  • Coldfusion
  • .NET
  • Erlang
  • Google App Engine (GAE)
  • Java
  • JavaScript
  • Lua-Corona
  • node.js
  • Objective-C
  • Perl
  • PHP
  • Python
  • Ruby
  • Silverlight
  • Titaniumf
  • REST API
  • PubSub
Subscribe
JavaScript (client)
var pubnub = PUBNUB.init({
  subscribe_key: 'demo'
});

pubnub.subscribe({
  channel: 'my_channel',
  message: function( msg )  {
    // handle update
  }
});
Publish
JavaScript (client)
var pubnub = PUBNUB.init({
  publish_key: 'demo'
});

pubnub.publish( {
  channel: 'my_channel',        
  message: 'hello!'
} );
PHP
$pubnub = new Pubnub(
  "demo",  ## PUBLISH_KEY
  "demo",  ## SUBSCRIBE_KEY
  "",      ## SECRET_KEY
  false    ## SSL_ON?
);

$info = $pubnub->publish( array(
  'channel' => 'hello_world',
  'message' => 'Hey World!'
) );    

Pusher

Pusher is a hosted API for quickly, easily and securely adding scalable realtime functionality to web and mobile apps.

  • WebSockets
  • HTTP fallback
  • Flash socket fallback
  • Real-Time Client Push
  • Real-Time messaging
  • Real-Time Data
  • in-built security
  • HTML5
  • JavaScript
  • Objective-C
  • Ruby
  • PHP
  • node.js
  • .NET
  • Silverlight
  • ActionScript
  • Google App Engine (GAE)
  • Erlang
  • Perl
  • Coldfusion
  • Python
  • Groovy
  • Java
  • REST API
  • Presence
  • PubSub
Subscribe
JavaScript (client)
var pusher = new Pusher( 'APP_KEY', options );
var channel = pusher.subscribe( 'my-channel' );
channel.bind( 'my-event', function( eventData ) {
  // handle event
} );
Publish
Node.js
var pusher = new Pusher( { appId: 'APP_ID', key: 'APP_KEY', secret: 'APP_KEY' } );
pusher.trigger( 'my-channel', 'my-event', { "some": "data" } );
PHP
$pusher = new Pusher( 'APP_KEY', 'APP_SECRET', 'APP_ID' );
$pusher->trigger( 'my-channel', 'my_event', array( 'some' => 'data' );

Realtime.co

The Realtime Messaging Framework is a cloud-hosted messaging system for websites and mobile apps that require constant content updates in just a few milliseconds, enabling any application to interact with millions of connected users in a fast and secure way.

  • Websockets
  • Fallback-support (streaming and polling)
  • Real-Time Client Push
  • Real-Time messaging
  • Real-Time data
  • Mobile Push Notifications for iOS and Android (APNS and GCM)
  • .NET
  • Java / Android
  • JavaScript
  • Lua
  • iOS
  • Titanium Appcelerator
  • Windows Phone
  • node.js
  • Objective-C
  • PHP
  • Python
  • C/C++
  • Ruby
  • Silverlight
  • ActionScript
  • REST API
  • Pub/Sub
  • Presence
  • built-in security (authentication and authorization)
  • multiplexing (through the use of channels)
  • HTML5 real-time enabled templating engine (xRTML)
Subscribe
JavaScript (client)
var RealtimeClient = RealtimeFactory.createClient();
RealtimeClient.connect('[YOUR_APPLICATION_KEY]', '[USER_TOKEN]');

RealtimeClient.onConnected = function (theClient) {               
    theClient.subscribe('my-channel', true,
        function (theClient, channel, msg) {
            console.log("Received message:", msg);
        });                                
};    
Publish
JavaScript (client)
var RealtimeClient = RealtimeFactory.createClient();
RealtimeClient.connect('[YOUR_APPLICATION_KEY]', '[USER_TOKEN]');

RealtimeClient.onConnected = function (theClient) {               
    theClient.send('my-channel', 'Hello World');                                
};
PHP
$URL = 'http://ortc-developers.realtime.co/server/2.1';
$AK = '[YOUR_APPLICATION_KEY]';
$PK = '[YOUR_APPLICATION_PRIVATE_KEY]';
$TK = '[USER_TOKEN]'; // not necessary if private key is used

$rt = new Realtime( $URL, $AK, $PK, $TK );
$result = $rt->send("my-channel", "Hello World", $response);

Tambur.io

Tambur.io provides your business with a simple messaging API to build scalable realtime web and mobile apps.

  • Realtime messaging
  • HTTP/REST
  • SSL
  • Websockets
  • Comet
  • Streams
  • Modes
  • Broadcast
  • Unicast
  • Authcast
  • Presence
  • Direct Messaging
  • PHP
  • Ruby
  • Java
  • .Net
  • Erlang
  • JavaScript
Subscribe
JavaScript (client)
var connection = new tambur.Connection("API_KEY", "APP_ID");
var stream = connection.get_stream("my_stream");
stream.onmessage = function(msg){
    // handle message
};    
Publish
Python (client)
tambur = Tambur(api_key='API_KEY', app_id='APP_ID', secret='SECRET')
tambur.publish('my_stream', 'some message')
Modes

Streams can operate in one or several modes. As an example a stream can enable the ‘Authentication’ mode and therefore receive messages that target an authenticated receiver. Besides the ‘Authentication’ mode Tambur.io supports a ‘Direct Messaging’ mode that allows the subscribers of a stream to communicate directly among each other, as well as a ‘Presence’ mode that automatically publishes presence status of all the stream subscribers.

Authentication Mode (JavaScript)
stream.enable_auth("AuthToken");
stream.onauth = function(msg) {
    // handle authenticated message
};
Direct Messaging Mode (JavaScript)
stream.enable_direct("MyUserName", "DirectToken");
stream.ondirect = function(msg) {
    var sender = msg[0];
    var content = msg[1];
    /* reply back */
    stream.direct_msg(sender, "thanks for the message!");
};
Presence Mode (JavaScript)
stream.enable_presence("MyUserName", "PresenceToken");
stream.onpresence = function(notification) {
    var user = notification[0];
    var status = notification[1];
    if (status === "up") {
        // subscriber has joined the stream 
    } else {
        // subscriber has left the stream  
    }
};

WebSync on-demand (by FrozenMountain)

  • Comet
  • Real-Time Client Push
  • Real-Time messaging
  • Real-Time data

OpenPushNo activity since 2011

spire.ioDown. Status unknown

Build serverless applications with our secure, scalable web APIs for web and mobile development.

x-stream.ly – Service defunct

  • JavaScript
  • REST API
  • Presence
  • Real-Time Client Push

Kwwika – Service defunct

  • JavaScript
  • .NET
  • REST API
  • Real-Time Client Push
  • HTTP Streaming
  • Comet

Data Synchronisation, Persistence, Full Stack

Firebase

A scalable real-time backend for your web app. Build apps really fast without the hassle of managing servers

  • iOS
  • Java / Android
  • JavaScript
  • WebSockets
  • BaaS (Backend as a Service)
JavaScript (client)
var dataRef = new Firebase( 'https://my-app.firebaseio.com/' );

dataRef.push( { name: '@leggetter', text: 'Yo from FOWA!' } );

dataRef.on( 'child_added', function(snapshot) {
  // Add the data
} );

dataRef.on( 'child_changed', function(snapshot) {
  // Update the data
} );

dataRef.on( 'child_removed', function(snapshot) {
  // Remove the data
} );

Google Drive Realtime API

Add Realtime collaboration to your app Give your users the power of Google Docs–style collaboration. All JavaScript. No server. No sweat.

Meteor

Meteor is a set of new technologies for building top-quality web apps in a fraction of the time, whether you’re an expert developer or just getting started.

  • Node.js
  • fullstack
  • HTTP Streaming
  • HTTP Long-polling
  • WebSockets

Not to be confused with the original Meteor Comet server

Realtime.co Cloud Storage

The Realtime.co Cloud Storage is a highly-scalable backend-as-a-service based on Amazon DynamoDB. Built-in real-time notifications keep data synchronized between users (web and mobile).

  • BaaS (Backend-as-a-Service)
  • Real-time data sync
  • JavaScript
  • iOS
  • Android (Java)
  • Node.js
  • NoSQL
  • DynamoDB
  • HTTP Streaming
  • HTTP Long-polling
  • WebSockets
  • Mobile Push Notifications for iOS and Android (APNS and GCM)
JavaScript (client)
var credentials = {
    applicationKey: "[YOUR_APPLICATION_KEY]",
    authenticationToken: "[USER_TOKEN]"
}

var storageRef = Realtime.Storage.create(credentials);
var tableRef = storageRef.table("chat-messages");

var chat-msg = {
    chatid : "My chat room",
    timestamp : +new Date(),
    text : "Hello World",
    nickname : "Beavis"
};

tableRef.push(chat-msg, function() {
    // item successfully committed to database    
});

tableRef.on("put", function(item) {
    // item was added to the database table
});

tableRef.on("update", function(item) {
    // item was updated at the database table
});

tableRef.on("delete", function(item) {
    // item was removed from the database table
});

simperium

Simperium is a service for developers to move data everywhere it’s needed, instantly and automatically.

Messaging: with focus on delivery to servers

Superfeedr

  • RSS
  • PubSubHubbub

DataSift

  • Social Media data
  • RSS
  • HTTP Streaming

Other

Echo

Self Hosted Realtime Services

Prosody

Prosody is a modern flexible communications server for Jabber/XMPP written in Lua. It aims to be easy to set up and configure, and light on resources. For developers it aims to be easy to extend and give a flexible system on which to rapidly develop added functionality, or prototype new protocols.

  • Jabber
  • XMPP
  • Lua
  • BOSH

Centrifuge

Simple platform for real-time message broadcasting in web applications.

  • WebSockets
  • SockJS
  • HTTP-fallback
  • Presence
  • Event/Message history
  • JavaScript
  • PubSub

Spike-Engine

Spike-Engine allows quick and painless creation of real-time web services in .NET. Spike-Engine focuses on latency, bandwith and perfomance and has been designed and proven to be robust and reliable. The technology has been tested in production environment with thousands of simultaneous connections and used to build reliable game and application servers.

  • RPC
  • Automatic Client Stub Generation
  • WebSockets
  • Fallback Support
  • Cross-Domain Support
  • Comet
  • Long-Polling
  • PubSub
  • HTTP
  • .NET
  • Flash
  • FlashSockets
  • SPML / SECP
  • HTTP Tunneling
  • Security
  • Cross-Platform
  • Monitoring

SignalR

  • WebSockets
  • Long-polling
  • ASP.NET
  • IIS
  • PubSub
  • RMI

Mojolicious

A modern Perl web framework built from the ground-up as a nonblocking web server, including built-in support for web sockets.

  • Full nonblocking web server
  • WebSockets
  • Perl

Alchemy Websockets

An extremely efficient C# WebSocket server for .NET projects.

  • WebSockets
  • .NET
  • C#

SockJS

SockJS is a browser JavaScript library that provides a WebSocket-like object. SockJS gives you a coherent, cross-browser, Javascript API which creates a low latency, full duplex, cross-domain communication channel between the browser and the web server.

  • WebSockets
  • Fallback-support
  • HTTP Streaming
  • HTTP Polling
  • JSONP Polling
  • Cross Domain support
  • EventSource

socket.io

Socket.IO aims to make realtime apps possible in every browser and mobile device, blurring the differences between the different transport mechanisms. It’s care-free realtime 100% in JavaScript.

  • WebSockets
  • Fallback-support
  • Flash Socket
  • HTTP Long-Polling
  • node.js
  • Cross Domain Support

Firehose.io

Firehose is a minimally invasive way of building realtime web apps without complex protocols or rewriting your app from scratch. Its a dirt simple pub/sub server that keeps client-side Javascript models in synch with the server code via WebSockets or HTTP long polling.

  • WebSockets
  • HTTP Long-Polling
  • Ruby

Thunder Push

Thunderpush is a Tornado and SockJS based push service. It provides a Beaconpush (beaconpush.com) inspired HTTP API and client.

  • SockJS
  • Python

Cramp

  • WebSockets
  • Server Sent Events
  • EventSource
  • Ruby

phpDaemon

Asynchronous server-side framework for Web and network applications implemented in PHP using libevent. phpDaemon can handle thousands of simultaneous connections

  • PHP

http://nugget.codeplex.com/

A web socket server implemented in c#.

The goal of the projects is to create an easy way to start using HTML5 web sockets in .NET web applications.

  • C#
  • .NET

SuperWebSocket, a .NET WebSocket server

  • WebSockets,
  • .NET

webbit

An event-based WebSocket and HTTP server in Java

  • Java

Fleck

Fleck is a WebSocket server implementation in C#. Fleck requires no inheritance, container, or additional references.

  • WebSockets
  • .NET

Persevere

  • Comet
  • PubSub

Migratory

  • Comet
  • WebSockets

Meteor

  • Comet
  • Perl

Beacon Push

  • WebSockets
  • Comet
  • Fallback-support
  • Real-Time Client Push
  • Real-time messaging
  • Real-Time Data
  • Python
  • Ruby
  • PHP
  • node.js
  • REST API

LightStreamer

  • Comet
  • WebSockets

Jetty

  • WebSockets
  • HTTP Streaming

Ratchet

A PHP 5.3 (PSR-0 compliant) component library for serving/consuming sockets and building socket based applications. Build up your application (like Lego!) through simple interfaces using the decorator and command patterns. Re-use your application without changing any of its code just by wrapping it in a different protocol.

  • PHP
  • WebSockets

BrainSocket

A Laravel package that allows you to get up and running with real-time event-driven PHP apps using WebSockets.

  • Laravel
  • WebSockets
  • PHP

WebSockets and Joomla

  • PHP
  • WebSockets
  • Joomla

Atmosphere

  • Comet
  • WebSockets
  • Scala
  • Groovy
  • Java

erlycomet

  • Comet

cometD

  • Comet

Pokein

  • Comet
  • ASP.NET
  • Mono

APE Project

  • WebSockets
  • Comet

StreamHub

Caplin System’s Liberator

  • Comet
  • WebSockets
  • Fallback-support
  • PubSub

ICEfaces

Kaazing

  • WebSockets
  • Fallback-support

FAYE

  • Real-Time messaging
  • Bayeux
  • node.js
  • Ruby

XSockets

  • WebSockets
  • .NET
  • Fallback-support

Tornado

Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed. By using non-blocking network I/O, Tornado can scale to tens of thousands of open connections, making it ideal for long polling, WebSockets, and other applications that require a long-lived connection to each user.

Represents a core building block of many other realtime web servers.

misultin

  • WebSockets
  • Erlang

Cowboy

  • WebSockets
  • Erlang

YAWS (Yet Another Web Server)

  • WebSockets
  • HTTP Long-Polling
  • HTTP Streaming
  • Erlang

juggernaut deprecated

  • WebSockets
  • Comet
  • Fallback-support
  • node.js

PHP WebSocket

  • PHP
  • WebSockets

apache-websocket

WebSocket module for Apache

  • PHP
  • WebSockets
  • Apache

jwebsocket

  • Java
  • WebSockets

Goliath

  • Ruby
  • Asynchronous
  • non-blocking
  • HTTP Streaming

ws4py

  • Python
  • WebSockets
  • Server
  • Client

SocketTornad.IO

Implementation of the Socket.IO Websocket emulation protocol in Python on top of the non-blocking Tornado Web Framework.

  • Python
  • WebSockets
  • Server
  • Client

erlang_websocket

  • Erlang
  • WebSockets
  • Server

Slanger

Slanger is an open source server implementation of the Pusher protocol written in Ruby.

  • Ruby
  • WebSockets
  • Server

em-websocket

EventMachine based, async, Ruby WebSocket server.

  • Ruby
  • WebSockets
  • Server

Java-WebSocket

This repository contains a barebones WebSocket server and client implementation written in 100% Java. The underlying classes are implemented using the Java ServerSocketChannel and SocketChannel classes, which allows for a non-blocking event-driven model (similar to the WebSocket API for web browsers).

  • Java
  • WebSockets
  • Server
  • Client

Autobahn WebSocket

Autobahn provides Open-Source client and server implementations of WebSocket and WAMP.

  • WebSockets
  • Java
  • Android

libwebsockets

C Websockets Server Library

  • C
  • WebSockets
  • Server

ArduinoWebsocketServer

This library implements a Websocket server running on an Arduino

  • WebSockets
  • Server
  • Arduino

nowjs

  • node.js

Doesn’t appear to be actively maintained any more and the website is down.

WebSocket Client Libraries

JavaScript – Flash Socket Fallback

ActionScript

.NET

Silverlight

Silverlight WebSocket client – prototype

Java

C++

Ruby

Python

Objective-C

  • Pingback: Twitter Weekly Updates for 2011-07-03 | Phil Leggetter - Real-Time Web Software and Technology Evangelist

  • Pingback: Chimo @ Chromic » TODOs

  • Pingback: A year as a Developer Evangelist - Phil Leggetter - Real-Time Web Software and Developer Evangelist

  • sankalp singha

    Thank you for this awesome list!! This is one of the most comprehensive list in this category!! I am still trying to figure out which would be the best solution. After going through all of them what I fail to understand that why is there such a less support for PHP when half of the net is coded in it. Maybe because of it’s memory leaks??

    • http://www.leggetter.co.uk/ Phil Leggetter

      PHP generally runs on Apache which wasn’t built to handle persistent connections. It was built with the request/response paradigm (http://en.wikipedia.org/wiki/Request-response ) in mind and allocates resources to each request accordingly. If you build a realtime solution on Apache and end up maintaining lots of open connections resources are used up very quickly.

      That’s why you’ll see that the PHP solutions, such at Ratchet (http://socketo.me) run as a standalone process.

      If I were to build an application using PHP and I wanted realtime functionality then I would probably outsource the realtime functionality to a hosted service. If that wasn’t an option then I would run another self-hosted solution in parallel and communicate between the component using message queues.

      • sankalp singha

        Thank you so much Phil for the really quick reply in the matter. Much obliged!! I did indeed look into Ratchet and also had a look into Slanger. Currently even trying node.js + socket.io + redis for realtime notifications. Just wanted to know if you think that this method is a good idea?

        P.S – So if Slanger is using the same Pusher libraries, can I be using more than 100 concurrent connections in the sandbox plan with Slanger? Sorry, just a lame doubt :P

        • http://www.leggetter.co.uk/ Phil Leggetter

          node.js + socket.io seems to be the way everybody gets started. Whilst there’s value in having a “go to” solution for some things, I think we’d all benefit if there were solid realtime web technologies for all languages. And, it’s getting there.

          One way of achieving this would be to choose a realtime web technology based on your language preference. So, if you’re a PHP developer then take a look at Ratchet, use it, contribute, tell others about it, and hopefully it’ll become an even better solution – http fallback support, pubsub abstractions and more.

          > So if Slanger is using the same Pusher libraries, can I be using more than 100 concurrent connections in the sandbox plan with Slanger?

          If you are using Slanger then it’s hosted on your own infrastructure. So, there’s no limit on how many connections you can have other than the limits imposed by your realtime web infrastructure.

          Hope this helps.

  • David Mertens

    Under Self Hosted Realtime Services you might consider including Mojolicious. Mojolicious is a Perl web framework and server built non-blocking from the ground up, with built-in support for web sockets. Otherwise this is a great list! Thanks!

  • MetaClass

    The list has grown during last year:-). But i can’t find Iron MQ (hosted service). And maybe queues.io is worth mentioning?

  • http://bachwehbi.net bachwehbi

    Many thanks for this comprehensive overview over the different
    technologies/providers

    In the hosted realtime services there is
    Beebotte (beebotte.com)

    It is a cloud platform for Internet of Things and
    realtime connected applications. It provides REST, websockets and XMPP
    connectivity, an API for data storage and history (statistics), and a number
    of Web widgets for data visualization.

    Thanks!

Realtime Web Apps: With HTML5 WebSocket, PHP, and jQuery

Buy the book I co-write with Jason Lengstorf via Amazon.com or Amazon.co.uk

BladeRunnerJS - Divide & Conquer your Web Apps
BladeRunnerJS: Divide & Conquer your Web Apps

BladeRunnerJS is a development toolkit and lightweight framework for building web applications consisting of one or more components called Blades. It comes complete with some seriously useful tools which make it easy to develop, test and deploy your app.

Find out more