Modrinth · Fabric

Distant Decorations on your Minecraft server

Distant Decorations runs on Minecraft servers with Fabric. Order your server, set the loader in the panel and install the mod with one click in the mod browser.

Distant Decorations is a high-performance Fabric framework that lets participating mods persist and render decorative block-entity visuals far beyond vanilla chunk distances.

Downloads
2.2K
Author
–
Loader
Fabric
Minecraft
26.2 – 26.3
Updated
–

Screenshots

What Distant Decorations looks like

Images: Distant Decorations on Modrinth, published by the project team.

Setup

Install Distant Decorations on your server

The server and players need the same loader and Minecraft version. Back up the world before adding or updating mods.

  1. 01

    Configure

    4 GB of RAM is preselected. You choose the term and add-ons and pay by credit card or PayPal.

  2. 02

    Set the loader

    In the panel, set the server software to Fabric and choose the matching Minecraft version, for example 26.3.

  3. 03

    Install the mod

    Search the mod browser for “Distant Decorations” and install the release for your loader. Alternatively, upload the .jar to the mods folder via SFTP. Required dependencies are listed on the project page.

  4. 04

    Connect

    Every player installs the same Distant Decorations release locally and connects using the server address from the panel.

On the server
Required
On the client
Required
Loader
Fabric
Minecraft
26.3, 26.2
License
Mozilla Public License 2.0

The panel

Install mods, find errors.

Real screenshots from the Mado panel. Both come with every Minecraft server.

Mod browser

Modrinth and CurseForge, right in the panel.

The browser filters by your Minecraft version. Install mods with one click, without uploading .jar files.

Browser in the Mado panel with search, a CurseForge or Modrinth source switch and install buttons.

AI crash analysis

When a mod crashes, the analyzer reads the log.

Mods often fail on a wrong loader version, Java version or missing dependency. The analyzer names a likely cause and suggests a fix.

Optimization page in the Mado panel with the AI Log Analyzer enabled and a “Server Crashed” notice with an “Analyze Now” button.

Releases

Published releases

Pick the file that matches your server’s loader and Minecraft version. The server and players need the same release.

Distant Decorations · Modrinth
Original description by the project author

Distant Decorations

Minecraft
Fabric API
Java
License

Distant Decorations is a high-performance Fabric framework for Minecraft 26.2 that lets participating mods persist and render decorative block-entity visuals far beyond vanilla chunk distances. Its default client subscription range is 512 chunks (8,192 blocks), with a server-authoritative maximum of 1,024 chunks (16,384 blocks). Integrations such as Fast Paintings and Camerapture provide their own lightweight server metadata providers and distant client renderers.

By decoupling visual representation from ticking block entities and leveraging hierarchical spatial indexing, projected-size culling, and bounded top-K selection, Distant Decorations keeps distant-decoration traversal in the low-millisecond range even with large synchronized datasets—seamlessly coexisting with long-distance terrain renderers like Voxy.


