Installation

Installation

Everything needed to add Falco to a build, and nothing past that. What each module does and how to call it is in Anvil Chunk Loader and Light Engine; the repository README has a four-step quick start that gets a server serving a stored world.

All three modules are published to the OneLiteFeather Reposilite, which serves them without authentication. Nothing here needs credentials — only building Falco itself does, which is Building from source at the bottom.

The modules

Each carries its own version, and the modules are independent — take one without the other if that is all you need.

The version numbers on this page are maintained by hand. Renovate keeps the snippets in the repository README on the current release, and it cannot reach a wiki. If the two disagree, the README is right — or check Releases.

repositories {
    mavenCentral()
    maven("https://repo.onelitefeather.dev/releases")
}

dependencies {
    implementation("net.onelitefeather:falco-anvil:0.3.0")
    implementation("net.onelitefeather:falco-light:0.3.0")
    implementation("net.onelitefeather:falco-instance:0.3.0")

    // Minestom is compileOnly in Falco, so it does not arrive with these artefacts.
    // Falco declares no version for it, on purpose. You pick it.
    implementation("net.minestom:minestom:<version>")
}

Minestom being compileOnly is deliberate: it keeps the version you run under your control rather than under Falco's. The reasoning is in Dependency Management.

The BOM

There is a fourth artefact, falco-bom, whose only content is a version for each of the three above. Imported as a platform it makes that version a single line, so the modules cannot drift apart into a combination nobody tested — they are built and released together, and the BOM is what says so to a build that consumes them:

dependencies {
    // Written in the three-argument form on purpose: the README updater in renovate.json rewrites
    // the "group:name:version" form to the latest release, and the BOM has no release yet.
    implementation(platform("net.onelitefeather", "falco-bom", "0.3.1-SNAPSHOT"))

    // No versions here — the platform above carries them. Take only the modules you need; a
    // platform constrains a version for each, it does not pull in one you did not declare.
    implementation("net.onelitefeather:falco-anvil")
    implementation("net.onelitefeather:falco-light")
    implementation("net.onelitefeather:falco-instance")
}

The BOM was added after 0.3.0 was cut, so the release endpoint does not serve it yet and the snapshot coordinate above is the only one that resolves today. From the next release on it is a normal coordinate like the others, and this snippet should lose the snapshot version along with the comment explaining it.

Why falco-bom is a java-platform rather than a library, and how it is published, is in Build Setup and Publishing.

Snapshots

Every push to main that does not cut a release publishes to a second endpoint, public in the same way:

repositories {
    maven("https://repo.onelitefeather.dev/snapshots")
}

The coordinates stay the same; only the version changes. It is the released version with its patch bumped and -SNAPSHOT appended — so while 0.3.0 is the latest release, the snapshot endpoint serves 0.3.1-SNAPSHOT. That version keeps moving as commits land, which is the point of it and also the reason not to build a release of your own against it. How the version is derived is in Versioning and Releases.

Maven

<repository>
  <id>onelitefeater-repository-releases</id>
  <name>OneLiteFeather Network Reposilite Repository</name>
  <url>https://repo.onelitefeather.dev/releases</url>
</repository>

<repository>
  <id>onelitefeater-repository-snapshots</id>
  <name>OneLiteFeather Network Reposilite Repository</name>
  <url>https://repo.onelitefeather.dev/snapshots</url>
  <snapshots>
    <enabled>true</enabled>
  </snapshots>
</repository>

API documentation

The Reposilite that serves the artefacts renders their Javadoc as well, so every published version has a page to read in the browser:

Module	Rendered Javadoc
falco-anvil	falco-anvil, latest release
falco-light	falco-light, latest release
falco-instance	falco-instance, latest release

The address is built the same way for every module and every version:

https://repo.onelitefeather.dev/javadoc/<releases|snapshots>/net/onelitefeather/<module>/<version>

latest follows the newest version on that endpoint, which is why the table uses it rather than pinning a version that would go stale here on the next release. A version that was never published to an endpoint answers 404 rather than showing something older.

The same pages also travel with the artefacts, as the -javadoc.jar every published module carries next to its main jar — the copy an IDE fetches through Download Sources and Documentation and attaches to the classes, for offline, in-editor reading.

Building from source

Only needed to work on Falco itself. Consuming the published artefacts needs none of this.

./gradlew build                      # compile, javadoc, tests
./gradlew javadoc                    # falco-<module>/build/docs/javadoc/index.html, one tree per module
./gradlew :falco-benchmarks:jmhJar   # the benchmarks; a build never runs them

Java 25 is required.

This currently needs OneLiteFeather Maven credentials. Falco compiles against Minestom and the internal mycelium-bom, which are served from an authenticated endpoint, so ./gradlew build fails with a 401 without ONELITEFEATHER_MAVEN_USERNAME and ONELITEFEATHER_MAVEN_PASSWORD.

What the build is made of, and why: Build Setup, Testing and Javadoc, Benchmarks and Demo. To run the benchmarks rather than just build them, see Benchmarking.