minimal code snippet syntax highlighting exampl

Performant AR apps are powered by Reality Models.

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

Sign upm

AR Objects That Don't Drift

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

Want to get rid of drift?

Have your application stream RGB-D data to RaaS using our SSP Unity integration, then use the RaaS API to subscribe to a motion_event (a real-time update to the device's 6DoF position). RaaS will return an optimized motion_event to the subscriber which can be used in application code to correct for drift. The result is AR objects rendering exactly where they should be.

sign up

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.

Want to enable relocalization between multiple iPhones at super speeds?

Have your application stream RGB-D data to RaaS using our SSP Unity integration, then use the RaaS API to request motion reality events as a live subscription. Live subscriptions return a localized motion_event to the subscriber which can be used in application code to localize the players.

This enables relocalization between devices as quick as <2 seconds.

sign up

Build Superior AR Apps.

Stream sensor data to RaaS and it will return a Reality Model via object, motion, and structure reality "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 and/or depth frames), and transmits it to a remote server where it's decoded and then subsequently processed with RaaS. Have your AR application stream the client device's RGB-D data to RaaS using our SSP Unity integration.

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");
        } 
    }
}

Use the RaaS API to request a "Structure snapshot," which is a mesh of the scanned physical environment at a given point in time. You can specify the data archetype (point clouds or meshes), texture (color properties or none), groupID (only send structures from defined group), and the point in time, and you can even add more data over multiple sessions by streaming to the same environmentID.

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();
    }
} 

Use the RaaS API to request object reality events either through live subscriptions (ex: live detection of people in space) or historical events (a dump of all the detected people within a given time frame). First, define the object 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);
    }
}

Use the RaaS API to request motion reality events either through live subscriptions or historical events. Live subscriptions emit a stream of messages with real-time 6DoF positions of the requested sensor_ids. HistoricalMotion is a dump of all motion reality messages from a given time period. Use your client_id to subscribe to a motion_event from the generated environment_id using our RaaS Unity integration.

$0.79 Per 10,000 Frames Processed.

You, the developer, decide how often client devices stream their data to RaaS API. Let's put the $0.79 per 10,000 frames into some context:

Do you publish AR games?

Use RaaS API 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 API.*In exchangeRaaS sends back superaccurate 6DoF coordinates.

As the developer, you can set how often the clients stream frames to RaaS for relocalization. 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

Do you build Industrial AR apps?

Use RaaS API 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 map it in 3D. 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 3D 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 + relocalizations). If the user uses the app once a weekday***, that's 400,700 frames/1st 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 the total overall 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.19 total.

3D Map

20k frames / 10k sqft construction site
*
20 maps / month
*
$0.000079 / frame
=
$31.66/month

Relocalizations

7 frames / relocalization
*
5 relocalizations / session
*
20 sessions / MAU
*
$0.000079 / frame
*
100 MAU
=
$5.53/month

=
$37.19 / 100 MAU

*RaaS needs only about 7 frames to relocalize, on average.
**assuming that the average mobile AR session is 5 minutes
***assuming 20 weekdays in a month

Sign up for RaaS API.

Be one of the first to test the Reality as a Service™ (RaaS) API. Sign up below. We'll be in touch soon.

You are interested in...

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 toes 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

We're on standby, ready to answer your questions.

Join our Discord Server, where you can chat with the founders directly.

Join Discord