linkBindings (Import Existing Datapacks)

The bindings module lets you import existing datapacks and generates Kotlin types so you can reference functions, resources, and tags safely in your code.

linkInstall this module

Add the bindings artifact when you want to import an existing datapack and generate Kotlin bindings from it.

linkArtifact

dependencies {
	implementation("io.github.ayfri.kore:bindings:VERSION")
}

linkBest fit

• Use kore for the main DSL.
• Add bindings when you want type-safe access to resources coming from an external datapack.
• Combine it with oop or helpers only if your project also needs those higher-level utilities.

linkQuick start

import io.github.ayfri.kore.bindings.api.importDatapacks

importDatapacks {
	configuration {
		outputPath("src/main/kotlin")
		packagePrefix = "kore.dependencies"
	}

	github("pixigeko.minecraft-default-data:1.21.8") {
		subPath = "data"
	}

	modrinth("vanilla-refresh")
	curseforge("repurposed-structures-illager-invasion-compat")
	url("https://example.com/pack.zip")
}

linkUsing generated bindings

When you import a datapack, Kore generates a data object with a name derived from the datapack's name (e.g., VanillaRefresh).

linkAccessing resources

Resources are organized by namespace and type. If a datapack has only one namespace, resources are accessible directly:

import kore.dependencies.vanillarefresh.VanillaRefresh

function("my_function") {
	// Call a function from the imported datapack
	function(VanillaRefresh.Functions.MAIN_TICK)

	// Reference a loot table (see Commands for loot usage)
	loot(VanillaRefresh.LootTables.BLOCKS.IRON_ORE)
}

For more on using commands with imported resources, see Commands.

If the datapack uses multiple namespaces, they are nested:

VanillaRefresh.Minecraft.LootTables.CHESTS.ABANDONED_MINESHAFT

linkTags

Tags are also imported and can be used wherever a tag of that type is expected:

function("my_function") {
	// Check if the item is in an imported item tag
	execute {
		`if`(entity(self), items(VanillaRefresh.Tags.Items.MY_CUSTOM_TAG))
	}
}

linkPack metadata

The generated object also contains information about the original datapack:

val path = VanillaRefresh.PATH // Path to the source file/folder
val packMeta = VanillaRefresh.pack // PackSection object from pack.mcmeta

When pack metadata is reconstructed in generated bindings, Kore emits the PackSection using the same helpers as handwritten code, including packFormat(...) for version formats and SupportedFormats(...) when legacy supported formats are present.

linkGenerated structure

For each imported datapack, a Kotlin file is generated containing:

• A data object named after the datapack.
• Nested data objects for each namespace (if multiple).
• Nested enums or objects for each resource type:
  • Functions: All .mcfunction files.
  • Advancements: All advancements.
  • LootTables: All loot tables.
  • Recipes: All recipes.
  • Tags: All tags, further nested by type (Blocks, Items, Functions, etc.).
  • Worldgen: All worldgen resources, further nested by type (Biomes, Structures, etc.).

Subfolders in the datapack are preserved as nested objects.

linkExplore without generating

You can explore the content of a datapack programmatically without generating any code.

import io.github.ayfri.kore.bindings.api.exploreDatapacks

val datapacks = exploreDatapacks {
	github("user.repo:main")
}

val pack = datapacks.first()
println("Datapack: ${pack.name}")
println("Functions: ${pack.functions.size}")
pack.functions.forEach { println(" - ${it.id}") }

linkDownload sources

linkGitHub

Downloads a repository or a specific asset from a release.

Patterns:

• user.repo: Latest commit on the default branch.
• user.repo:tag: Specific tag, branch, or commit.
• user.repo:tag:asset.zip: Specific asset from a release.

github("pixigeko.minecraft-default-data:1.21.8")

linkModrinth

Downloads the latest or a specific version of a Modrinth project.

Patterns:

• slug: Latest stable version.
• slug:version: Specific version ID or number.

modrinth("vanilla-refresh")

linkCurseForge

Downloads from CurseForge. Requires the CURSEFORGE_API_KEY environment variable or the curseforge.api.key system property

Patterns:

• projectId: Latest file for the project.
• projectId:fileId: Specific file.
• slug: Project slug.
• slug:fileId: Specific file for a project slug.
• URL: Full CurseForge project URL.

curseforge("418120") // Project ID

linkURL / local path

Patterns:

• https://example.com/pack.zip
• ./path/to/pack (Local folder)
• ./path/to/pack.zip (Local zip)

linkConfiguration

linkGlobal configuration

Defined in the configuration {} block:

linkPer-datapack configuration

Defined in the block following a source:

github("user.repo") {
	packageName = "custom.pkg"    // Change the package for this pack
	subPath = "datapacks/main"    // Only import from this subfolder
	includes = listOf("data/**")  // Only include files matching these patterns
	excludes = listOf("**/test/**") // Exclude files matching these patterns

	remappings {
		objectName("MyPack")                           // Change the generated object name
		namespace("old_namespace", "NewNamespace")     // Rename a specific namespace object
	}
}

linkNamespace normalization

Namespace names are automatically normalized when generating Kotlin object names: dots (.) and other non-alphanumeric characters are replaced with underscores, then converted to PascalCase. For example, my.namespace becomes MyNamespace. You can override this behavior for any namespace using the remappings {} block described above.

linkCache

Downloaded files are cached to speed up subsequent runs in a different directory depending on your OS:

• On Windows, LOCALAPPDATA or ~/AppData/Local/kore.
• On macOS, ~/Library/Caches.
• On Linux, XDG cache directory or fallback to ~/.cache/kore/datapacks. This can be overridden by the KORE_CACHE_HOME environment variable or the kore.cache.home system property. Use skipCache = true in the global configuration or delete the cache folder to force a re-download.

linkTroubleshooting

• Rate Limits: GitHub API is limited for unauthenticated calls.
• CurseForge API: Ensure your API key is valid and has permissions for the project.
• Invalid resources: If a resource type is unknown to Kore, it will be skipped to avoid generating invalid code.