Performant AR apps are powered by Reality Models.

Reality as a Service™ (RaaS) API enables you to publish incredibly performant AR apps.

AR Objects that don't drift

When AR objects "drift away" on-screen during runtime, it's a terrible user experience. "Drift" happens because the native AR SDK on the device hits a limit on the accuracy of its motion tracking. As runtime increases, the error of device position grows, and AR objects appear to drift on-screen.

RaaS API prevents this from happening. RaaS API sends real-time updates of 6DoF positions back to the client devices. The result is AR objects rendering exactly where they should be.

Relocalization that doesn't take forever

Slow relocalization at the start of an AR multiplayer game is a total buzzkill. Users just give up and quit. Prevent that from happening with RaaS API.

RaaS API enables fast (<2 s) and consistent relocalization between a device and its environment, enabling high-fidelity multi-user AR experiences. RaaS API publishes real-time motionEvents, which send back updated, highly-accurate sensor positions in real-time. With RaaS API client devices can connect and relocalize super duper fast.

save-money

Structure

any updates or changes to static environments get streamed out

hosting

Objects

detections of dynamic objects in a space are published in real-time

app

Motion

sensor position in 6DoF is updated in real-time with <2ms latency

Build superior AR apps.

Stream sensor data to RaaS and it will return a Reality Model by way of object, motion, and structure "events" across 3 time intervals: Live Subscription, Historical Events, and Snapshots. Click below to see how it works:
public class StreamData : MonoBehaviour
{
    public string clientId;
    void Start()
    {
        //create an environment id for this session
        Guid myEnvUuid = Guid.NewGuid();
        string sessionEnvironmentId = myEnvUuid.ToString();
​
        //authenticate with your client id
        RaasAuthenticationObject authentication = new RaasAuthenticationObject(clientId, sessionEnvironmentId);
​
​
        //create a sensor id for this session
        Guid mySensorUuid = Guid.NewGuid();
        string sessionSensorId = mySensorUuid.ToString();
​
        //create a stream of data for SSP plugin to send for an environment id and providing the sensor id streaming the data
        //not defining frame rate streams at 5Hz
        //not defining which data types to send sends all available data types (rgb, d, humans)
        SSPStreamDefinitionObject datastream = new SSPStreamDefinitionObject(sessionSensorId);
​
        //begin streaming of data
        try {
            SSPStream sspStream = new SSPStream(authentication, datastream);
        }
        catch (Exception e) {
            print("error");
        } 
    }
}

SSP encodes and compresses client device sensor output (like color or depth frames), and transmits them to a remote server where they can be decoded and then subsequently processed with RaaS.

public class CreateMeshFromRecentStructureSnapshot : MonoBehaviour
{
    public string clientId;
    public string environmentId;
    void Start()
    {
        //authenticate with your client id
        RaasAuthenticationObject authentication = new RaasAuthenticationObject(clientId, environmentId);
​
        //create a no-texture-mesh structure snapshot request for a known environment id from as close to as recent as possible
        RaasSnapshotDefinition snapshot = new RaasSnapshotDefinition("structure", "mesh", "none", DateTime.UtcNow);
​
        //make a request to RaaS for a snapshot with the provided definition
        try {
            RaasSnapshot raasSnapshot = new RaasSnapshot(authentication, snapshot);
​
            //create a Unity GameObject with a Transform at the origin and mesh provided by the RaaS Structure Snapshot
            GameObject mesh = raasSnapshot.CreateMesh(new Vector3(0,0,0), new Quaternion());
        }
        catch (Exception e) {
            print("error");
        } 
    }
}

Structure snapshots are a data representation of the phyical environment at a given point in time. You can specify which data archetypes (point clouds or meshes), texture (color properties or none), groupID (only send structures from defined group), and time (structure requests on or before the provided time) you want returned.

public class LiveHumanFeed : MonoBehaviour
{
    public string clientId;
    public string environmentId;
    private RaasLiveSubscription raasLiveSubscription;
    void Start()
    {
        //authenticate with your client id
        RaasAuthenticationObject authentication = new RaasAuthenticationObject(clientId, environmentId);
​
        //create a subscription to live events for a known environment id
        RaasLiveObjectSubscriptionDefinition subscription = new RaasLiveObjectSubscriptionDefinition("object", "human", "raw");
​
        //subscribe to  RaaS to get live messages for the given subscription definition
        try {
            RaasLiveSubscription raasLiveSubscription = new RaasLiveSubscription(authentication, subscription);
        }
        catch (Exception e) {
            print("error");
        } 
    }
​
    void Update()
    {
        //RaaS plugin will automatically update Human Prefab GameObjects based on received RaaS messages
        raasLiveSubscription.UpdateObjects();
    }
} 

Request object reality events either through live subscriptions or historical events. First, define the archetype (i.e. human) and request that RaaS sends back identified human objects (HumanStruct) in real-time, or within a designated date/time period.

