Registry Dumper 3000

Registry Dumper 3000 is a developer/debugging utility mod for modpack makers, datapack creators, and mod developers.

It dumps Minecraft registries, tags, recipes, and resource folders to disk in a structured format so you can inspect exactly what is loaded in your game/server.

This is especially useful for:

modpack debugging
datapack troubleshooting
tag/recipe conflict investigation
registry inspection across mods
reverse-engineering data-driven content
checking what resources actually loaded after packs merge

What it dumps

Built-in registries

Dumps all built-in registries (not just blocks/items/fluids) from BuiltInRegistries.REGISTRY.

Output format: TXT or JSON (configurable)
Optional class names for entries (great for modded debugging)

Runtime registries

Dumps all runtime registries from the server RegistryAccess.

This includes modded/runtime-loaded registries and gives you the final state seen by the server.

Raw tag JSONs

Dumps raw tag JSON files directly from the resource manager (data/*/tags/...).

Routes files by inferred registry type
Supports modded tag types
Can preserve original JSON formatting or pretty-print (configurable)

Expanded runtime tags

Dumps the final merged tag contents from Registry#getTags().

This lets you see the actual resolved contents of tags after all mods + datapacks + resource layers are applied.

Output format: TXT or JSON (configurable)

Raw recipe JSONs

Dumps raw recipe JSON files from data/*/recipes/....

Groups recipes by parsed recipe type
Handles unknown recipe type and invalid JSON safely
Optional pretty printing

Generic datapack resource folders (rule-based)

Config-driven dumping for arbitrary datapack folders (raw copy mode), including a large default ruleset.

Examples covered by default:

loot_tables
predicates
item_modifiers
advancements
functions
worldgen/* (biomes, features, structures, template pools, processors, noise, density functions, presets, etc.)
dimension
dimension_type
damage_type
chat_type
trim_material
trim_pattern
painting_variant
instrument
jukebox_song
Forge / NeoForge extras like loot modifiers / biome modifiers / structure modifiers

Unknown top-level folder catch-all (optional)

Can also dump top-level data folders that are not explicitly covered by your configured rules.

This helps find hidden or mod-added resource directories you forgot to account for.

Client asset folders (optional)

Optional client-side asset dumping on client start (disabled by default because it can be huge).

Examples:

lang
models
blockstates
textures
sounds
font
shaders
post_effect
particles
atlases

Why this mod is useful

When debugging modded Minecraft, the hard part usually isn't "what should be loaded" — it's "what actually got loaded after everything merged?"

Registry Dumper 3000 helps answer that by exporting:

final registries
final expanded tags
raw source JSONs
raw resource folders
structured summaries with counts

It is designed for inspection and troubleshooting, not gameplay features.

Output location

By default, dumps are written to:

<game folder>/dump/

The folder layout is configurable in the mod config.

Examples of generated roots (default names):

dump/registry_builtin
dump/registry_runtime
dump/tags
dump/registry_tags_expanded
dump/recipes
dump/data_raw
dump/assets_raw

The mod also writes summary files (_summary.txt) for major dump sections.

Configuration

A detailed JSON config is automatically created at:

<game folder>/config/registry_dumper_3000.json

The config lets you control:

what dump sections are enabled
TXT vs JSON output for supported dumps
pretty-print behavior for raw JSON copies
run-once-per-session behavior
client/server triggers
rule-based resource folder dumping
unknown-folder catch-all behavior
optional asset dumping
summary/report generation
optional resource stack dumping (advanced)

Performance / size notes

This mod can generate a lot of files depending on your modpack and config.

Please keep in mind:

enabling asset dumping can be very large
enabling unknown-folder catch-all can greatly increase output size
pretty-printing JSON increases CPU work and file size
optional resource stack dumping can multiply file count

If you only need specific data, disable the sections you don't need.

Who should use this

This mod is ideal for:

modpack developers
datapack developers
mod developers
server pack maintainers
technical players debugging data-driven content

If you just want gameplay content, this mod is probably not for you.

Compatibility notes

Built with Architectury-style lifecycle hooks
Uses reflection in a few places for compatibility (platform info / client resource manager / optional resource stack APIs)
Intended as a utility/debugging tool and may produce different amounts of output depending on loader/version/modpack contents

Quick start

Install the mod and launch the game/server.
Let it generate the config file.
Edit config/registry_dumper_3000.json to enable/disable what you want.
Restart and check the dump/ folder.
Use the generated _summary.txt files to quickly see what was exported.

Notes for pack authors

This mod is great for diagnosing issues like:

tag contents not matching expectations
recipe overrides not applying
datapack resource path mistakes
unexpected modded registry entries
data-driven feature generation problems (worldgen folders)

It can also help you build automation/scripts that inspect dumped outputs for pack QA.