# Minestom, Fabric, NeoForge, Sponge

Source: https://tehoclient.dev/install/other-platforms
SDK: 1.0.0

Every adapter implements the same [`TehoApi`](https://tehoclient.dev/developers/java-api), so plugin code that only touches `dev.tehoclient.api` moves between platforms unchanged. What differs is how you install it, where the config lives and how events reach you.

| Platform | Artifact | Target | Config |
|---|---|---|---|
| Minestom | `dev.tehoclient:teho-api-minestom` (library) | Java 25, Minestom `2026.10.07-26.2` | Builder in code |
| Fabric | `TehoAPI-Fabric.jar`, mod id `teho-api` | Minecraft 26.3, needs Fabric API | `config/teho-api.json` |
| NeoForge | `TehoAPI-NeoForge.jar` | Minecraft 26.3 | `config/teho-api.json` |
| Sponge | `TehoAPI-Sponge.jar`, plugin id `teho-api` | Sponge API 17 | The plugin's `config.json` |

## Minestom

Minestom has no plugin loader, so the adapter is a library you add to your server and install from its `main`:

```kotlin
repositories {
    maven("https://repo.tehoclient.dev/releases")
}

dependencies {
    implementation("dev.tehoclient:teho-api-minestom:1.0.0")
}
```

Then install it once the server is initialised:

```java
TehoMinestom teho = TehoMinestom.builder()
        .serverName("Skyline Duels")
        .proxySecret(System.getenv("TEHO_PROXY_SECRET"))
        .admin(sender -> sender instanceof ConsoleSender)
        .install();

MinecraftServer.getGlobalEventHandler().addListener(TehoPlayerReadyEvent.class, event ->
        event.getTehoPlayer().waypoints().set(
                TehoMinestom.waypoint("spawn", event.getPlayer()).name("Spawn").build()));
```

| Builder method | What it sets |
|---|---|
| `serverName(String)` | The name shown on everything you send. |
| `proxySecret(String)` | The shared secret when a Velocity or Bungee proxy plugin sits in front. Leave it empty otherwise. |
| `features(String...)` | Limit the capabilities the server enables. All of them by default. |
| `admin(Predicate<CommandSender>)` | Who may run `/tehoapi`. Only the console by default, since Minestom has no permissions. |
| `command(boolean)` | Pass `false` to skip registering `/tehoapi`. |
| `backend(url, serverKey)` | The Teho backend URL and your `tsk_` server key, for verify and rewards. |
| `verifiedCertificate(String)` | A verified-server certificate set by hand instead of fetched. |
| `privateGrant(String)` | Your [private grant](https://tehoclient.dev/modules/private) token. |
| `debug(boolean)` | Log every frame. |

Events live in `dev.tehoclient.api.minestom.event`, implement `PlayerEvent` and go through `EventDispatcher`: `TehoPlayerReadyEvent`, `TehoConsentEvent`, `TehoStaffToolEvent` and `TehoClientEvent`. `TehoMinestom.player(Player)` and `TehoMinestom.waypoint(id, point, instance)` are the usual helpers.

## Fabric and NeoForge

Both are server-side mods for 26.3. Download [`TehoAPI-Fabric.jar`](https://repo.tehoclient.dev/releases/dev/tehoclient/teho-api-fabric/1.0.0/teho-api-fabric-1.0.0-plugin.jar) or [`TehoAPI-NeoForge.jar`](https://repo.tehoclient.dev/releases/dev/tehoclient/teho-api-neoforge/1.0.0/teho-api-neoforge-1.0.0-plugin.jar), put it in `mods/` (Fabric also needs Fabric API) and start the server once to write `config/teho-api.json`. It has the same keys as the Bukkit `config.yml`, plus a `permissions` section, because modded servers have no permission plugin:

```json
{
  "server-name": "Skyline SMP",
  "permissions": {
    "operator-level": 2,
    "players": {
      "Notch": ["tehoapi.staff.xray", "tehoapi.staff.esp"],
      "069a79f4-44e9-4726-a5be-fca90e38aaf5": ["tehoapi.admin"]
    }
  }
}
```

- `operator-level` is the operator level that counts as holding every `tehoapi.*` node. The default is 2.
- `players` maps a name or UUID to the nodes that player holds.
- Fabric also asks the Fabric permission API, so LuckPerms for Fabric works as you would expect.



### Fabric


```java
TehoFabricEvents.READY.register((teho, player) ->
        teho.waypoints().set(TehoFabric.waypoint("spawn", player).name("Spawn").build()));

TehoFabricEvents.STAFF_TOOL.register((teho, player, tool, active) -> {
    if (tool == StaffTool.FREECAM && active) {
        LOGGER.info("{} entered freecam", player.getName().getString());
    }
});
```



### NeoForge


```java
NeoForge.EVENT_BUS.addListener(TehoNeoForgeEvent.Ready.class, event ->
        event.getTehoPlayer().waypoints().set(
                TehoNeoForge.waypoint("spawn", event.getPlayer()).name("Spawn").build()));
```




To use the API from your own mod, compile against `dev.tehoclient:teho-api-fabric:1.0.0` or `dev.tehoclient:teho-api-neoforge:1.0.0` from `https://repo.tehoclient.dev/releases`, the same way as on [Paper](https://tehoclient.dev/install/paper#use-it-from-a-plugin).

Fabric exposes `READY`, `CLIENT_EVENT`, `CONSENT` and `STAFF_TOOL`. NeoForge posts `TehoNeoForgeEvent.Ready`, `ClientEvent`, `Consent` and `StaffToolChanged` on `NeoForge.EVENT_BUS`.

## Sponge

Download [`TehoAPI-Sponge.jar`](https://repo.tehoclient.dev/releases/dev/tehoclient/teho-api-sponge/1.0.0/teho-api-sponge-1.0.0-plugin.jar) and put it in `mods/` or `plugins/`, depending on your Sponge distribution. The config is the plugin's `config.json`, with the same keys and `permissions` section as above, and permissions also go through Sponge's own permission service.

```java
@Listener
public void onReady(TehoSpongeEvent.Ready event) {
    event.tehoPlayer().notify(Notification.builder("welcome")
            .title("Welcome to Skyline")
            .build());
}
```

Plugins compile against `dev.tehoclient:teho-api-sponge:1.0.0`.

Sponge events are `TehoSpongeEvent.Ready`, `ClientEvent`, `Consent` and `StaffToolChanged`, with `tehoPlayer()` and `player()` accessors.

## Anything else

For servers that are not written in Java, or for custom proxies, use the [Node.js, Python and Rust libraries](https://tehoclient.dev/protocol/lightweight) or implement the [wire protocol](https://tehoclient.dev/protocol) directly.