SpatialOS

Company

Careers

Sites

Close menu

Dream Bigger. Build Faster.

Improbable’s SpatialOS platform gives you the power to seamlessly stitch together multiple servers and game engines like Unreal and Unity to power massive, persistent worlds with more players than ever before.

Enables rapid multiplayer development and deployment with smaller teams.
Allows you to use the game engines and tools you already know and love.
Free to try, and free throughout development if you qualify for our Games Innovation Program.

Get SpatialOS Now Games Innovation Program

Code Beyond Server Boundaries

SpatialOS can create a swarm of hundreds of conventional game engines that overlap together to create a huge, seamless world. Develop unconstrained by the computational and concurrent player limits of a single engine.

Grow a Persistent World

A SpatialOS world can contain millions of persistent entities and manage their state and history. Design gameplay that allows players to affect the world in meaningful, long-lasting ways.

Deploy Fast, Iterate Fast

Use just a few CLI commands to run your world on the SpatialOS Platform, then instantly share with players. SpatialOS handles all infrastructure management and data synchronization for you, greatly increasing the speed at which you can build and grow your online world.

Architecture

What is SpatialOS?

The Current Approach

Online worlds or shards are often constrained to the single server running them.

This limits you in terms of world scale, reliability, and concurrent players. The hassle of managing servers yourself results in a much slower development and iteration process.

How SpatialOS is Different

SpatialOS is a cloud-based computational platform that lets you use many servers and engines to power a single world.

The platform coordinates a swarm of micro-services called workers, which overlap and dynamically reorganize to power a huge, seamless world.

The platform also lets you handle a huge number of concurrent players across different devices in one world.

Abstraction

What makes up your world?

Entities

All things in your world exist as entities. SpatialOS maintains the persistent state of all entities across a cluster of servers. Worlds can contain millions of entities.

Components

Entities consist of components, which define their state and how other entities interact with them. Components are defined in a schema language. Automatically generated integrations then allow different workers to visualize and simulate them.

Workers

Workers are micro-services that simulate the components of entities across the world. SpatialOS runs as many workers across your world as needed to simulate every component in the world. All data synchronization is handled for you.

Code

How do you write it?

Implement flammability with SpatialOS and Unity3D

A code example from the SpatialOS demo introduces a basic concept of flammability to entities in your game world. SpatialOS executes this code across many workers simultaneously, allowing flammability behaviour to run across a huge number of entities and be visualized by many connected clients simultaneously.

SpatialOS schema

                    // The SpatialOS Schema Language lets you define cross-language 
      // components, that can be implemented and visualized across a
      // variety of languages and integrations
      component Flammability {
         id = 1000;
      
         // This property defines the persistent state of this entity potentially being on fire
         bool is_on_fire = 1;
      
         // Commands provide a way of workers interacting with other workers. 
         // These workers could be even written in different langauges!
         command IgniteRequest ignite returns Nothing;
      }
      
      type IgniteRequest {
         // could contain additional parameters
      }
                    
                      Expand

Unity server worker

                    // Would be added to GameObjects that exist on Unity server worker.
      // Potentially hundreds of server workers could be running in the same world.
      class PropagateFlamesBehaviour : MonoBehaviour {
      
          // FlammabilityWriter is code generated for you
          // using our SpatialOS Schema compiler, and injected
          [Require] private Flammability.Writer flammabilityWriter;
      
          void OnEnable() {
              // Set up a handler for when we get an Ignite command
              flammabilityWriter.CommandReceiver.OnIgnite.RegisterResponse(HandleIgnite);
          }
      
          // When the trigger around the flaming GameObject intersects another entity
          void OnTriggerEnter(Collider other) {
              if (flammabilityWriter.Data.isOnFire) {
                  // SpatialOS RPCs will route to whichever worker is simulating this Component.
                  SpatialOS.Commands.SendCommand(flammabilityWriter,
                      Flammability.Commands.Ignite.Descriptor,
                      new IgniteRequest(), 
                      other.gameObject.EntityId());
              }
          }
      
          private Nothing HandleIgnite(Nothing request, ICommandCallerInfo callerinfo) {
              if (!flammabilityWriter.Data.isOnFire) {
                  flammabilityWriter.Send(new Flammable.Update().SetIsOnFire(true));
              }
              return new Nothing();
          }
      
          void OnDisable() {
              flammabilityWriter.CommandReceiver.OnIgnite.DeregisterResponse();
          }
      }
                    
                      Expand

