Rethink your datapack development experience withKore

Kore is a modern, open-source, and easy-to-use Kotlin library for Minecraft datapack development. You can use it to create your own Minecraft Datapacks, and without the need to write a single line of JSON or MCFunction.

Get Started GitHub

fun main() {
	val datapack = dataPack("test") {
		function("display_text") {
			tellraw(allPlayers(), textComponent("Hello World!"))
		}

		recipes {
			craftingShaped("enchanted_golden_apple") {
				pattern(
					"GGG",
					"GAG",
					"GGG"
				)

				key("G", Items.GOLD_BLOCK)
				key("A", Items.APPLE)

				result(Items.ENCHANTED_GOLDEN_APPLE)
			}
		}

		function("tp_random_entity_to_entity") {
			val entityName = "test"
			val entity = allEntities(limitToOne = true) {
				name = entityName
			}

			summon(Entities.CREEPER, vec3(), nbt {
				this["CustomName"] = textComponent("Hello World!")
			})

			execute {
				asTarget(allEntities {
					limit = 3
					sort = Sort.RANDOM
				})

				ifCondition {
					score(self(), "test") lessThan 10
				}

				run {
					teleport(entity)
				}
			}
		}

		pack {
			description = textComponent("Datapack test for ", Color.GOLD) + text("Kore", Color.AQUA) {
				bold = true
			}
		}
	}

	datapack.generateZip()
}

fun scoreboardDisplayDatapack() = dataPack("scoreboard_display") {
	val randomEntityUUID = randomUUID()
	val scoreName = "score"

	// use a marker entity to hold the score
	val scoreHolderEntity = allEntities(limitToOne = true) {
		nbt = nbt {
			putNbtCompound("data") {
				this["UUID"] = randomEntityUUID.uuid.toString()
			}
		}
	}

	load {
		ScoreboardDisplay.resetAll()

		// create the entity
		summon(EntityTypes.MARKER) {
			putNbtCompound("data") {
				this["UUID"] = randomEntityUUID.uuid.toString()
			}
		}

		// create the score
		scoreboard.objectives.add(scoreName)
		scoreboard.player(scoreHolderEntity) {
			set(scoreName, 0)
		}
	}

	tick {
		// recreate the scoreboard display each tick so that it's dynamic
		scoreboardDisplay("minigame") {
			displayName = textComponent("✪ Mini-game ✪", Color.GOLD)

			// some fake lines for the example
			appendLine("Game: Mini-game")
			appendLine("IP: 127.0.0.1")
			appendLine("Players: 10/20")

			appendLine("------------------")

			// display the score
			appendLine(textComponent("Score: ")) {
				customScoreEntity = scoreHolderEntity
				customScoreObjective = scoreName
			}

			emptyLine()
			appendLine("HyKore server 3.1.0")

			// hide values except the score
			hideValues(1..<5)
			hideValues(6..lines.size)
		}
	}
}

data object VanillaTweaksCreate {
	val VANILLA_TWEAKS_SPAWN_NAMESPACE = "spawn"

	context(Function)
	fun checkX() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "check_x")
	context(Function)
	fun checkZ() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "check_z")
	context(Function)
	fun config() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "config")
	context(Function)
	fun decrementCooldown() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "decrement_cooldown")
	context(Function)
	fun decrementCooldowns() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "decrement_cooldowns")

	// ...
	context(Function)
	fun uninstall() = function(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, "restore_command_feedback")

	// Note : You could also use FunctionArgument instead, but you'll have instead to call the function explicitly.

	fun loadedPredicate() = PredicateArgument.invoke(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, name = "loaded")

	fun validSpawnLocationTag() = TagArgument.invoke(namespace = VANILLA_TWEAKS_SPAWN_NAMESPACE, name = "blocks/valid_spawn_location")
}

