Architecture Overview

Welcome to the Entropy platform architecture documentation.

Entropy aims to be a new kind of app development framework for 2D, 3D, and spatial applications in AR and VR.

Instead of a monolithic app, Entropy is a collection of modules that can be used to build apps. It doesn’t try to be a game engine that you have to learn how to use, but rather a framework that provides the tools you need to build your app.

These architecture documents describe various concepts in the Entropy ecosystem - from base primitives to how specific features work behind the scenes.

System Diagrams

The App Stack

The following diagram illustrates the stack for an Entropy Application relative to the OS and Hardware.

block-beta
    columns 2
    APP["Applications"]:2
    SDK["EntropyCanvasSDK"]:2
    XR["OpenXR / ARKit"]
    OS_ABS["OS Behaviors"]

Canvas & Portal Relationship

EntropyPortal acts as the viewer/renderer, while Canvas (running on CanvasEngine) serves as the session host and state manager for your apps. Apps running on the EntropyCanvasSDK push state to the Canvas, which is then replicated to connected Portals. You can almost think of this as something like a window manager (the Canvas) and a compositor (the Portal).

graph TD
    subgraph "Apps"
        App1[App 1]
        App2[App 2]
    end
    
    subgraph "Host"
        Canvas[Canvas Engine]
    end

    subgraph "Viewers"
        Portal1[Portal 1]
        Portal2[Portal 2]
    end

    App1 -->|Updates| Canvas
    App2 -->|Updates| Canvas
    Canvas -->|Replication| Portal1
    Canvas -->|Replication| Portal2

Multi-App/Multi-Portal Topology

A single Canvas can host multiple apps simultaneously, and multiple Portals can connect to the same Canvas to view the shared state.

graph LR
    subgraph "Canvas Environment"
        CanvasCore[Canvas State]
    end

    subgraph "Applications"
        AppA[Physics App]
        AppB[Drawing App]
        AppC[Clock App]
    end

    subgraph "Viewers (Portals)"
        User1["User 1 (VR)"]
        User2["User 2 (Desktop)"]
        User3["User 3 (AR)"]
    end

    AppA <--> CanvasCore
    AppB <--> CanvasCore
    AppC <--> CanvasCore

    CanvasCore --> User1
    CanvasCore --> User2
    CanvasCore --> User3

Module Architectures

The Entropy ecosystem is composed of several key modules, each serving a distinct purpose in the stack.

EntropyCore

Foundation & Concurrency The bedrock of the engine. It provides the WorkService (job scheduler), Virtual File System, and Type System. It abstracts platform specifics and enforces a high-performance, multithreaded execution model.

EntropyNetworking

Communication Layer Handles all data transport between nodes. It implements a layered stack:

1. Session: High-level replication and RPC.
2. Protocol: Cap’n Proto schemas and serialization.
3. Transport: Abstracted IPC, TCP, and WebRTC backends.

EntropyCanvasSDK

Application Framework The SDK used by developers to build apps. it provides high-level abstractions like CanvasClient for session management and SceneSystem for manipulating USD-based 3D content. It hides the complexity of networking and synchronization.

EntropyPortal

renderer & Viewer The visual terminal. It connects to a Canvas, receives the scene state, and renders it using a high-fidelity Clustered Forward pipeline. It features a Frame Graph architecture and supports advanced features like Global Illumination and Reflection Probes.

CanvasEngine

Session Host The runtime that hosts the collaborative session. It manages the authoritative state of the world, arbitrates conflicts, and ensures persistent simulation rules (like physics) are applied. (Documentation coming soon)