HotCrafted

HOT DISCLAIMER: This mod and firstparty macros were fully made by GPT-5.6 Sol max with human review. (they were designed by me though) The mod will probably work well but it may have some weird bugs or things I did not account for. This is not a perfect mod, so here be dragons! GPT Readme below:

HotCrafted is a client-side, approval-gated Java macro hotloader for Minecraft. Drop a .java source file into [instance]/hotcrafted/macros, review and approve its exact SHA-256 in game, and HotCrafted compiles it against the live game, loader, installed mods, and optional integration jars without restarting.

This is intentionally a full-power mod loader, not a sandbox. An approved macro can do anything another in-process mod can do, including reading files, using the network, calling Minecraft internals, and integrating with other mods.

Security and reload model

• New and changed .java files are never compiled before approval.
• Approval is tied to the file's exact SHA-256. Any byte-level change unloads and disables the prior class before the replacement can compile.
• The approval screen re-hashes the file when Approve is clicked, preventing a file-change race while the review is open.
• The first enable of each macro ID opens a full-power warning. Its Continue button remains disabled for five real seconds; that acknowledgement is stored once per macro ID.
• Approved sources compile on one minimum-priority daemon thread. Source files are limited to 4 MiB and runtime logs rotate at 16 MiB.
• HotCrafted watches the folder and also performs a fallback scan every ten seconds.

Approving a macro is equivalent to installing and running a mod. Only approve code you personally trust and have reviewed.

Configured version and loader matrix

Stonecutter owns the shared source/version graph. Fabric is primary, NeoForge is secondary, and Forge/Quilt are tertiary.

Loader	Configured Minecraft versions
Fabric	1.20–1.20.6, 1.21–1.21.11, 26.1, 26.1.1, 26.1.2, 26.2
NeoForge	1.20.4, 1.21.1–1.21.11, 26.1, 26.1.1, 26.1.2, 26.2
Forge	1.20–1.20.4, 1.20.6, 1.21, 1.21.1, 1.21.3–1.21.11, 26.1.1, 26.1.2, 26.2
Quilt	1.20.1, 1.20.4, 1.21.1–1.21.11, 26.1, 26.1.1, 26.1.2, 26.2

Forge 1.20.5 and 1.21.2 do not have matching Forge releases. Forge 26.1 is omitted because the available Forge bootstrap fails during setup; 26.1 remains covered by Fabric, NeoForge, and Quilt.

Architectury API provides the common platform, client tick/chat, key-mapping, and loader services on Fabric, Quilt, and NeoForge. Forge uses the same Stonecutter sources with a small native reflection/Mixin fallback where modern Architectury Forge artifacts are unavailable.

Building without launching Minecraft

The checked-in defaults cap Gradle at a 512 MiB heap and 256 MiB metaspace, use one worker, disable parallel execution, disable the persistent daemon, and disable VFS watching. No build or check task launches Minecraft.

Always select one target and use configure-on-demand for local builds; this keeps Gradle from configuring unrelated Minecraft toolchains. On Windows, the checked-in settings also accept HOTCRAFTED_TARGET, which avoids wrappers that drop dotted Gradle properties:

$env:HOTCRAFTED_TARGET='26.2-fabric'
.\gradlew.bat --configure-on-demand --no-daemon --max-workers=1 :26.2-fabric:build

$env:HOTCRAFTED_TARGET='1.20.1-quilt'
.\gradlew.bat --configure-on-demand --no-daemon --max-workers=1 :1.20.1-quilt:build

The 26.2 Fabric check task also compiles the bundled DSMPMiner source against the real target classpath. It still does not start a game client.

Installing and using HotCrafted

1. Put the matching HotCrafted jar in the instance's mods folder.
2. Fabric, Quilt, and NeoForge builds require the matching Architectury API jar.
3. Use a Minecraft runtime that includes javac, or point HOTCRAFTED_JAVAC at a compatible javac.exe.
4. Start the client normally and press F8 to open HotCrafted.
5. Put macro sources directly in [instance]/hotcrafted/macros.
6. Select a pending macro, inspect its filename/hash, approve that exact file, then enable it.

The screen provides search, status, hash approval/rejection, enable/disable, per-macro configuration, folder access, and pagination.

Runtime layout:

[instance]/hotcrafted/
├── macros/             approved-at-runtime .java sources
├── data/<macro-id>/    private config and logs for each macro
├── lib/                extra jars added to the macro compiler classpath
├── cache/<sha256>/     generated class files
├── state.properties    approvals, first-enable warnings, enabled choices
└── hotcrafted.log      bounded loader/runtime diagnostics

Macro API

