Features - Commands, JSON Resources, Worldgen & Tooling

Generated output

The Kotlin you write next to the exact files Kore generates from it. 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

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

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)

Try it in the playground

Data-driven resources

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

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

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

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

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

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

Datapack bindingsImport any datapack, even from GitHub, and reference its functions and tags with type-safe Kotlin.Lantern LoadFull Lantern Load boilerplate, version publishing and dependency guards.Fabric resource conditionsLoad recipes, advancements and loot tables only when mods, tags or flags are present.GameTestWrite test instances and environments for Minecraft's built-in test framework.Editor pluginsKore Assistant browses every declaration as a datapack tree and flags calls to functions declared nowhere. A VS Code extension is also available.Project templateClone a working project with Gradle already set up and start writing your pack.PlaygroundWrite Kore in the browser, browse the generated files and download the pack as a zip, with nothing to install.

Limits

What Kore does not do, so you know before picking 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.