Unity client worker

                    // Would be added to GameObjects that exist on Unity client worker.
      // Arbitrarily many Unity clients would be running this code
      class FlamesVisualizer : MonoBehaviour {
      
          // FlammabilityReader is code generated for you
          // using our SpatialOS Schema compiler, and injected
          [Require] private Flammability.Reader flammabilityReader;
      
          // This will reference a ParticleSystem on the GameObject
          public ParticleSystem particles;
      
          void OnEnable() {
              // Re-visualize when we're set on fire
              flammabilityReader.IsOnFireUpdated.Add(UpdateVisualization);
              UpdateVisualization(flammabilityReader.Data.isOnFire);
          }
      
          void UpdateVisualization(bool isOnFire) {
              // Enable the ParticleSystem as appropriate
              if (isOnFire) {
                  particles.Start();
              } else {
                  particles.Stop();
              }
          }
      }
                    
                      Expand

                      // The SpatialOS Schema Language lets you define cross-language 
      // components, that can be implemented and visualized across a
      // variety of languages and integrations
      component Flammability {
         id = 1000;
      
         // This property defines the persistent state of this entity potentially being on fire
         bool is_on_fire = 1;
      
         // Commands provide a way of workers interacting with other workers. 
         // These workers could be even written in different langauges!
         command IgniteRequest ignite returns Nothing;
      }
      
      type IgniteRequest {
         // could contain additional parameters
      }

                      // Would be added to GameObjects that exist on Unity server worker.
      // Potentially hundreds of server workers could be running in the same world.
      class PropagateFlamesBehaviour : MonoBehaviour {
      
          // FlammabilityWriter is code generated for you
          // using our SpatialOS Schema compiler, and injected
          [Require] private Flammability.Writer flammabilityWriter;
      
          void OnEnable() {
              // Set up a handler for when we get an Ignite command
              flammabilityWriter.CommandReceiver.OnIgnite.RegisterResponse(HandleIgnite);
          }
      
          // When the trigger around the flaming GameObject intersects another entity
          void OnTriggerEnter(Collider other) {
              if (flammabilityWriter.Data.isOnFire) {
                  // SpatialOS RPCs will route to whichever worker is simulating this Component.
                  SpatialOS.Commands.SendCommand(flammabilityWriter,
                      Flammability.Commands.Ignite.Descriptor,
                      new IgniteRequest(), 
                      other.gameObject.EntityId());
              }
          }
      
          private Nothing HandleIgnite(Nothing request, ICommandCallerInfo callerinfo) {
              if (!flammabilityWriter.Data.isOnFire) {
                  flammabilityWriter.Send(new Flammable.Update().SetIsOnFire(true));
              }
              return new Nothing();
          }
      
          void OnDisable() {
              flammabilityWriter.CommandReceiver.OnIgnite.DeregisterResponse();
          }
      }

                      // Would be added to GameObjects that exist on Unity client worker.
      // Arbitrarily many Unity clients would be running this code
      class FlamesVisualizer : MonoBehaviour {
      
          // FlammabilityReader is code generated for you
          // using our SpatialOS Schema compiler, and injected
          [Require] private Flammability.Reader flammabilityReader;
      
          // This will reference a ParticleSystem on the GameObject
          public ParticleSystem particles;
      
          void OnEnable() {
              // Re-visualize when we're set on fire
              flammabilityReader.IsOnFireUpdated.Add(UpdateVisualization);
              UpdateVisualization(flammabilityReader.Data.isOnFire);
          }
      
          void UpdateVisualization(bool isOnFire) {
              // Enable the ParticleSystem as appropriate
              if (isOnFire) {
                  particles.Start();
              } else {
                  particles.Stop();
              }
          }
      }

Try it yourself!

Set your own entities on fire across multiple workers in the SpatialOS Wizards demo!

You’ll need to make an account first.

Games

A few of the many game types SpatialOS revolutionizes

Open World Survival

Build a fully simulated city of unprecedented scale and complexity, with lasting persistence and destruction

MMORPG

Use Unreal, Unity, or your own engine to make a massive, lush world with all of your players in a single unsharded space

Mobile

Rapidly build real-time multiplayer games without requiring your own networking and multiplayer teams & tech

Features

Here’s what you get:

Engine Integration

Build your game logic with Unity, Unreal or a supported language SDK (C#, C++, Java).

Deployment Console

Explore and manage your deployment within a web browser.

Inspector

Explore your world from above and track the movement of players and game objects in a massive space.

Easy Deployment Commands

Deploying your game is as easy as running a few CLI commands.

Log Viewer

Easily explore the logs generated by your game in order to diagnose production issues and identify patterns.

Snapshots

Manage and evolve the state of your worlds over time using a suite of CLI tools and APIs.

Who's making SpatialOS games?

SpatialOS is designed to unlock developers’ creativity, from the smallest indie team to industry titans. Read testimonials from SpatialOS developers about building games on this radical new tech!

And be sure to check our blog and forums for new technical approaches and game-play ideas.

Help each other out, play each other’s games. We’re in it together!

Read the Blog

Read the Forums

Check out the latest SpatialOS featured games:

Vanishing Stars by NINPO

Seed by Klang

Chronicles of Elyria by Soulbound