Features

Everything you can build with Kore

Commands, every data-driven JSON file, world generation, gameplay systems and the tooling to ship them. All typed, all generated from Minecraft's own data, all compiled to plain vanilla datapacks.

65+typed commands

50+JSON resource types

80+generated registries

4mod loaders to export to

Get Started Compare with other tools

Kotlin in, vanilla datapack out

What you write on the left, the exact files Kore generates on the right. Nothing else ships.

You write

dataPack("arena") {
	lootTable("boss_chest") {
		pool {
			rolls = constant(3f)
			entries {
				item(Items.DIAMOND) { weight = 1 }
				item(Items.GOLDEN_APPLE) { weight = 4 }
				item(Items.IRON_INGOT) { weight = 10 }
			}
		}
	}
}

Kore generatesdata/arena/loot_table/boss_chest.json

{
	"pools": [
		{
			"rolls": 3.0,
			"entries": [
				{
					"type": "minecraft:item",
					"name": "minecraft:diamond",
					"weight": 1
				},
				{
					"type": "minecraft:item",
					"name": "minecraft:golden_apple",
					"weight": 4
				},
				{
					"type": "minecraft:item",
					"name": "minecraft:iron_ingot",
					"weight": 10
				}
			]
		}
	]
}

You write

dataPack("arena") {
	function("reward_winners") {
		execute {
			asTarget(allPlayers {
				scores { score("kills") greaterThanOrEqualTo 10 }
			})
			at(self())
			run {
				effect(self()) { give(Effects.GLOWING, 10, 0, true) }
				playSound(SoundEvents.Entity.Player.LEVELUP, PlaySoundMixer.MASTER, self())
				title(self(), TitleLocation.TITLE, textComponent("Champion!", Color.GOLD))
			}
		}
	}
}

Kore generatesdata/arena/function/reward_winners.mcfunction

execute as @a[scores={kills=10..}] at @s run function arena:generated_scopes/generated_278536229

data/arena/function/generated_scopes/generated_278536229.mcfunction

effect give @s minecraft:glowing 10 0 true
playsound minecraft:entity.player.levelup master @s
title @s title {type:"text",color:"gold",text:"Champion!"}

Commands & functions

The whole command set, autocompleted

Every vanilla command as a typed Kotlin call. Your IDE lists every item, block and effect, and the compiler rejects a typo before /reload ever sees it.

Every vanilla commandFrom /say to /worldborder, with typed arguments, enums and named parameters.Execute builderas, at, positioned, if/unless and store chains. A multi-command run block becomes its own function automatically.Functions & lifecycle tagsNamespaced functions, load and tick tags, and calls between functions by reference.MacrosMacro functions with typed arguments, called with literal values or straight from storage.Target selectors@a, @e, @s and friends built with filters, sorting, limits and score conditions.Raw escape hatchAnything not covered yet is one addLine("...") away, so the DSL never blocks you.

Arena.kt

