linkWhy Kore

Datapacks are powerful but painful to write by hand: stringly-typed commands, sprawling JSON, no autocomplete, and silent failures you only discover after /reload. Kore replaces all of that with a single, strongly-typed Kotlin DSL that generates the exact same vanilla output - just faster, safer, and without the boilerplate.

This page is for deciding: what Kore gives you over raw datapacks, how it compares to other generators, and when it is the wrong tool. If you are already convinced, go to Getting Started instead.

linkThe problem with hand-written datapacks

A real datapack is a mix of two error-prone formats:

• .mcfunction - plain text commands with no validation. A typo in a selector, a wrong block id, or a misremembered argument order fails silently or breaks at runtime.
• JSON - loot tables, predicates, advancements, recipes, worldgen, dialogs. Deeply nested, verbose, and easy to get subtly wrong. No editor tells you a field is misspelled until the game refuses to load it.

There is no autocomplete, no type checking, no refactoring, and no way to share logic except copy-paste. As a pack grows, this gets worse fast.

linkWhat Kore changes

linkOne language, no JSON

You write Kotlin. Kore generates the .mcfunction and JSON for you. You never hand-write a brace.

dataPack("example") {
	function("hello") {
		tellraw(allPlayers(), textComponent("Hello World!"))
	}
}.generateZip()

linkEverything is typed

Every vanilla list - blocks, items, entities, effects, enchantments, biomes, sounds - is a generated enum. You cannot misspell minecraft:diamond_sword, because you write Items.DIAMOND_SWORD and the compiler checks it. The same applies to command arguments, NBT paths, and data-driven schemas. See Arguments.

linkReal code structure

Because it is Kotlin, you get everything the language offers: extension functions to split a pack across files, loops and conditionals to generate repetitive content at build time (see Runtime Logic), and refactoring/autocomplete from your IDE. Big projects stay maintainable.

linkTested, predictable output

Kore is a build-time generator. There is no runtime, no plugin, no server mod. The output is exactly the vanilla datapack you would have written by hand - every public feature ships with tests asserting the exact generated JSON and command strings. What you generate is what loads.

linkUp to date

Kore tracks recent Minecraft versions closely, including newer systems like command macros, dialogs, timelines, and the current pack format. You get modern features with type safety on day one.

linkHow Kore compares to other generators

Kore is not the only datapack generator. Here is an honest, broad-strokes comparison. (Verify specifics against each project before quoting - tooling moves fast.)

Where Kore wins: a single strongly-typed Kotlin DSL with generated registries, so vanilla ids are real symbols the compiler checks, plus exact-output tests shipped with every feature. The DSL mirrors Minecraft's own structure, so it reads naturally to anyone who knows datapacks.

Where others may fit better: Beet has a very mature plugin ecosystem and mecha's command compiler, and is a good fit if your team lives in Python. Sandstone is a strong choice for TypeScript-first teams.

Kore's bet is that for anything beyond trivial, a typed compiler-checked DSL saves more time than it costs to learn.

linkChoose Kore when

• Your pack is more than a few functions, or you expect it to grow.
• You want autocomplete, refactoring, and the compiler catching mistakes before /reload.
• You already know Kotlin (or are happy to learn a small subset - see Getting Started).
• You want data-driven content (loot, recipes, advancements, worldgen, dialogs) without writing JSON.

linkSkip Kore when

Being honest about the cost matters more than winning the comparison:

• The pack is tiny or one-off. Three functions and a loot table are not worth a Gradle project.
• Your collaborators will not touch a JVM toolchain. Kore needs a JDK, Gradle, and a compile step between editing and /reload - slower than saving an .mcfunction and reloading.
• You need resource packs too. Kore targets datapacks only, see Known Issues.
• You expect runtime gains. Kore improves authoring, not in-game execution cost: the generated commands run exactly as fast as the ones you would have written.

linkNext steps

• Getting Started - build your first datapack
• Runtime Logic - the one concept that makes everything click
• From Datapacks to Kore - port a pack you already ship