fun main() {
	val datapack = dataPack("vanilla_tweaks_spawn") {
		function("check_coordinates") {
			VanillaTweaksCreate.checkX()
			VanillaTweaksCreate.checkZ()
		}

		function("config_if_loaded") {
			execute {
				ifCondition(VanillaTweaksCreate.loadedPredicate())
				run {
					VanillaTweaksCreate.config()
				}
			}
		}
	}
}

architecture

Modern

Write datapacks for recent Minecraft versions with a modern programming language leveraging Kotlin features for robust code.

data_object

Easy to use

Intuitive API and abstractions over vanilla minimize complexity for simple datapack development.

group_add

Open Source

Active community and contributions provide freedom and support for any open source project.

fun myDatapack() = dataPack("my_datapack") {
	function("test") {
		say("Hello World!")
	}

	function("gamemode_creative") {
		gamemode(Gamemode.CREATIVE)
		tellraw(
			targets = allPlayers(),
			message = "You are now in creative mode!",
			color = Color.GREEN
		)
	}
}

Simple APIs

Kore provides simple and intuitive APIs to create Minecraft datapacks and call commands. Almost all the lists from the game are available as enums, so you are always sure to use the right value.

import myproject.constants.myScore
import myproject.functions.myFunction
import myproject.predicates.myPredicate

fun myDatapack() = dataPack("my_datapack") {
	function("execute_my_function") {
		execute {
			ifCondition(myPredicate)

			run {
				function(myFunction)
				scoreboard.player(self()) {
					add(myScore, 1)
				}
			}
		}
	}
}

Perfect for big projects

Kore is perfect for big projects, as it allows you to split your code into multiple files and use the full power of Kotlin to manage your code.

fun myDatapack() = dataPack("my_datapack") {
	val myRecipe = recipesBuilder.smithingTransform(
		name = "diamond_to_netherite"
	) {
		template(Items.DIAMOND_BLOCK)
		base(Items.DIAMOND_SWORD)
		addition(Items.NETHERITE_INGOT)
		result(Items.NETHERITE_SWORD)
	}

	function("give_recipe") {
		recipe(allPlayers()).give(myRecipe)
	}
}

JSON-less

By using Kore, you don't have to write a single line of JSON ever. You only have one language to learn and maintain. Feature-complete code completion and documentation are available in your IDE.

fun myDatapack() = dataPack("my_datapack") {
	function("kore_is_great") {
		advancement(allPlayers {
			gamemode = !Gamemode.CREATIVE
			nbt = nbt {
				this["using_kore"] = true
			}
		}) {
			grant(Advancements.Story.SHINY_GEAR)
		}

		playSound(
			sound = Sounds.Block.EnchantmentTable,
			source = PlaySoundSource.MASTER,
			target = allEntities()
		)
	}
}

Type-safe

We crafted generators for dozens of Minecraft lists, so you can be sure to use the right value at the right place. No more typos in your commands, JSON files, or functions.

Frequently Asked Questions

Is Kore compatible with recent Minecraft versions?

Yes, Kore is compatible with all Minecraft versions from 1.20 to the latest version.

Can I use other datapacks with Kore?

Yes, you can use other datapacks with Kore. By providing bindings for your datapacks, you can use them in your Kore code.

Why would I use Kore?

Kore is a modern, open-source, and easy-to-use Kotlin library for Minecraft datapack development. You can use it to create your own Minecraft Datapacks, and without writing a single line of JSON or MCFunction. You'll have great, precise, and fast code completion, and you'll be able to use the full power of Kotlin to manage your code. Furthermore, you can even create libraries to help you or others develop datapacks.

Are its APIs complete?

Yes, Kore's API is complete. It provides simple and intuitive APIs to create Minecraft datapacks and call commands. All the common lists of the game are available as enums (like all the blocks, items, enchantments, etc.), you are always sure to use the right value.

Is Kore compatible with mods?

By providing APIs for creating your own commands/features, you can use Kore with mods. However, Kore is not compatible with mods directly.

Build your first datapack in Kotlin

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

Get Started