public class DriftCorrection : MonoBehaviour
{
    public string clientId;
    private string mySensorUuid;
    private RaasLiveSubscription raasLiveSubscription;
    void Start()
    {
        //create an environment id for this session
        Guid myEnvUuid = Guid.NewGuid();
        string sessionEnvironmentId = myEnvUuid.ToString();
​
        //authenticate with your client id
        RaasAuthenticationObject authentication = new RaasAuthenticationObject(clientId, sessionEnvironmentId);
​
​
        //create a sensor id for this session
        Guid mySensorUuid = Guid.NewGuid();
        string sessionSensorId = mySensorUuid.ToString(); 
​
        //create a stream of data for SSP plugin to send defining the id of the sensor
        //not defining which data types to send sends all available data types (rgb, d, humans)
        SSPStreamDefinitionObject datastream = new SSPStreamDefinitionObject(sessionSensorId);
​
        //begin streaming of data
        try {
            SSPStream sspStream = new SSPStream(authentication, datastream);
        }
        catch (Exception e) {
            print("error");
        } 
​
        //create a subscription to live events for the sensor id in the session environment id
        RaasLiveSubscriptionDefinition subscription = new RaasLiveSubscriptionDefinition("motion", "optimized", sessionSensorId);
​
        //subscribe to  RaaS to get live messages for the given subscription definition
        try {
            RaasLiveSubscription raasLiveSubscription = new RaasLiveSubscription(authentication, subscription);
        }
        catch (Exception e) {
            print("error");
        } 
    }
​
    void Update()
    {
        //RaaS plugin can automatically update Unity's ARPose Driver origin on each update loop
        raasLiveSubscription.UpdateMotion(mySensorUuid);
    }
}

Request motion reality events either through live subscriptions or historical events. Live subscriptions emit a stream of messages with real-time Reality data. HistoricalMotion is a dump of all motion reality messages from the given time period.

$0.79 per 10,000 frames processed.

You, the developer, decide how often client devices stream their data to RaaS.

Let's put the $0.79 per 10,000 frames into some context:

Do you publish AR games or experiences?


Use RaaS if you need device relocalization to be highly accurate and consistent.

Here's how you should think about our $/frame pricing:

Let's imagine you publish a multiplayer AR game that requires devices to relocalize to their environments for accurate rendering of AR game objects.

In order to relocalize to the environment, the devices stream their sensor data (frames) to RaaS.* In exchange, RaaS sends back super accurate 6DoF coordinates.

As the developer, you can set how often the clients stream frames to RaaS for processing. Let's take the median scenario and say that client devices relocalize once a minute during a mobile game session.**

With 5 relocalizations per mobile game session per  device, RaaS processes 35 frames per mobile game session per device. If each of your monthly active users (MAU) engage in 10 mobile game sessions a month, this amounts to 350 frames/MAU and you'd end up paying $0.028/MAU. If you have 100,000 MAU, that's $2,765/month total.

  • 7 frames / relocalization
  • *
  • 5 relocalizations / session
  • *
  • 10 mobile game sessions / MAU
  • *
  • $0.000079 / frame
  • *
  • 100,000 MAU
  • =
  • $2,765 / 100k MAU
Sign up

Do you build Industrial AR apps?


Use RaaS if 3D meshes, drift correction, and relocalization are critical to your app.

Here's how you should think about our $/frame pricing:

Let's say you build an app for supervisors of a construction site to use during their on-site "walk-throughs." Supervisors use the app to see AR CAD models projected onto the built environment, through their devices.

First, one of the devices "scans" the entire construction site in order to 3D map it. To do this, the device streams its sensor data (frames) to RaaS. Approx 20,000 frames are needed to map a 10,000 sqft area. As the developer, you can set how often an area should be "re-mapped"; let's say the area is re-mapped once each workday because there are daily, visible changes to the construction site.

Next, the first app user needs to relocalize their device to this 10,000 sqft area, so that all devices are on the same coordinate plane during the session. Let's take the median scenario and say that devices relocalize once a minute during the session.** This means that RaaS processes 35 frames per device per session, and for the first ever user, RaaS processes 20,035 frames (3D map + user). If the user uses the app once a weekday***, that's 400,700 frames/first MAU. You'd end up paying $31.66 for the first MAU.

With each subsequent MAU, you hit economies of scale. If there are 100 MAU using the app once a weekday, that only adds an additional 70k frames to RaaS's total processing, bringing the total to 470,700 frames/100 MAU. You'd only end up paying an additional $0.06 / MAU. If you have 100 MAU, that's $37.13 total.

  • 3D Map
  • 20k frames / 10k sqft construction site
  • *
  • 20 maps / month
  • *
  • $0.000079 / frame
  • =
  • $31.60/month
  • Relocalizations
  • 7 frames / relocalization
  • *
  • 5 relocalization / session
  • *
  • 20 sessions / MAU
  • *
  • $0.000079 / frame
  • *
  • 100 MAU
  • =
  • $5.53/month
  • =
  • $37.13 / 100 MAU
Sign up
*typically, it takes about 7 frames to relocalize
**assuming that the average mobile game session is 5 minutes.
***assuming 20 weekdays in a month

Sign up for RaaS API.

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Learn how to use
Unity DOTS 
with our sample projects

If you haven't dipped your toe into learning Unity's multithreaded Data-Oriented Technology Stack (DOTS) yet, now is the time. Learning Unity DOTS is crucial for building performant apps that require massive data pipelines.

The RaaS API is a data-intensive pipeline and for that reason, it's built with Unity DOTS.

Fear not, we've built out a Unity DOTS series of tutorials for you.

Get Started