Multiplayer game platform for developers

  • Build faster

    Our libraries and server infrastructure hide the low level logic required to run modern realtime multiplayer games. Focus on your game, we do the rest.

  • Deploy and manage easily

    Never again fear putting new features online. Get up to date information about your software. Stay confident: You are in charge.

  • Scale to millions of users

    Our cloud infrastructure is able to scale with your user requirements. Benefit from every opportunity as your user base grows.

Get started - it's free

Registration takes less than 2 minutes.
  • Multiplayer
  • Chat
  • Realtime action
  • Quizz
  • Turn based
  • Cross platform
  • HTML
  • Facebook
  • Unity
  • Windows
  • Analysis
  • Realtime metrics
  • Aggregated data
  • Custom metrics
  • Detailed logging
  • Customize
  • SDKs and web API
  • Local, scriptable tools
  • Instant deployment
  • Full server customization

Stormancer is currently available as a preview. Our hosting platform has already demonstrated its robustness, but doesn't integrate every feature we want to see in the final product. Try it and tell us what you think!

1: Code your client

                            //Create a Stormancer client for the live platform (you have an emulator too!)
                            var client = $.stormancer(Stormancer.Configuration.forAccount("accountId", "app"));
                            //Connect to a scene using custom user infos (server authoritative data is possible)
                            client.getPublicScene(  'scene_name', userInfos, 
                            function (scene) {                                
                                //Subscribe to the 'move' realtime server events with the onMove callback.
                                scene.onMessage('move', onMove);
                                //Connect to the scene
                                //Send player avatar position to the server.
                                scene.send('move', { X: x, Y: y });
                            var client = new Stormancer.Client(ClientConfiguration.ForAccount("accountId", "app"));
                            //prepare a connection to a scene with custom user data. 
                            //It's also possible to provide server authoritative data.
                            var scene = await client.GetPublicScene("scene_name", userData);
                            //Subscribe to the 'move' realtime server events with the OnMove method.
                            //Connect to the scene and start listening to server messages.
                            await scene.Connect();
                            //Send player avatar position to the server.
                            scene.send('move', new PositionUpdate(x,y));

2: Write some server code

                            private Task Move(RequestMessage<PositionUpdate> message)
                                //Retrieve the user data (as specified when calling getScene in the client application)
                                var user = message.Connection.GetUserData<User>();
                                var msg = message.Content;
                                msg.UserId = user.Id;
                                //Broadcast the position update to all connected players.
                                return AssociatedObject.Broadcast("move", msg);

3: Publish on Stormancer.

>stormancer deploy

You are done.

Get more samples on Github

Our technology

Network engine

Stormancer uses a cross platform network engine optimized for performance. It handles all the complexity of establishing connectivity between different devices, whether mobile, web or desktop based.

Currently the default transport for application is websocket based (TCP). TCP is the perfect solution for games like Quizz, turn based games, or even most of more fast-paced gameplays.

[WIP] However, it's not enough for FPS or fast-paced massively multiplayer titles. For these cases, you will need UDP. Currently this network technology is being tested in Stormancer. We will definitely tell you more about it.

Subscribe if you want to be notified by email about the updates.

Distributed cloud based engine

Stormancer is built from the ground up for the cloud. When we started the project, we had several core objectives.

The first was scalability, making sure that developers using the platform would be able to build great scalable multiplayer games. The core hosting infrastructure is a distributed system able to host your games transparently on several servers, according to your configuration. When developing games for Stormancer, you just don't have to care about synchronizing servers or load balancing your game sessions.

The second was customization. Stormancer is not just a service. It's a platform for your code. We like very much the work made on modern cloud web hosting platforms, so we’ve taken our inspiration from them. You can deploy through a command, then rollback securely if something goes wrong. We handle everything to make sure it happens smoothly.

The last was security. All the applications are isolated. Stormancer nodes (hosting apps) are isolated too, and all the network communication between your app and the exterior are filtered by the distributed platform. The web API themselves and the websocket communications are secured through SSL and symmetric key authentication.

Open source & standards

To make sure that Stormancer is as easy to integrate with outside technologies as possible, we make extensive use of standards or common technologies, whenever possible (if we forgot something, don't hesitate to remind us about it). Managing applications and monitoring them can be completely automated through a web API. The authentication process is mostly powered by OAuth (some work is required in this area) and our serialization protocol is the awesome MessagePack. Our communication protocol is proprietary as nothing adequate existed, but the specifications are available on request (and on our website in the near future).

We think that open source is today a core part of a great development experience. We have opensourced many libraries and components on GitHub and intend to add more in the future. All of our turnkey components including chat, virtual shop, turn-based engine will be open source.

C# based, fully non blocking server scripting

Recently someone asked us this very question: Why the hell is Stormancer scripting done in C#? Why not Javascript? We have several answers. The first is a single keyword (two actually) async await.

The asynchronous development capabilites of C# 5 are awesome. We like JavaScript promises very much, but they just can't compete. It's very easy to write fully non blocking and highly scalable code with C#, and the Stormancer platform leverages that fully. And you can, too. The second answer is shorter: why not. ;)

Get started - it's free

Registration takes less than 2 minutes.


Some javascript samples and components using Stormancer. Source code available on Github.

  • Chat
    A simple chat, easy to integrate in any web app.
  • Unity
    An action game based on Angrybots. Built using Unity 3D. See our tutorial to discover how to do it yourself.
  • 3D webgl
    Built using Babylon.js & Game FX. Thanks a lot to the GameFX team for the original sample.


Tools and libraries available free of charge.

  • Free
    Low performance mutualized hosting. Ideal for prototyping and testing.
  • Standard
    Billed per compute hours.
    20€/Month per compute unit.
    More information available soon
  • Custom
    Customized solution with dedicated servers
    Contact us and we will work a custom solution for you!


  • June 2014 update

    Hello ! this month we released a bunch of updates for Stormancer. Today’s announcements include:

    • Client libraries update: Mainly for javascript, including new status capabilities and robustness improvements.
    • Unity support: Compatibility with the webplayer, usability in the Unity game engine (stay tuned for a dedicated article)
    • Server logs: New web apis to access the server logs of your applications. Available in realtime, in the management portal too.
    • Deployment management: Rollback deployments if required in the management portal (or through the web apis)


    Client libraries update

    These updates mainly aim to raffine the existing functionnality and robustness of the libraries.

    First, Javascript

    We added a timeout config parameter to control how long the client should wait when attempting to connect to the Stormancer platform. The first time an user connects to your application, the initialization process on our side can take a few seconds, depending on the size of your deployment. The default timeout value is fine for most applications, but some of our users had issues with deployments bigger than 200MB. It’s obviously somewhat rare, but for these case, you can now configure the timeout. Please note that this is a temporary workaround as we are working on an architecture update which will completely eradicate this issue.

    The Stormancer exceptions are now ouputed to the console.

    As a side note, I took 10 mn to build a fiddle out of our Chat Sample which demonstrates the features. I will probably build most of my new javascript demos this way.


    We added a new property on the javascript client object. It enables application to check the state of the connection (client.state.state) and to be notified whenever it changes (client.state.stateChanged event)

    This feature is demonstrated on the fiddle on line 36.

    this.client.state.stateChanged(function () {
                if (_this.client.state.state == Stormancer.ConnectionState.connected) {
                    _this.textBox.attr("disabled", "disabled");


    The .NET library currently only features bug corrections, and improved compatibility with Unity.

    Unity support

    We announce support for webplayer Unity3D games, with exactly the same code as for desktop games. To demonstrate this feature, we build a multiplayer version of the Angrybot sample . Thanks to the Unity3D team to provide so great samples to the community!

    We will soon add a blog article featuring the Unity plugin in great details. For now, you can download it from here.


    Server logs

    We released a first version for our realtime server logs feature, it enables you to better understand the behavior of your stormancer applications online. You will be able to get exceptions, debug and trace messages.

    We use a few different technologies as backend for our logging system. On the server itself, logs are handled thanks to the great NLog library. You can therefore plug your own logs into the pipe rather easily.

    First get a NLog logger (you will need the NLog Nuget).

    private readonly Logger _logger = NLog.LogManager.GetCurrentClassLogger();


    Then use the logger as required by your logic. All logs will be stored in our database.

    You will be able to access them through the api and on the management application. This page is rather plain, but we intend to make it better.

    To use the API, you will need an account level token. We are going to add some documentation about this subject in a few days. Before that, may you need it, feel free to contact us to get the details.

    The logging system itself uses Redis, logstash and Elasticsearch. I have to say that this stack is great. Thank you guys !

    Deployment management

    Stormancer as supported for a long time some interesting features regarding the application deployment process. Now you have an UI to really use these features.

    You can now rollback running application easily from the management portal. We store the last 9 packages you deployed, and enabled you to switch from one another as your active deployment.

    As always, the management portal only uses public APIs, so you can duplicate this feature in your own scripts.

    If you got to the end of this article, thank you for your attention!

    Feel free to give us your feedbacks and comments, we really want them and will take them into account.

  • Update : Unity & Metrics

    Unity web player support

    Great news! We pinned the different issues that were preventing Stormancer to run correctly on Unity 3D. Our last version worked pretty well on the desktop export, but the webplayer was a no go. I won’t go to much into details here, but it involved:

    - Getting the Stormancer client lib to compile with the webplayer export. We got a few issues with the way the Unity compiler handle unsupported types and type inference itself.

    - Getting the client lib to work at runtime. There are quite a lot of unsupported .NET capabilities on the webplayer sandbox, and we needed to address all of them.

    <rant>Fortunately, the Unity documentation contains a compatibility list.  Unfortunately this list is not up to date and there are quite a few things in there that are expected to work, but in fact don’t. </rant>

    At the end, all is well that ends well! Disclaimer: It’s more fun with more than one player.

    Thanks a lot to the guy behind Unity web, which provides better support for HTTP requests than the www class. The required socket policy is a minor (and unavoidable) inconvenience.

    Download the plugin here

    We will soon release the Unity Stormancer client on GitHub. We need a little time to clean this coding battlefield before, however.

    What about Android & iOS?

    The mobile version of the Unity Stormancer library may work on Android. It won’t work on iOS because emit is not supported on this platform. This is something we will definitely solve in the future. Either case, we make use of sockets, therefore Unity pro is a requirement too.


    We are currently working on adding application metrics to Stormancer. It's something that has been postponed a few times in favor of bug corrections, customer requests and improved Unity 3D support (arg).

    I had initially decided to deliver that on June 1, but apparently it will take a little more time .

    We have put online quite a nice architecture using RabbitMQ to retrieve logs from the applications to the Stormancer node agent, and redis, logstash & ElasticSearch for log retrieval, processing and storage.

    Now we need to expose the output to Stormancer developers through web APIs and a fashionable UX.

    I was wondering if you would like us to expose this system to you to enable the creation of custom metrics in your apps. What do you think about it? What would be your use cases?

  • Stormancer May update released!

    We are glad to announce you the release of Stormancer v0.4, the next step in our preview!

    Open Preview

    Stormancer is entering its open preview phase right now! It means you can go to the management website, create your account and then create your application right away. All Stormancer tools and documentation are available on Stormancer wiki.

    Our documentation is not yet as good as it should. We are however working on it.

    Furthermore please give your feedbacks, we really would love to hear them! In order to do that, you can contact us on:

    - This blog

    - UserVoice (both on our main website and on the management site)

    -  Twitter @stormancer

    or to contact us directly by mail at team[at]stormancer.com

    New management site

    The Stormancer management site has been completely overhauled.

    You can now manage your Stormancer accounts and applications more easily, get the management keys for your applications, or add scenes directly in the web interface. You can even deploy turnkey applications from our new applications gallery. And suggest new ones. We will definitely consider adding the best ideas.

    Application gallery

    We felt that many of you would be happy to get a simple way to get started with Stormancer. The platform now includes an application gallery with ready to use applications. The gallery is accessible when creating an application in the management site.

    Right now, the gallery only contains a simple chat application and a simple starter pack, but we intend to add other turnkey components soon.

    But even better: you can deploy a turnkey app on the website, download it locally, update it to suit your needs, then deploy it again!

    We publish the current apps under the MIT license (and intend to continue doing that), so feel free to change them as required by your own needs.

    In the future we want to open the gallery to outside submissions. What do you think about it?

    Our new unity client library is available as prealpha

    Tadam! Many where waiting for that.. It's finally here! We just created a Unity3D plugin for Stormancer. Sadly we weren't able to publish it on the Asset Store yet, but it's available on our website. Just download it then double click on the package file while running the Unity Editor, and it should add itself automatically (nice).

    Some of our optimized code don't work on Unity Mobile however, which means that the current Unity library is only compatible with desktop targets as of now. We are working on a Mobile version, incoming in the very near future :) .

    This plugin is currently available as a prealpha release. Get your hands on it from its page on our wiki


    This new release add the following features, in addition to several bug fixes and performance enhancements.

    Stormancer platform

    Connection counts on scenes

    The Stormancer API can now tell you how many users are currently connected to your game scenes . The information is available on the Get Scene and Query scenes APIs.

    We don't provide this piece of information for your app yet. We are however working on it :)

    For example, if you send a get request to the following url:


    if you have provided the right authentification token, you will receive json data looking like that as a response.


    Stormancer applications

    Shutdown logic

    You can now provide your own shutdown logic on your scenes. This logic will be called when the scene is deleted from Stormancer. The scene deletion process becomes:

    1. A scene is deleted through the API. At this point Stormancer will refuse any new connection attempts made to the scene.
    2. The scene is notified, and starts the custom shutdown logic. At this point, users are NOT disconnected. The custom logic can disconnect the users, notify them of the situation, perform cleanup logic, whatever... The point being that Stormancer will wait until your shutdown task is completed to continue.
    3. When the custom task is complete, the remaining users are disconnected from the scene and the scene is removed from the node.

    We think that this approach will provide you with just the right amount of customization. As always, we welcome your opinion and feedbacks.

    protected override void OnAttached()
        // [...]
    private async Task OnShutDown(Core.Infrastructure.ShutdownArgument arg)
        if (arg.HasData)
            var data = arg.GetData<MyType>();
            //do your shutdown logic

    Scene creation parameters

    Scenes now accept parameters on creation. The parameters are a custom string passed to Stormancer when calling the create scene API. We expect these parameters to be JSON data, but it's clearly not a requirement. The Starting event on your scene will receive the parameter when the scene starts, for you to handle it on the server. This feature is particularly useful to configure the scene behavior at runtime: (setting IA options or victory conditions, for instance)

    protected override void OnAttached()
    private async Task OnStarting(string parameter)
        //do your starting logic

    javascript client library

    All asynchronous operations now return  JQuery promises

    We improved the javascript library to use JQuery promises whenever possible rather than function callbacks. This way, Stormancer becomes easier to integrate with other asynchronous libraries.

    this.client.getPublicScene('room1', { Id: this.guid(), Name: "jsclient" }).then(function(scene) {
        // do scene Initialization
       return scene.connect();  
        // do things after scene connection

    Bug corrections

    • Automatic reconnections should work as expected now
    • Better error messages
    • When connecting to a scene, the library will perform the (new) necessary handshakes

    .NET client library

    Bug corrections

    • Automatic reconnections should work as expected now
    • Better error messages
    • When connecting to a scene, the library will perform the (new) necessary handshakes

    Stormancer emulator

    The emulator has been updated to simulate all the platform new features.

    Dynamic compilation

    The emulator can now automatically restart your apps when you change C# files.  Dynamic compilation behavior is detailed in the wiki. We are welcoming your feedbacks on this feature.

    Bug corrections

    • The emulator will now restart as expected when receiving the reset emulator command.

    Stormancer command line

    • Authentication using the new Stormancer management site.
    • The register account command functionality has been integrated in the use command. Why did we make 2 commands in the first place ?!? -_-


    The following command

    stormancer use -account=4cadb093-cd87-4242-8e7d-521cd630aca2

    will now prompt a window asking you to log in to Stormancer’s management portal.

    • The new download command allows you to download locally a remote application. It’s especially useful if you want to slightly modify an existing application., then deploy it again! The basic starter pack included in the application gallery will help you get started with your own Stormancer application: inside is a full Stormancer project that does nothing but has already all the architecture in place for you to create great applications.


    Creating a custom application becomes really easy: create an application with the basic starter pack on Stormancer’s management portal, launch the Stormancer command prompt you installed with the Stormancer tools and use the following command to authenticate yourself:

    stormancer use -account=4cadb093-cd87-4242-8e7d-521cd630aca2 -app=myapp

    Conveniently, that command line can be found on the application’s page on the management portal site.

    Then download your application with this simple line:

    stormancer download

    You now have the application locally, and you can modify it with your favorite C# IDE (MonoDevelop or Visual Studio Express for instance). Once you’re done, just deploy your new version back to the server.

    stormancer deploy

    Congratulations, your new application is now online and running.


    All public Web Apis remain compatible with existing consumers.

    Old applications remain fully compatible with the new Stormancer version. Yes that means that if it already works, you don't need to do anything. But you won't benefit from the new features either :'( .

    If you update your Stormancer server application to v0.4, you will also need to update the client libraries. Failing to do so will result in locking issues.

    The old Stormancer command line will not be able to connect to your account anymore due to some changes to the authentication process.

  • Creating a chat: javascript client

    In the last post, we saw how to put online the server logic of a simple chat. Now we will speak about the client.

    Stormancer offers cross platform development and compatibility, with currently javascript and .NET (WinRT, Windows, Mono, Unity) supported (more to come in the future).

    In this article, I will focus on javascript. I will omit the HTML part of the code, it is available on the full working sample and has nothing special anyway. The live demo is here.

    In order to create the server application running on the Stormancer platform, see this post.

    Let’s go, javascript!


    First, reference the required scripts in your HTML page:

    <script src="http://code.jquery.com/jquery-1.9.1.js"></script>
    <script src="http://stormancer.blob.core.windows.net/libs/js/jquery.stormancer-0.3.min.js"></script>


    then create a stormancer client by providing an accountId and application name.

    var client = $.stormancer(Stormancer.Configuration.forAccount("accountId", "appName"));


    The client provides you with all the facilities to connect, send and receive messages from scenes.


    Now get the scene you want to connect to from the API:

    client.getPublicScene("room1", { Id: this.userId, Name: this.username })

    This will get connection informations for a public scene (accessible without authentication), and associate this connection with a session object containing an Id and a Name.

    Using a private scene, it is possible to provide this data from a trusted source (like your own webserver).

    getPublicScene returns a promise completed when Stormancer is ready to accept the connection.

    .then(function (scene) {
      _this.scene = scene;
      scene.onMessage('message', function (msg) {
         var el = document.createElement('p');
         _this.content.append($(el).text(msg.UserName + ' : ' + msg.Text));
       scene.onMessage('user.Add', function (users) {
           for (var i = 0; i < users.length; i++) {
             var user = users[i];
             var el = document.createElement('li');
             _this.users.append($(el).html(user.Name).attr("id", "user-" + user.Id));
      scene.onMessage('user.Remove', function (id) {
          $("#user-" + id).remove();

    Once the API returns the scene object, it’s time to bind your events to it. Use the onMessage method to register callback functions with the scene “routes” and be notified when the scene send data to your client app through these routes.


    You are now ready to connect to the scene and start sending and receiving messages.


    This function returns a promise you can use to perform actions when your app is finally connected to your Stormancer app, like for instance hide a loading screen.



    To send messages to your server scene, use the send method on the scene object:

    scene.send('message', this.textBox.val());

    the first parameter is the server route on which to send the message, the second a javascript object to serialize and send. Here we send a string, but you could use the method with any json object.


    You are now done. In this post, we covered the basics of Stormancer through building a chat in javascript. If you have any questions and remarks, feel free to comment!


We love technology, game development and good cooking (We are French after all). As a team, we are thriving passionately to build the product you really need, not the one we think you should (maybe) need.

Our motto: Make the developer's life easier
  • Jean-Michel
    Our enthousiastic cloud stirrer. However, 42 ideas per minute can sometimes be too much to bear. Thankfully we make him shut up by giving him even more work to do.
    She can do almost anything, and what she can't, she learns fast (Maybe too fast, we fear she could get dangerous). And she makes sure everyone does what they have to. And do it RIGHT NOW.
    Our big teddy bear. He codes a lot, grumbles a little, but he also loves speaking passionately with game developers about their job, learning eagerly about what they need.