One source file must contain a concrete top-level class implementing dev.hotcrafted.api.HotCraftedMacro and a no-argument constructor.

package hotcrafted.macros;

import dev.hotcrafted.api.HotCraftedMacro;
import dev.hotcrafted.api.MacroContext;

public final class HelloMacro implements HotCraftedMacro {
    @Override
    public String id() {
        return "hello";
    }

    @Override
    public void onEnable(MacroContext context) {
        context.localMessage("Hello from a hot-loaded Java macro");
    }

    @Override
    public void onTick(MacroContext context) {
        // Runs on the Minecraft client thread while enabled.
    }
}

Available callbacks are onLoad, onEnable, onDisable, onTick, onRender, onChatReceived, and onUnload. When Baritone is present, the stable core-owned render bridge passes its world RenderEvent to enabled macros without pinning a hot-reloaded macro classloader. MacroContext exposes the live Minecraft instance, game/mod classloader, game/data paths, loader/version information, client-thread execution, commands, local chat, screen opening, and logging.

The compiler classpath includes the running game's classpath/classloaders, all jars in [instance]/mods, and all jars in [instance]/hotcrafted/lib. This is what permits direct use of Minecraft, loader, other-mod, and integration APIs.

For an optional custom options screen, return a Minecraft Screen from createOptionsScreen. For Fzzy Config, register a config normally and return its scope from fzzyConfigScope; HotCrafted calls ConfigApiJava.openScreen(String) reflectively, so Fzzy Config remains optional and is not embedded.

Mapping caveat before Minecraft 26.1

Minecraft 26.1+ ships unobfuscated jars. Older clients still run in a loader runtime namespace, so a runtime-compiled macro must use the names present in that running instance. The stable HotCrafted API works across the matrix; direct Minecraft imports on older versions may need the loader's runtime names or a reflection/mapping bridge supplied by the macro author.

First-party DSMPMiner macro (26.2 Fabric only)

HUMAN NOTE: designed for donutsmp.net (designed to be used with meteor client)

The durable source is firstparty-macros/DSMPMiner.java. On its first 26.2 Fabric start, HotCrafted copies DSMPMiner.java into the macro folder pending approval. An existing DeepExplorerMacro.java is preserved as the non-loadable DeepExplorerMacro.java.legacy-disabled during the rename. It requires the 26.2 Baritone fork to be installed. The implementation was grounded against the fork's 26.2 branch at commit ae025968019160339ab427d97c101546965e9b14 and drives Baritone's real public processes rather than imitating movement packets:

• sends /rtp, waits for the teleport to settle, and offers three descent modes: Deepest open terrain, Fast cave near Y -40, or Hole Finder;
• Deepest Open Terrain accepts open cave levels from Y −30 through −60, prefers Y −40, raises Baritone's block-break penalty to 24, selects revealed zero-mining descent routes first, and refreshes a forward exploration anchor to reduce backtracking; it sends a fresh /rtp after each five-minute exploration cycle;
• Fast Y −40 and Hole Finder first run a bounded search through actually revealed, connected two-block-high cave floors. If no downward opening is revealed, they advance a forward GoalXZ frontier three times to load real chunks before allowing Baritone's high-break-cost GoalYLevel(-40) fallback;
• Hole Finder sends /delhome 3 and then /sethome 3 before each directional route, uses the same descent and exploration planner, starts a 1,200-client-tick (normally 60-second) exploration window only after the real player body reaches its hole, sends /home 3, waits for the real return position instead of assuming a server teleport delay, rotates toward a new direction, refreshes home 3, and repeats;
• treats deep/far route data as unknown rather than an impassable wall beyond the requested 10-block/6-chunk confidence limits, extended to 20/8 with clear sight; nearby previously loaded chunks remain trusted within 16 chunks;
• uses Baritone's actual ExploreProcess, a forward-shifted cached-chunk anchor, depth-maintaining heuristic, high block-break cost, loaded-boundary re-plan, sprinting, native sprint-jumps into safe one-block ascents, diagonal movement, digging, placement, and backfill; unreliable gap parkour stays disabled because Baritone's own BackfillProcess refuses to operate while parkour is enabled;
• uses only a mild Baritone mob path cost (1.20). The former close-zombie GoalRunAway cancellation loop is removed, so mobs never repeatedly replace the descent/exploration process; it never attacks or selects a combat target, so it does not compete with KillAura attack input;
• uses Baritone freeLook/blockFreeLook and its normal look behavior to face into the travel direction on server-facing movement updates while restoring the local camera; no raw movement-packet loop or input-simulation layer is added;
• enables Baritone's animated goal, path, XZ beacon, and break/place selection overlays; cached-chunk ghost rendering stays off because Baritone documents it as expensive and potentially unstable;
• uses the actual LocalPlayer body—not a freecam/render-camera position—to decide whether a cave/frontier goal was reached;
• immediately cancels movement when another loaded player appears, records name, time, coordinates, and dimension, waits 20 client ticks (normally one second), replaces home 3 with /delhome 3 then /sethome 3, and disconnects;
• immediately replaces home 3 and disconnects when any loaded ender pearl not owned by the local player appears, without requiring line of sight;
• at one heart, cancels movement, records the danger coordinates, replaces home 3, sends /home base instead of disconnecting, and waits for an actual position or dimension jump rather than assuming a teleport delay; if death still occurs, it saves the final known coordinates, dimension, stage, time, and reason;
• records all received chat, and scans actual client-loaded chunks through stable core-owned chunk callbacks plus bounded nearest-first periodic rescans. The scanner uses each chunk's palette-aware block search instead of walking a large moving cuboid position by position, and never applies navigation confidence or line-of-sight rules to configured finds;
• sends a local message and appends time/dimension/ID/XYZ/kind to blocks.csv for every configured tracked find, then renders a Baritone selection-box ESP and body-to-find tracer in that block's configured RGB colour.

