First and foremost, Ambient was built from the ground up to enable networked experiences like the cube example above. The server state is automatically synchronized to clients, and the data model is the same on the server and client. This means that in the future you can move your code between backend and frontend, or even run it on both seamlessly.
Ambient's interface is built on top of WebAssembly, which will enable you to write code in any language which compiles to WASM. At present, Rust is our only supported language, but we are actively working on supporting as many languages as possible so that you can choose the right tool for the job. Thanks to our data model, different modules built in different languages can still communicate with each other through both shared data and messages.
Isolation is key to the execution model of Ambient: each module runs isolated from every other module. If some part of your application crashes, the rest of the application can continue running unaffected, increasing its resilience. This also allows for the use of untrusted third-party code - code you don't trust should be able to run in its own isolated module without impacting overall functionality.
Ambient is built with data-oriented design in mind from top to bottom. All data is stored in, and interacted through, an entity component system backed by a centralized entity database on the server. This database is automatically replicated to every client, and each client has the ability to augment and extend entities with local state. The use of an ECS makes it easy to visualize the state of your application and provides excellent performance and scalability.
The use of an ECS provides a common abstraction over the data in your application. This enables an exciting possibility: modules that are unaware of each other can still interoperate as long as they understand how to interpret the shared data in the same way.
To enable this, we have introduced the ability to define custom components (the C in ECS: typed pieces of data attached to an entity) and concepts (bundles of components that describe shared behaviors and features). These can be shared by multiple modules and used to interoperate, even without those modules being directly aware of each other. In addition, modules can broadcast messages (bundles of components) to negotiate more complex behavior.
As an example, a hitpoints: F32 component can be decreased by a damage module, increased by a healing module, and visualized by a UI module. All of these share the same definition, but are otherwise completely independent and do not know about each other.
Ambient is a single executable that you can download for Windows x64, Linux x64 or macOS ARM, or you can build it yourself for your platform. This executable can act as a server, or it can join a server as a graphical client. It can even act as both with ambient run!
Asset pipeline & streaming
Assets are automatically compiled and optimized by the customizable Ambient asset pipeline, which supports most common model formats (including FBX and glTF), image formats, audio formats, and more.
The compiled assets are always streamed to clients, so that they can immediately start playing without having to download all of the content first.
Rich standard functionality
Finally, Ambient aims to provide a rich set of standard functionality for game and 3D application development. This includes, but is not limited to, a GPU-driven physically-based-rendering engine, PhysX-powered physics, a React-like UI system, spatial audio with composable filters, platform-independent user input, and more. Some of this functionality (e.g. UI and sound) has not been exposed to the API, but we're working on it.