linkKore

Welcome to the Kore wiki!

Kore is a Kotlin library for building Minecraft datapacks with a concise, type-safe Kotlin DSL. It focuses on readable builders, stable generation of datapack JSON, and tight integration with vanilla concepts (functions, loot tables, predicates, worldgen, ...).

linkQuick start

• Getting started: Check out the Getting Started guide for a step-by-step introduction to creating your first datapack.
• Prerequisites: Java 21+ and a Kotlin-capable build environment.
• Starter template: use the Kore Template for a ready-to-run project: Kore Template.
• Create & generate: see Creating A Datapack for lifecycle and output options (.generate(), .generateZip(), .generateJar()).
• Build faster: browse the Cookbook for practical patterns you can reuse.

linkInstallable modules

Kore is split into installable modules. Start with kore, then add the others depending on the abstractions or tooling you need.

linkkore - Core DSL

• Build datapacks with the main Kore DSL.
• Artifact: io.github.ayfri.kore:kore:VERSION
• Snapshot builds from each commit on master: add https://central.sonatype.com/repository/maven-snapshots/ and use VERSION-SNAPSHOT
• Start here: Getting Started

linkoop - Object-oriented gameplay utilities

• Add higher-level abstractions for boss bars, cooldowns, entities, game states, scoreboards, spawners, teams, and timers.
• Especially useful when several gameplay systems need to exchange data cleanly, such as syncing a Team with a boss bar or reusing an Entity handle across scoreboards and commands.
• Artifact: io.github.ayfri.kore:oop:VERSION
• Explore: OOP Utilities

linkhelpers - Utility-focused helpers

• Add renderers, raycasts, scheduler utilities, scoreboard math, state delegates, particle helpers, and related utilities.
• These helpers complement the core DSL well for advanced text pipelines, reusable state access, geometric particles, or command-heavy math routines.
• Artifact: io.github.ayfri.kore:helpers:VERSION
• Explore: Helpers Utilities

linkbindings - Datapack importer

• Import existing datapacks and generate type-safe Kotlin bindings for their functions, resources, and tags.
• Artifact: io.github.ayfri.kore:bindings:VERSION
• Explore: Bindings

linkMinimal example

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

linkEssential reading

• Getting Started: step-by-step guide to create your first datapack.
• Creating A Datapack: lifecycle, output paths, and generation options.
• Cookbook: practical recipes combining multiple Kore features.
• Commands: comprehensive guide to all Minecraft commands with examples.
• Functions: building functions, tags, and command helpers.

linkFull documentation index

linkCore Guides

• From Datapacks to Kore - advanced guide for migrating established datapacks to a Kotlin/Kore architecture.
• Configuration - JSON formatting and generation options.
• Cookbook - practical patterns for common datapack workflows.

linkCommands

• Macros - dynamic command arguments for reusable functions.

linkConcepts

• Components - item/component builders and custom components.
• Chat Components - formatted messages and text components.
• Colors - chat colors and formatting options.
• Selectors - entity and player targeting with typed filters.
• Scoreboards - objectives, teams, and scoreboard displays.

linkData-Driven

• Predicates - reusable conditions used by loot tables, advancements and item modifiers.
• Loot Tables & Item Modifiers - tables, pools and /item modify helpers.
• Recipes & Advancements - crafting, rewards and integration.
• Enchantments - custom enchantment definitions.
• Dialogs - NPC dialog systems.
• Worldgen - biomes, features and dimension examples.
• Tags - custom tag definitions for grouping items, blocks, entities, etc.

linkHelpers

• Helpers Utilities - overview of helper-focused utilities extracted from the OOP module.
• Display Entities - text, block, and item displays.
• Inventory Manager - inventory manipulation helpers.
• Mannequins - armor stand helpers.
• ANSI Renderer - ANSI escape codes to text components.
• Area - 3D bounding box geometry.
• Markdown Renderer - Markdown to text components.
• MiniMessage Renderer - Adventure MiniMessage to text components.
• Raycasts - recursive step-based raycasting.
• Scheduler - delayed function execution patterns.
• Scoreboard Math - trigonometry and algebra via scoreboards.
• State Delegates - Kotlin property delegates for scoreboards/storage.
• VFX Particles - geometric particle shapes.

linkOOP

• OOP Utilities - overview of all OOP module features.
• Entities & Players - entity/player management, commands, and effects.
• Teams - object-oriented team management.
• Scoreboards - objective and score operations.
• Items - item creation and spawning.
• Events - advancement-based event system.
• Cooldowns - scoreboard-based cooldowns.
• Boss Bars - boss bar management.
• Timers - scoreboard-based timers with optional boss bar.
• Spawners - reusable entity spawner handles.
• Game State Machine - scoreboard-based state machine.

linkAdvanced

• Bindings - import existing datapacks and generate Kotlin bindings (experimental).
• GitHub Actions Publishing - automate datapack publishing.
• Test Features (GameTest) - testing datapacks with GameTest.
• Known Issues - workarounds and limitations.

linkContributing to Kore

If you want to contribute to Kore itself, start with Contributing to Kore, the hub for architecture, workflow, issue/PR, and maintainer docs.

Useful contributor-facing internals:

• Architecture and Patterns - module boundaries and recurring implementation patterns.
• Arguments Internals - how the typed argument layer, resource wrappers, and literals fit together.

linkShort tips

• Keep builders small and reusable; prefer extracting predicates and modifiers.
• Enable prettyPrint in Configuration during development for readable JSON.
• Reach for OOP Utilities when multiple gameplay features should share the same handles instead of re-building selectors and score names manually.
• Use Components + Predicates together for robust item checks and inventory management.
• Use Helpers Utilities to avoid reimplementing common glue code such as renderers, scheduler patterns, raycasts, or scoreboard-based maths.

linkKnown issues

Check out the Known Issues page for a list of known issues and workarounds.

linkCommunity & source

• Repository: Kore
• Starter template: Kore Template
• LLM-friendly documentation: llms.txt | llms-full.txt

For hands-on examples, follow the doc pages above - most pages include runnable snippets and links to test cases in the repository.