DSMPMiner preserves the original macro ID and writes to [instance]/hotcrafted/data/deep_explorer_26_2, so the rename keeps existing data:

• deep-explorer.properties — scan, descent-mode, look, mob, and one track.<id> toggle plus color.<id>=RRGGBB value for every tracked block/item;
• blocks.csv — block and dropped-item finds;
• players.txt — safety-triggering players and coordinates;
• deaths.txt — final known coordinates and state if the player dies;
• chat.txt — all received chat text;
• events.txt — navigation and safety transitions.

Iron block is intentionally absent. Every remaining screenshot entry is individually enabled/disabled and assigned a custom hexadecimal ESP/tracer colour in the macro's paginated Tracked finds screen. minecraft:shulker_box covers every coloured shulker box; Resin Clump is tracked as a dropped item because it is not a placeable block.

The confidence rules affect navigation only. Block-find logs contain actual IDs received by the client; HotCrafted does not infer or reveal withheld blocks.

First-party Development MCP macro (26.2 Fabric only)

The durable source is firstparty-macros/DevelopmentMcpMacro.java. HotCrafted seeds it pending approval beside DSMPMiner. When the user approves and enables it, the macro:

• binds only 127.0.0.1:15565, with http://localhost:15565/ as the primary MCP endpoint and /mcp as a compatibility alias;
• requires Authorization: Bearer ... on every request. A cryptographically random token is created at [instance]/hotcrafted/data/development_mcp_26_2/bearer-token.txt; the token is never printed to chat or logs;
• validates any browser Origin header and rejects non-loopback origins to prevent DNS-rebinding access;
• implements current stateless MCP 2026-07-28 discovery, metadata, routing-header, ping, tools/list, and tools/call behavior, while also supporting the legacy initialize/notifications/initialized lifecycle through 2025-11-25 clients;
• exposes one explicitly destructive/full-power tool, run_java. Its code is a Java method body with Minecraft minecraft and MacroContext context parameters; optional imports are placed above the generated class;
• compiles against the exact same live Minecraft, loader, installed-mod, and hotcrafted/lib classpath as ordinary HotCrafted macros, then invokes the method on Minecraft's real client thread;
• bounds HTTP bodies, queues, response text, generated classloaders, and on-disk compiler cache. It uses at most two minimum-priority daemon HTTP threads and an external fallback compiler capped at 256 MiB;
• stops the listener immediately when disabled or unloaded.

For example, a run_java method body can be as small as:

return "player=" + (minecraft.player == null ? "none" : minecraft.player.getName().getString());

The request timeout limits how long the server waits for a result; Java already running on the client thread cannot be safely preempted. Treat enabling this macro as granting complete mod-level control for that session. The transport and security behavior follows the official MCP Streamable HTTP specification and the tools/list / tools/call schema.

Dependencies and credits

• Architectury API — shared loader/event/platform API.
• Stonecutter — version/loader source graph.
• Baritone and the 26.2 fork — navigation processes, goals, pathing, avoidance, backfill, look behavior, cache, and overlays used by the personal macro.
• Meteor Client — its 26.2 Fabric chunk scanning, ESP organization, rotation, and Baritone integration were reviewed as design references; no GPL-covered Meteor source is embedded.
• Fzzy Config — optional config-screen bridge; not bundled.

See NOTICE.md for attribution details. HotCrafted itself is MIT licensed.