🌟 Key Features

  • Extreme Visibility Range: Extends decoration visibility up to 512 chunks (8,192 blocks) by default, with server support for subscriptions up to 1,024 chunks (16,384 blocks), independent of vanilla chunk render distance.
  • Hierarchical Spatial Indexing:
    • 4×4 Chunk Cells (64×64 blocks): Aggregate bounding box calculation for instantaneous coarse frustum culling.
    • 32×32 Chunk Regions (512×512 blocks): Monotonic revision tracking, dirty-region flushing (every 5s), and idle eviction (60s).
  • Dynamic Level of Detail (LOD) & Far-Visual Scaling:
    • Provider-Aware Projected-Size Culling: Allows renderers to specify custom subpixel culling thresholds via cullBelowProjectedPixelSize() (defaults to global 0.10 px, configurable down to 0.01 px).
    • Far-LOD Footprint Support: Core delivers precise projection metrics and non-culled submissions so provider renderers can scale subpixel distant quads around their center to maintain a rasterizable ~1 px visual footprint (e.g. clamped up to 16x without altering physical world AABBs.
  • Flicker-Free Live Handoff:
    • Dynamic distance threshold (64 x entityDistanceScaling blocks) and a 200 ms chunk-load grace period ensuring seamless transitions between live block entity renderers and Distant Decorations.
    • Real-time mutation capture (MixinBlockEntity) tracking block entity updates (setChanged) and removals in active chunks.
  • OBE Coexistence: Designed to cleanly coexist with OptimisedBlockEntities (OBE) by operating completely independently of ticking block entity lifecycles.
  • Chunky Integration: Safely intercepts asynchronous chunk generation from Chunky and marshals reconciliation back onto the server main thread to atomically commit newly generated block entities to the world index.
  • GPU & Network Throttling:
    • Distance & screen-space prioritized budget limiter (projectedPixelSize * 1000 - distance) using bounded top-K selection (O(N log K)).
    • Bandwidth-throttled (128 KiB/tick) chunked multipart snapshot packet streaming (nearest-first) with atomic client-side assembly.
    • Ingestion-time payload pre-decoding: zero payload deserialization or ByteBuf allocation in the render loop.

🧩 Provider Architecture

Distant Decorations is designed as a modular core framework. Content mods register their own lightweight metadata providers on the server and custom renderers on the client:

Mod Integration Architecture
Really Fast Paintings Registers a painting provider and renderer leveraging vanilla atlas sprites with single-quad FAR LOD and far-LOD visual footprint scaling.

⚙️ Configuration & Diagnostics

Distant Decorations provides runtime diagnostics commands and system property configuration:

Diagnostic Commands
  • Client:
    • /ddc stats: Displays active configuration, synced region/decoration counts, and last-frame breakdown (Visible/Rendered, Far-LOD Scaled, Suppressed (Live), Culled (Distance), Culled (Subpixel), Culled (Frustum), and Culled (Budget)).
    • /ddc toggle: Toggles distant decoration rendering on or off at runtime.
  • Server:
    • /dd stats: Displays indexed decoration counts, loaded dimensions, active client subscriptions, and dirty region tracking.
    • /dd toggle: Master server toggle for decoration synchronization.
Configuration Properties
JVM Property Default Description
distantdecorations.subscription_radius_chunks 512 Client subscription radius in chunks (decoupled from vanilla render distance).
distantdecorations.min_projected_pixel_size 0.10 Global subpixel culling threshold in screen pixels (floored at 0.01).
distantdecorations.max_render_distance radius * 16.0 Absolute max rendering distance in blocks (defaults to 8192.0 at 512 chunks).
distantdecorations.disabled false Master kill-switch to disable DD processing.
distantdecorations.provider.<namespace>.<path>.disabled false Disables a specific decoration provider/renderer by identifier.
distantdecorations.provider.<namespace>.disabled false Disables all decoration providers from a given namespace.

🛠️ Developer API

Distant Decorations provides a clean, extensible API allowing third-party mods to register custom decoration types, server providers, and client renderers.

1. Define a Decoration Type & Provider (Server-Side)
public record MyCustomData(Identifier texture, Direction facing, int width, int height, int packedLight) {}

public class MyCustomProvider implements DecorationProvider<MyCustomData> {
    public static final DecorationType<MyCustomData> TYPE = new DecorationType<>(
        Identifier.fromNamespaceAndPath("mymod", "custom_deco"),
        (data, buf) -> {
            buf.writeIdentifier(data.texture());
            buf.writeByte(data.facing().get2DDataValue());
            buf.writeVarInt(data.width());
            buf.writeVarInt(data.height());
            buf.writeInt(data.packedLight());
        },
        buf -> new MyCustomData(
            buf.readIdentifier(),
            Direction.from2DDataValue(buf.readByte()),
            buf.readVarInt(),
            buf.readVarInt(),
            buf.readInt()
        )
    );

    @Override
    public DecorationType<MyCustomData> type() { return TYPE; }

    @Override
    public boolean matches(BlockEntity be) { return be instanceof MyCustomBlockEntity; }

    @Override
    public MyCustomData capture(ServerLevel level, BlockPos pos, BlockEntity be) {
        MyCustomBlockEntity custom = (MyCustomBlockEntity) be;
        return new MyCustomData(custom.getTexture(), custom.getFacing(), custom.getWidth(), custom.getHeight(), getPackedLight(level, pos));
    }

    @Override
    public AABB calculateBounds(ServerLevel level, BlockPos pos, MyCustomData data) {
        return new AABB(pos);
    }
}
2. Implement Client Renderer (Client-Side)
public class MyCustomRenderer implements DecorationClientRenderer<MyCustomData> {
    @Override
    public DecorationType<MyCustomData> type() { return MyCustomProvider.TYPE; }

    @Override
    public double cullBelowProjectedPixelSize() {
        // Opt into custom subpixel threshold for far-LOD scaling
        return 0.01;
    }

    @Override
    public void render(
        DecorationRecord record,
        MyCustomData data,
        Camera camera,
        PoseStack poseStack,
        SubmitNodeCollector submitNodeCollector,
        ProjectionMetrics metrics,
        double projectedPixelSize
    ) {
        BlockPos anchor = record.pos();
        Vec3 camPos = camera.position();

        poseStack.pushPose();
        poseStack.translate(anchor.getX() - camPos.x, anchor.getY() - camPos.y, anchor.getZ() - camPos.z);
        poseStack.translate(0.5, 0.5, 0.5);

        // Optional Far-LOD visual scaling for subpixel quads
        double targetMinPixelSize = 1.0;
        if (projectedPixelSize > 0 && projectedPixelSize < targetMinPixelSize) {
            double visualScale = Math.min(16.0, targetMinPixelSize / projectedPixelSize);
            poseStack.scale((float) visualScale, (float) visualScale, 1.0F);
            TelemetryMetrics.clientFarLodScaledRenders++;
        }

        RenderType renderType = RenderTypes.entityCutout(data.texture());
        submitNodeCollector.submitCustomGeometry(poseStack, renderType, (pose, buffer) -> {
            // Submit vertex geometry
        });

        poseStack.popPose();
    }
}
3. Registration
// Common / Server Mod Initializer
DecorationRegistry.registerProvider(new MyCustomProvider());

// Client Mod Initializer
ClientDecorationRegistry.registerRenderer(new MyCustomRenderer());

📦 Building & Testing from Source

git clone https://github.com/justbecauseph/distant-decorations.git
cd distant-decorations
./gradlew build

To run the full client test environment with Voxy, Sodium, and Spark preloaded:

./gradlew runIntegrationClient

The compiled mod JAR will be located in build/libs/.


📄 License

Distant Decorations is licensed under the Mozilla Public License 2.0 (MPL-2.0).

FAQ

Distant Decorations questions

Question not listed? Ask our team.

Distant Decorations server crashes on startup – what to do?

Common causes: the loader or Minecraft version does not match the mod file, a dependency is missing, or RAM is too low. Check the log (latest.log) for “OutOfMemoryError”, “Mixin” or missing mods. At Mado, the AI crash analysis reads the log and suggests a cause. You can change the loader and version in the panel.

Which loader does Distant Decorations run on?

According to Modrinth, Distant Decorations supports Fabric for Minecraft 26.3, 26.2.

How much RAM does a server with Distant Decorations need?

As guidance, 3–4 GB for a server with this mod. This is an estimate, not a measured minimum. More mods, many players and long view distances need more. The spark profiler shows whether a mod is costing tick time.

Ready for your server with Distant Decorations?

4 GB of RAM from €8.00 per month. 35% off your first month with MADO35.

Order server