After a month under heavy development, Socket.IO 0.7 is finally here!

Socket.IO came out almost a year ago making the first solid steps in the cross-browser realtime space. Ever since then, a constant stream of feedback and support has made this release possible, the biggest yet, with dozens of improvements and bugfixes.

• +1000 Google Groups members
• +1600 GitHub followers
• +50 projects in the ecosystem
• +5 conference talks and meetups
• +5 language implementations

Socket.IO 0.7 addresses a major shortcoming of the WebSocket protocol. When you initialize a `WebSocket` in a browser, that one socket can only stream data for a single protocol or purpose, unless you build in logic to channel messages:

var a = new WebSocket();

a.onmessage = function (msg) {
  var msg = JSON.parse(msg);
  if (msg.type == 'chat') {
    Chat.handle(msg.data);
  } else {
    // do something else
  }
};

This presents a number of problems

1. You need to think about how you encode and interpret messages.
2. It's hard to achieve interoperability with 3rd-party code.
3. Logic for "connecting" or "disconnecting" specific parts of the application are inexistent.
4. Authentication, error-handling for different subsets of functionality introduce even more difficulties.

To fix this, Socket.IO now gives you one `Socket` per namespace you define:

<script>
  var chat = io.connect('/chat');
  chat.on('message', function () {
    // chat socket messages
  });
  chat.on('disconnect', function () {
    // chat disconnect event
  });

  var news = io.connect('/news');
  news.on('item', function () {
    // a new `news` socket event is here
  });
</script>

Each "sub-socket" or "namespace" has the same characteristics of any other Socket, but socket.io does the heavylifting of splitting the messages in a very lightweight and performant way. This technique is specially necessary for non-WebSocket transports, as they're usually associated with more than one connection.

In my previous example I used a custom event. Custom events allow you to simplify your code, and their implementation adds no overhead to the protocol. This means that if you don't use them, not much will change.

// server-side
io.sockets.on('connection', function (socket) {
  // send custom events to browser socket
  socket.emit('hi', { 'i can send': 'json!' });
});

If you pass parameters, those will be automatically encoded and decoded in JSON for you. In addition, you can pass data around:

// client-side
var socket = io.connect();
socket.emit('set nickname', 'john', function (response) [
  console.log(response);
});

// server-side
// …
socket.on('set nickname', function (nick, fn) {
  if (nick == 'rauchg') {
    fn({ err: 'nickname in use' });
  }
});

The regular `.send` method got simple acknowledgements as well. These are sent if you pass a function as the second parameter:

var socket = io.connect();
socket.send('woot', function () {
  // now i know my message arrived!
});

Another introduction to the API was the concept of `flags`. Flags are getters that you prefix to the `.send` and `.emit` calls. One of them is `volatile`, which allows you to send messages at a rate that your client can consume them, dropping messages that cannot be flushed out fast enough.

This is very useful for games, high-volume twitter streams, etc.

io.sockets.on('connection', function (socket) {
  setInterval(function () {
    getTweet(function (tweet) {
      socket.volatile.emit('tweet', tweet);
    });
  }, 100);
});

Sometimes you want to put a bunch of sockets in one room, and send a message to them. You can leverage rooms by calling `join` on a socket, and then with the flags `to` and `in`:

io.sockets.on('connection', function (socket) {
  socket.join('a room');
  socket.broadcast.to('a room').send('im here');
  io.sockets.in('some other room').emit('hi');
});

Socket.IO caught the attention of people inside and outside of the Node.JS world.

As a result, I created the socket.io-spec project to explain the internals of how the project works, and how the client and server talk to each other

Some changes to the protocol include:

• The protocol has been made more lightweight, more consistent and a concept of revisions have been introduced to ensure compatibility between clients and servers.
• A new handshake mechanism that introduces a lightweight negotation of transports and timeouts. In addition, it allows to get more information about a certain client (like the `User-Agent`) that transports like WebSocket don't send.
• Disconnection packets (that allow to forcedfully kick out clients)
• And extended message types to make all the aforementioned features possible.

The Node.JS socket.io server has tripled its number of tests, totaling 160 as I speak. This will help add and maintain high levels of reliability.

More interestingly, the new `socket.io-client` has been designed to run both on the client and the server with the same codebase. I wrote a custom test runner that allows the following to be possible:

When the tests are run from the command line, the transports run on Node.JS. In some cases, almost no code modification is needed. For example, there's a WebSocket client by Peter Griess that simulates the exact same WebSocket API of the browser.

All it took to do this was wrap my client modules like this:

(function (module, io) {
  // my module
})(
    'undefined' == typeof module ? module = {} : module
  , 'undefined' == typeof io ? require('socket.io-client') : io
);

Write once. Run everywhere.

Another major change was the introduction of the concept of message dispatcher adaptors. It's now possible to introduce a custom message queue (like one built with RabbitMQ or Redis) at the socket.io level.

This makes socket.io not dependent on a single process to scale. The introduction of the first of these message adaptors is going to make socket.io more robust, reliable and fault-tolerant.

A blogpost will soon be dedicated entirely to this topic, stay tuned!

Our signature 10-lines-of-socket.io-code chat example app has been streamlined. It now supports nicknames, and looks better:

And now we get another 15-liner (on each side), this time a bot that joins the #node.js IRC channel and shows what's going on:

Special thanks to the following people that made this release possible and awesome with their feedback and contributions:

• Arnout Kazemier (socket.io contributor)
• Vladimir Dronnikov (socket.io contributor)
• TJ Holowaychuk
• Shripad K
• Sascha Gehlich
• Mikeal Rogers

… and many others I'm probably forgeting about.

Many exciting things are still to come. I'm going to make it a priority, now that the major architecture changes are out of the way, to have frequent small releases.

Soon, I'm going to unveil the framework we created at LearnBoost to seamlessly power realtime experiences in web applications created with the Express web framework.

As usual, I welcome everyone to help with bugfixes, documentation and wiki pages on GitHub. Also, don't forget to join our brand-new channel #socket.io on irc.freenode.net.