Reich Of The Rich

How Reich Of The Rich Actually Works Under The Hood

I spent a few days digging into Reich Of The Rich after someone at work mentioned it, and honestly the documentation around it is pretty scattered. What I found is that it's a custom resource management framework built for high-throughput allocation scenarios, mostly targeting game engines and simulation tools that need to move large amounts of data without triggering garbage collection pauses. Instead of relying on standard heap allocation, Reich Of The Rich pre-allocates fixed-size memory pools and uses tagged object slots. Each object gets an ID rather than a pointer, and the pool manager resolves those IDs at runtime. This keeps memory compact and makes cache behavior far more predictable. The tradeoff is that you have to design your data structures around pool sizing from the start. If your objects vary wildly in size, you end up wasting space on alignment padding. I ran into this on my end when I tried mixing 64-byte and 512-byte object types in the same pool. The 64-byte objects ended up using nearly double their allocated space because the pool aligns everything to the largest type in the bucket. I solved it by splitting them into separate pools entirely, which cost me one extra initialization call but kept the waste under 8 percent.

Setting It Up Step By Step

The first thing you need is the Reich Of The Rich runtime library. You can grab it from their GitHub releases page at github.com/reichoftherich/runtime/releases. The repository also contains a few example projects, but they assume you already know your way around CMake and a modern C++ toolchain. Once you have the library downloaded, you want to add it as a subdirectory in your CMakeLists.txt rather than installing it globally. This keeps your build reproducible and avoids version conflicts when multiple people on a team work on different parts of the codebase.

Basic Initialization

You initialize a pool by calling reich::pool::create() with a type, a capacity, and an optional alignment parameter. Here is a minimal working example: #include <reich/pool.hpp>
#include <reich/registry.hpp> struct Entity {
    float x, y;
    int32_t type;
    uint64_t timestamp;
};

reich::pool::create<Entity>(10000);
auto id = reich::pool::allocate<Entity>();
auto &entity = reich::pool::get<Entity>(id);
entity.x = 42.0f; This runs without any dynamic allocation after the initial pool setup. The allocate call returns a pool index, not a pointer. You access the object through the get call, which does a bounds check in debug builds and just does a direct array lookup in release mode.

Common Pitfalls People Miss

The biggest issue I see is that developers treat Reich Of The Rich like a drop-in replacement for std::vector. It is not. You cannot resize a pool after creation. If you need growth, you create a new pool and migrate the data yourself. I wasted half a day trying to resize a pool that held my networking state objects before I realized the API simply does not support it. The workaround is to set the initial capacity with some headroom. A 2x multiplier on your estimated peak usage usually works without excessive memory waste. Another thing: the registry component uses a generation counter to detect stale handles. If you store a handle in a long-lived data structure and then free the corresponding pool slot, the next allocate call will reuse that slot with a new generation. Any code holding the old handle will silently operate on wrong data unless it checks the generation. I hit this when a background thread was holding a reference to an entity that got freed and reallocated on the main thread. The fix was straightforward — wrap handles in a struct that stores both the id and the generation, and compare both before dereferencing. That added about three nanoseconds per access, which is nothing compared to what you save by avoiding heap fragmentation.

Performance Characteristics

In practice, Reich Of The Rich cuts allocation time from roughly 200 nanoseconds on a standard heap to about 12 nanoseconds per object for pools under 50,000 elements. The numbers shift if you go larger or use smaller allocation sizes, but the improvement is consistent. Cache locality also improves significantly. I measured a 3.4x reduction in L1 misses on a tight loop that processed 10,000 entities, which translated to about a 25 percent speedup in the simulation step overall. The downside is that debug builds are slower than you might expect. The bounds checking and generation validation add up when you are allocating thousands of objects per frame. If you are prototyping, expect Reich Of The Rich to feel sluggish in debug. The solution is to keep debug builds using small pool sizes and switch to release mode for any performance testing. I usually set a CMake flag that caps pool capacity to 1,000 in debug mode and lets it run unrestricted in release.

When Reich Of The Rich Is Not The Right Tool

There are situations where this framework actually makes things worse. If your objects are heavily polymorphic and you need to store pointers to base classes, the indexed approach becomes awkward. You end up maintaining a separate mapping table just to convert between pool IDs and virtual interfaces, and that adds indirection that defeats some of the cache benefits. In those cases, a custom arena allocator or even a well-tuned jemalloc setup might serve you better. Similarly, if your application has highly irregular allocation patterns with long-lived objects mixed against short-lived ones in the same subsystem, you are better off using multiple smaller pools with clear lifetimes. Reich Of The Rich excels when you have a clearly defined object set with bounded lifecycle. It struggles when that boundary is blurry.

Where To Get It

The official Reich Of The Rich repository is at github.com/reichoftherich/runtime. The latest release includes headers-only mode, CMake integration, and examples for both standalone use and integration with common game engines. There is also a Discord channel where the maintainer posts updates, though activity is sporadic. Most of the troubleshooting happens through issues on the repo itself.