Skip to content

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.