Feature status and next API slices
This page separates working portable features from proposed contracts. A feature is only marked implemented after the same portable source compiles for every supported target and its loader adapters have runtime evidence.
Implemented portable surface
| Area | Available today | Demo coverage |
|---|---|---|
| Items | Basic properties, class-based portable behavior, literal/translated tooltips with Shift/advanced visibility, and bounded typed held-stack data | Void crystal, resonance rod, 3D resonance core, and persistent preview tool |
| Blocks | Basic blocks, paired block items, strength, light, friction, jump factor, sounds | Alloy block, luminous lamp, shaped workbench |
| Creative tabs | Portable title, icon, and entries | One tab containing all demo content |
| Models/resources | Generated flat/handheld/cube models plus shared hand-authored JSON/resources | Three item sprites, block textures, and multi-element workbench/core models |
| Data | Shaped/shapeless recipes, custom workbench recipes, tags, translations, self-drop loot | Five vanilla recipes, one custom recipe, two tags, two locales, three loot tables |
| Commands | Typed arguments, permissions, suggestions, plain and translated replies | Guide, status, reset, kit, and network-pulse commands |
| Configuration | Typed TOML, validation, safe repair, common/client/server scopes | Bounded progression costs, healing, charge, cooldown, and networking values |
| Networking | Typed codecs, negotiation, size limits, directions, main-thread handlers | Server/client pulse and acknowledgement |
| Events | Lifecycle, server/client tick, player join/leave, sided item/block interaction, successful handling and cancellation | Lifecycle, cooldown timing, join guidance, and server-authoritative abilities |
| Player gameplay | Player snapshots, atomic inventory costs, item rewards and overflow, chat/action-bar feedback, healing, experience | Crystal absorption, workbench infusion ritual, core activation, rod ability, and development kit |
| Synchronized screens | Portable state-templated labels/buttons, bounded single/multiline text inputs, server-owned paged/disabled selection lists with native item-stack icons, counts, hover details and mouse-wheel paging, plus an opt-in server-discovered workbench recipe browser | The workbench uses real slots and synchronized selectable recipe outputs; the persistent preview also has a secure letter editor and rich searchable general-purpose list |
| Authored inventories (experimental) | Arbitrary persistent storage/input/output slot coordinates, item filters, per-slot count limits, player inventory/hotbar binding, explicit server-side quick-move routes, opt-in synchronized integer fields, and client-authored portable background/foreground rendering with full input lifecycle | The persistent preview cabinet builds the same menu and portable custom presentation on all nine targets while native code retains slot synchronization |
| General client screens (experimental) | Portable lifecycle/input; fills, text, wrapping, sprites, tiling, nine-slicing, clipping and transforms; item/entity previews; reusable focus targets with pointer hit-testing and Tab traversal; local typed client commands; isolated resource-reload listeners and requested hot reloads through generated immediate/extraction renderers | The contract client registers the same portable screen and /enderfall_client reload command on every target; its smoke lane requires an initial plus requested resource reload; full visual acceptance remains open |
| Reusable library mods | Isolated Java 17 src/api artifact, API-in-runtime packaging, coordinated target Maven publications, generated required/optional metadata, workspace/Maven-local/configured-repository tasks |
Gradle TestKit publishes a two-loader fixture and verifies API isolation plus target coordinates |
The showcase is in examples/demo-mod. All of its Java under src/main and src/client
is portable and contains no Minecraft, Fabric, Forge, or NeoForge imports.
Known inventory limitation: player item counts, costs, and rewards currently accept only
the calling mod's registered items. Vanilla/other-mod item lookup still needs a defined
portable contract and runtime tests; a manually constructed ItemRef is not a workaround.
Experimental workbench slice
The workbench API now registers a portable positional recipe type and a real container menu.
Every target adapter compiles its native recipe serializer/codec, menu type, client screen,
server-side recipe lookup, counted input consumption, shift-click rules, and unused-input return.
The same DemoRecipes, DemoWorkbench, and DemoData source is used for all nine targets.
This slice has dedicated-server recipe-load evidence on 1.20.1 Fabric, 1.21.4 NeoForge, and 26.2 NeoForge, plus a clean client lifecycle/resource reload on 1.20.1 Fabric. Manual slot, shift-click, and crafting passes are still required across the complete client matrix before it is promoted from experimental to stable.
The generated-runtime gameplay harness has additionally passed automated registration, config, listener isolation, player actions, live commands, native slot input, normal/shift crafting, counted consumption, input return, menu-state synchronization, and packet round trips on all nine generated targets using identical portable sources. The legacy Forge-family harness now performs the required status-ping negotiation before login on both loaders; two consecutive Forge runs passed after replacing its earlier Quick Play path. Pixel-level visual acceptance remains separate.
Instant item workbenches can opt into
recipeBrowser(). Every matching data-pack recipe is
discovered and validated on the logical server, sorted by stable recipe ID and exposed
through protected ghost output slots with synchronized selection, paging, required
input counts and server-owned All/Blocks/Items filtering. Selecting a result or category
uses the native menu-button path, so portable mods do not provide packets or client
registration. Timed/fluid machines, text search and consumer-defined categories are not
covered by this browser slice.
Experimental or not yet stable
| Area | Current status | Why it is not presented as working |
|---|---|---|
| Fluids | Experimental tank/storage, transfer, bucket interaction, UI gauge and block-entity rendering slices exist across generated targets | General fluid-family registration, arbitrary containers, third-party loader capabilities and complete live acceptance are not stable yet |
| Custom item/block behaviour | Server-side use/use-on-block callbacks, exact hit position, hand, crouching context, block-state mutation, declared persistent held-stack data, expected-item-checked carried-slot/off-hand reads and updates, and reusable item-editor screen sessions | Stack durability/effects still need broader portable contracts and live acceptance |
| Block entities and persistent state | Opt-in generated development adapters cover saved inventory/tanks, ticking, menus, automation and rendering on all nine targets | They remain excluded from normal release runtimes until the documented persistence, multiplayer and automation acceptance gates pass |
Proposed developer-facing contracts
These sketches are the design target for the next implementation phase. They are not callable APIs yet.
Authored block-owned inventory layouts are now callable through
StorageContainerSpec, including persistent ownership, native
screen construction, player inventory binding and server-side quick-move rules. A future
slice may add non-block session inventories without weakening those ownership guarantees.
General custom processing recipes
RecipeTypeRef<ProcessingRecipe> resonance = context.recipes().register(
"resonance",
ProcessingRecipeType.builder()
.inputCount(2)
.maximumOutputs(2)
.supportsDuration()
.supportsEnergy()
.build());
The first portable recipe type should deliberately target machine-style recipes rather than arbitrary executable serializers. EnderFall can then own deterministic JSON, validation, reload, synchronization, matching, and recipe-view data without exposing Minecraft codec changes to consumers.
Fluid families
FluidFamilyRef liquidEnder = context.fluids().register("liquid_ender",
FluidSpec.builder()
.colour(0xFF6B2BAA)
.viscosity(1_500)
.density(1_200)
.lightLevel(4)
.bucket()
.worldBlock()
.build());
One call should reserve and validate the source fluid, flowing fluid, bucket item, world block, render data, translations, and required tags as an atomic family. Partial registration must fail before loader registries freeze.
Admission rule
Each new surface must ship vertically: public API, runtime-core validation, all nine adapter implementations, data/resource support, unit tests, unchanged portable fixture, dedicated-server/client smoke assertions, documentation, and migration rules. This keeps the convenient one-call API honest and prevents loader-specific differences from leaking back into consumer source.