Identity, ownership and registries

Categories, modules, HUD widgets, keybinds, themes, render subscriptions, component providers and profile providers are top-level registry contributions. Those registries share the contract defined by io.github.sst.remake.api.registration.Registry.

Settings are different: a SettingDefinition is an ordered child of one ModuleDefinition, not an independently registered object. Its id is unique within that module definition, and its live SettingHandle is reached through the module’s ModuleState. Profile templates likewise use the dedicated template methods on ProfileRegistry rather than the registry’s general register method.

JelloId: the stable name

io.github.sst.remake.api.id.JelloId is the canonical identity of every registered object, in the form namespace:path. It is the JelloUI equivalent of a Minecraft ResourceLocation:

• the namespace is the owner. Use your Fabric mod id, for example example.
• the path is the object inside that namespace, for example auto_sprint.

The string form is example:auto_sprint. JelloId is immutable, validated and safe to use as a map key. The character set is intentionally strict: lowercase ASCII letters, digits, underscores, hyphens and dots (plus / inside the path). Namespace and path are each limited to 128 characters.

import io.github.sst.remake.api.id.JelloId;

JelloId a = JelloId.of("example:auto_sprint");   // parsed form
JelloId b = JelloId.of("example", "auto_sprint"); // component form
String p = a.path();                             // "auto_sprint"

Never change an id after shipping. Display names are presentation; ids are what profiles and saved settings persist under. Renaming an id orphans the stored value. Keep ids as constants in one place rather than building them inline.

Owner

An Owner (io.github.sst.remake.api.registration.Owner) is the identity of everything one addon contributes. Create one through JelloApi.owner(modId, displayName) or JelloApi.owner(modId, subNamespace, displayName).

Owner owner = JelloApi.owner("example", "Example Addon");

The namespace of the owner must match the namespace of every id you register under it. JelloUI enforces this: registering a module whose id namespace is other against an owner whose namespace is example throws ApiUsageException.

Owner identity makes coordinated teardown possible. The runtime removes all owners during JelloUI shutdown. There is currently no public single-call dynamic-addon unload API; an addon that performs an earlier teardown must call unregisterAll(owner) on each registry it used (and close any retained RenderSubscription or setting subscription).

The registry contract

Every registry is a Registry<T> with these semantics:

• register(T) - inserts in insertion order. A duplicate JelloId throws ApiUsageException and never replaces an existing registration.
• unregister(JelloId) - removes one registration regardless of owner.
• unregisterAll(Owner) - removes that owner’s entries from that registry and returns them in registration order.
• get(JelloId) - lookup, empty when absent.
• all() - unmodifiable, insertion-ordered snapshot of everything.
• allOwnedBy(Owner) - unmodifiable, insertion-ordered snapshot of one owner.
• isEmpty() and size() - trivial queries.

Registry iteration follows insertion order. Render-listener priority and category order add their own ordering rules; category ties keep insertion order. Register categories before modules that refer to them. An unknown module category currently falls back to the built-in Misc category and logs a warning rather than failing registration.

The default SimpleRegistry implementation is thread-safe for render-thread reads during initialisation-time writes, but the contract is that registration happens in deterministic single-threaded setup phases.

Registering your first objects

A category and a module, under one owner:

Owner owner = JelloApi.owner("example", "Example Addon");

CategoryDefinition utility = CategoryDefinition.builder(owner,
        JelloId.of("example", "utility"))
        .displayName("Utility")
        .order(100)
        .build();
api.categories().register(utility);

ModuleDefinition sample = ModuleDefinition.builder(owner,
        JelloId.of("example", "sample"))
        .displayName("Sample")
        .category(utility)
        .build();
api.modules().register(sample);

The category and module now appear in the Jello ClickGUI automatically. The current category bridge uses the category’s displayName and order. description, icon, accentColor and showWhenEmpty remain available as definition metadata but are not consumed by the current ClickGUI.