After a year of development, the first release of the new open source game engine Ambient is presented. The engine provides a runtime for building multiplayer games and 3D applications that compile to a WebAssembly representation and use the WebGPU API for rendering. The code is written in Rust and distributed under the MIT license.
A key goal in the development of Ambient is to provide tools that simplify the development of multiplayer games and make their creation no more difficult than single-player projects. The engine is initially aimed at creating a universal runtime that supports the development of games and applications in any programming languages ββfor which compilation into WebAssembly intermediate code is possible. However, the first release only supports Rust development so far.
Key features of the new engine:
- Transparent support for networking. The engine combines the functions of a client and a server, provides all the necessary components to create client and server logic, and automatically synchronizes the state of the server on clients. A common data model is used on the client and server side, which makes it easy to transfer code between the backend and frontend.
- Run each module in its own isolated environment to limit the impact of untrusted code. Crashing a module does not cause the entire application to crash.
- Data-oriented architecture. Providing a data model based on a system of components that each WASM can manipulate. Using the ECS (Entity Component System) design pattern. Storing the data of all components in a centralized database on the server, the state of which is automatically replicated to the client, which on its side can expand the data taking into account the local state.
- The ability to create Ambient modules in any programming language that compiles to WebAssembly (only Rust is supported so far).
- Generation of output universal executable files that can run on Windows, macOS and Linux, and function as both a client and a server.
- Ability to define your own components and "concepts" (collections of components). Projects that use the same components and concepts ensure that data is portable and shared, even if the data is not specifically designed for use in specific projects.
- Support for compiling resources in different formats, including .glb and .fbx. The ability to stream resources over the network - the client can get all the necessary resources when connecting to the server (you can start playing without waiting for all the resources to load). FBX and glTF model formats, various sound and image formats are supported.
- An advanced rendering system that uses the GPU to speed up rendering, and supports GPU-side clipping and LODs. Using physically based rendering (PBR) by default, support for animation and cascading shadow maps.
- Support for simulation of physical processes based on the PhysX engine.
- React-like user interface building system.
- Unified input system independent of the current platform.
- Spatial sound system with plug-in filters.
The development is still at the alpha stage. From the functionality not yet implemented, we can note the ability to run on the Web, the client API, the API for managing multithreading, the library for creating the user interface, the API for using your own shaders, sound support, loading and saving ECS ββ(Entity Component System) components, reloading resources on the fly , automatic scaling of servers, an editor for co-creating game maps and game scenes.
Source: opennet.ru