Renderite: The IPC Layer That Lets Resonite Split Its Brain From Its Renderer
A custom shared-memory protocol, pooled commands, and frame-by-frame handoff make Unity feel less like the engine and more like one possible display target.
- Renderite is less a renderer than a decoupling layer that lets Resonite separate simulation from presentation without freezing its architecture around Unity.
- Its main trick is not raw speed alone, but a disciplined frame protocol that moves state, commands, and ownership across a shared-memory boundary.
- Large assets do not travel as blobs through the queue, because shared buffer descriptors point the renderer at memory already laid out for the job.
- The design buys Resonite optionality: the frontend can change later without forcing the simulation core to be rewritten around a single engine.
The renderer is no longer the center
Renderite matters because it changes where the system’s gravity lives. In a typical engine, the renderer, scene state, and simulation are entangled. In Renderite, those concerns are split into two processes so Resonite can keep its simulation core moving while treating Unity as one possible presentation layer.
That sounds like an implementation detail until you see the architectural payoff. Once simulation and rendering are separate, the project can evolve the brain without dragging the body along with it. That is the real story here, not just lower latency or cleaner IPC.
What Renderite actually is
Renderite is organized around a shared core and a Unity-facing bridge. The shared side owns the engine-agnostic scene model, command types, frame data, and memory transport. The Unity side translates that stream into GameObjects, materials, textures, and display work.
The key idea is that the channel is not just passing messages. It is coordinating two clocks. The renderer gathers inputs and display context, the engine computes the next frame, and the submit path carries back the work needed to draw it.
The frame handshake
The runtime loop is explicit. The renderer emits FrameStartData. The engine consumes it, updates the simulation, and returns FrameSubmitData. That submit packet includes render tasks, camera updates, and other instructions that let the renderer finish the frame without guessing at engine state.
This matters because it defines ownership. The frame start message is about what the renderer knows. The frame submit message is about what the engine decides. Each side stays in its lane, and the protocol keeps them synchronized without collapsing them back into one process.
Why the wire format matters
Renderite’s messaging stack is deliberately opinionated. MessagingManager coordinates bi-directional communication, RendererCommand models the actions that can cross the boundary, and MemoryPacker handles the binary layout by writing directly into spans and unmanaged buffers.
That choice keeps allocations down and makes the protocol predictable. Instead of reaching for a general-purpose serializer and paying for its flexibility, Renderite uses a narrow format tuned for the specific job: high-frequency frame exchange between two live processes.
// Conceptual shape of the protocol
FrameStartData -> engine reads input and timing
RendererCommand -> pooled, typed command object
MemoryPacker -> writes into Span<byte>
FrameSubmitData -> render tasks and camera updates back to renderer
// The point: the wire format is a workflow, not a blob.
| Approach | What it optimizes for | Trade-off |
|---|---|---|
| JSON | Debuggability and interoperability | Too much overhead for a high-frequency frame loop |
| Protobuf | Compact structured serialization | Still more generic than this protocol needs |
| Renderite MemoryPacker | Low-allocation frame exchange | Harder to generalize, but tuned for the exact path it uses |
Moving big data without moving big data
The most elegant trick is the one that avoids the queue entirely. Large resources do not get copied as raw payloads. Instead, the engine sends a SharedMemoryBufferDescriptor with the addressable piece of memory the renderer should use.
That changes the cost model. A message queue is good for control, not for hauling heavy assets every frame. Renderite uses the queue for intent and the shared buffer for bulk data, which is a cleaner division than trying to make one path do both jobs.
Why this feels like C++ engineering in C#
The codebase leans hard into low-allocation .NET primitives. ref struct, Span<T>, explicit memory layouts, pooled entities, and unmanaged memory wrappers all show up here. The result is C# that behaves like systems code, with the control and discipline you would expect from a graphics runtime.
That is the point. Renderite is not trying to be idiomatic business software. It is trying to move frame data efficiently, keep garbage collection noise under control, and make ownership obvious enough that the two processes can trust each other under load.
// The style, not the exact implementation
UnmanagedMemoryManager<T> exposes raw memory as Memory<T>
RendererCommand objects are pooled
The authority flag decides who owns lifecycle setup
KeepAlive verifies both sides are still in lockstep
How Renderite compares
| Category | Examples | Where Renderite sits |
|---|---|---|
| Full engines | Unity, Godot, Unreal | More specialized and narrower, built to serve an existing simulation system |
| Rendering libraries | bgfx, Diligent Engine | Higher level than a thin API wrapper because it carries a scene model and command protocol |
| Serialization-based IPC | JSON, Protobuf transport | More specialized, because it treats frame exchange as a performance-critical contract rather than a generic data pipe |
Renderite occupies a narrow middle ground. It is not a full engine, and it is not just a graphics API wrapper. It is a bridge designed for a system that already has a strong simulation core and wants the renderer to become replaceable over time.
The strategic bet
The long-term implication is bigger than transport efficiency. By separating the brain from the renderer, Resonite creates room to swap frontends later without rewriting the simulation around one vendor’s runtime. Unity becomes a choice, not a cage.
That is a serious architectural bet. It makes the present more complex, but it buys the project a future where rendering can change without forcing the rest of the system to start over.