function("reward") {

give(self(), Items.DIA

}

generates

give @s minecraft:diamond

Game data, typed

Items, text and NBT as real objects

Build an item once with its name, lore and components, then reuse it anywhere an item is expected.

Chat componentsText, translations, scores, selectors, hover and click events, with + to concatenate.Item componentsEvery item component, from custom names to tools, food and equippables.NBT & SNBTOne NBT DSL for commands, predicates and chat components, with path helpers.Data storageStorage as runtime variables for strings, lists and compounds beyond integers.ScoreboardsObjectives, display slots and score operations without the string juggling.Time & colorsTicks, seconds and days with arithmetic, plus named, RGB and ARGB colors serialized per context.Runtime logicHow Kotlin at build time maps to scoreboards, storage and execute at runtime.

Relic.kt

val relic = Items.NETHERITE_SWORD {
	customName(textComponent("Blade of the Arena", Color.GOLD))
	lore(textComponent("Awarded to the last one standing", Color.GRAY) + text("Season 3", Color.DARK_PURPLE))
	unbreakable()
}

give(self(), relic)

Data-driven resources

Every JSON file, without writing JSON

Each resource is a Kotlin builder that serializes to the exact vanilla schema and lands in the right folder.

Advancements Advancement triggersBanner patternsChat typesDamage typesDialogs Enchantments Enchantment providers GameTest instances GameTest environmentsInstrumentsItem modifiersJukebox songsLoot tables Mob variants Mob sound variants Painting variants Predicates Recipes Sulfur cube archetypes Tags Timelines Trade sets Trial spawners Trim materials Trim patterns Villager trades World clocks

build/arena

arena/

pack.mcmeta

data/arena/

advancement/first_kill.jsonopen

dialog/main_menu.json

enchantment/lifesteal.json

function/load.mcfunction

loot_table/boss_chest.jsonopen

recipe/arena_key.jsonopen

tags/item/weapons.json

trial_spawner/arena_wave.json

worldgen/biome/ashlands.json

written bydataPack("arena") { ... }.generate()

World generation

Shape entire worlds from Kotlin

Custom dimensions, biomes and structures, down to density functions and noise, without hand-editing thousand-line JSON.

Biomes Block predicates Carvers Configured features Density functions Dimensions Dimension types Environment attributes Flat level presets Multi-noise parameter lists Noise settings Noises Placed features Processor lists Providers Structure sets Structures Template pools World presets

seaLevel

desert temperature

Islands.kt

val terrain = noiseSettings("islands") {
	seaLevel = 63
}

dimension("islands", type = islandsType) {
	noiseGenerator(settings = terrain, biomeSource = multiNoise {
		add(multiNoiseEntry(Biomes.DESERT) {
			temperature = doubleOrPair(0.1, 1.0)
		})
		// forest, plains, snowy plains, peaks...
	})
}

Gameplay objects

Minigame systems in a few lines

The oop module turns teams, timers, boss bars and events into handles you create once and call like regular objects.

Entities & playersSelector-backed handles with commands, effects and execute helpers built in.EventsReact to player and entity actions through advancement-based listeners.World eventsTick, weather and day/night triggers plus configurable intervals.Game state machineRegister states, transition between them and run hooks on change.Timers & cooldownsCountdown timers, boss bar timers and per-player cooldowns.Teams, scoreboards & boss barsCreate, configure and update them through typed handles and operators.Items & spawnersCreate, spawn and serialize items, and batch-summon entities from reusable spawners.Dynamic stringssubstring, split, join, replace, trim and case conversion at runtime.

LOBBY→PLAYING→ENDED

Ready-made helpers

The hard math, already solved

Raycasts, particle shapes, trigonometry on scoreboards, menus and text rendering, written and tested so you don't have to.

RaycastsStep-based raycasts with block hits, max distance and per-step callbacks.Scoreboard mathFixed-point sine, cosine, atan2 and exact integer square root on scores.Score vectorsRuntime 3D vectors: dot and cross products, normalize, motion and teleports.SchedulerDelayed actions, repeating loops and timed callbacks without scoreboard chains.State delegatesKotlin var properties backed by scoreboards or NBT storage.Menus & sidebarsDialog-based menus with buttons and sub-pages, and server-style sidebars.Inventory managerListen to slot events and control player or block containers.VFX particlesCircles, lines, spheres, spirals and helixes in world, relative or local space.Displays & mannequinsBlock, item and text displays with transformations and interpolation, plus mannequins.Text renderersTurn Markdown, MiniMessage or ANSI text into chat components.Areas & NBT paths3D bounding boxes with spatial queries, and typed NBT paths.

drawShape("fx") { shape = Shape.CIRCLE }

Build & ship

From save to in‑game in one command

Every save rebuilds the pack, copies it into your worlds and reloads the server. When it's ready, export it anywhere.

Gradle pluginBuild the pack, copy it into your worlds and reload a running server over RCON on every change.Folder, zip or mod jarOne call generates a folder, a zip, or a jar for Fabric, Forge, Quilt and NeoForge.Overlays & pack formatsTarget several game versions from one pack with overlays and supported format ranges.Merge existing packsMerge generated output with hand-written datapacks, lifecycle tags included.Optimization passesPrune dead functions, shorten execute chains, dedupe functions, or write your own pass.ConfigurationPretty-printed JSON, custom indentation, generated folder names and debug comments.Automated publishingShip every release to Modrinth and CurseForge from GitHub Actions.MultiplatformGenerate packs on the JVM, on Node.js, or as zip bytes right in the browser.

Terminal

$ gradlew koreRun --continuous

FolderZipFabricForgeQuiltNeoForge

Ecosystem & interop

Fits the tools you already use

Kore plays well with the datapacks, mods and editors around it.

What Kore does not do

Knowing the boundaries saves you time before you pick a tool.

Resource packs

Kore generates datapacks only. Textures, models and sounds still live in a separate resource pack.

Runtime speedups

Output is the same vanilla commands you would write by hand, so it runs exactly as fast, no faster.

Zero-setup editing

You need a JDK and Gradle, and a build step sits between editing and /reload.

Rough edges are tracked in Known Issues, and Why Kore covers when another tool fits better.

Build your first datapack in Kotlin

Craft your first datapack with Kore and enjoy the power of Kotlin for Minecraft development.

Get Started Migrate an existing pack