Introduction to Hera
Build interfaces for Embedded Linux with a retained scene graph and a server that owns the final pixels.
Hera lets applications describe what should appear on a display while the server controls how that interface reaches the screen. An application submits nodes, geometry, text runs, and image references, which the server retains as a scene. The server combines that scene with other surfaces, renders the composition with Vulkan, and presents the resulting image through DRM/KMS.
Because every client contributes to the same retained composition, applications built with different technologies can share a display. A Rust application can use Hera Kit, a React Native application can use rn_host, and a WebKit embedding can contribute imported page images through its host. Specialized clients can also communicate through the protocol directly. In each case, the client supplies UI state to the server's rendering and presentation loop.
Rendering Model
The retained scene gives the server a durable description of an application's visual state. When that state changes, the client submits explicit diff operations to update the description. The server can then compose subsequent frames or evaluate an animation from the state it already holds, without asking the client to describe the entire interface again for every refresh.
Applications still perform the work needed to produce their descriptions. Hera Kit measures and lays out views before sending resolved geometry, while React Native uses Fabric and Yoga to prepare layout and mounting transactions. Clients can also shape text into glyph runs. These computations prepare the scene; Hera remains responsible for drawing the composed image and controlling its presentation.
Effects Across Applications
Because the server owns the final composition, an application's boundary does not have to be the boundary of a visual effect. Hera can evaluate an effect in the context of the surrounding scene, where content from several applications and the system shell appears together. This makes it possible to design a display as one coherent interface while keeping each application's state and lifecycle independently owned.
A translucent system panel illustrates the difference. The shell can place the panel above application surfaces and apply a backdrop blur to the content behind it. The renderer samples the earlier layers of the composition, so the blurred background can include a Rust interface, a React Native surface, and imported WebKit content. As those applications update, the server accounts for the changed pixels and the panel's sampling region when planning the next frame. The panel's client does not need to capture the other applications or reproduce their interfaces to create the effect.
The same model supports transitions that act on an application as part of a larger scene. A shell can embed an application's surface in a parent hierarchy, then use transforms, clipping, and group opacity to move, reveal, or fade its contents together. With animation evaluated by the server against the display clock, that transition can continue from retained state while the application prepares its next update. Several surfaces can participate in a coordinated transition because their animation and presentation share the same frame timeline.
The scope of each effect follows the scene hierarchy and paint order. A backdrop filter reads the content behind its layer, while a group effect applies to the content composed into that group. Imported images participate in these operations as images; their internal DOM or drawing commands remain with the producer. The shell's surface placement policy determines how independently owned applications enter the composition. These boundaries let Hera combine content across processes without requiring applications to share their internal UI models.
Read scene graph and surfaces for how applications enter the hierarchy, damage and effects for how the renderer preserves effect inputs, and animation and scheduling for how the server coordinates changes over time.
Application and Platform Entry Points
Start with getting started to understand the build and deployment environment. Continue with architecture if you are bringing up a display or changing the server.
For applications, read the Hera Kit introduction or the React Native introduction. For web content within native UI, the WebKit guide explains the reusable package and its WPE bridge. The protocol guide is intended for transport authors, toolkit maintainers, and developers crossing the C ABI boundary.
Source Reference
The following files in the Hera checkout define the behavior described on this page.
Cargo.tomlcrates/protocol/src/lib.rscrates/kit/src/lib.rscrates/protocol/src/scene/diff.rscrates/renderer/src/vulkan/scene/planning/damage.rscrates/renderer/src/vulkan/scene/passes/blur.rs