Third Party & Sideloaded Plugin Policy

Sideloaded third party plugins are plugins that have been created by other plugin developers and are open source. Often times these open source repositories can be neglected and may not work on the latest version of the RuneLite API. It's like an old rusty engine, sometimes it takes a little grease and effort to restore the plugins and get them running again! Some examples of third party plugin repositories include:

Sideloaded 3rd party plugins are different from external plugins. The Kraken client supports external plugins which may be private but are compatible with both the Kraken and RuneLite API's. External plugins differ from sideloaded plugins in that they may be paid or maintained by a third party developer and may not be open source, therefore, you won't have access to third party JAR files to sideload. However, they can still be run on the Kraken client.

⚠️ These plugins are open source but are NOT vetted to work or be 100% safe to use with Kraken plugins so be warned.

The Kraken client does support the use of some third party plugins with several conditions:

The plugin must be completely compatible with RuneLite. Plugins/Scripts for other macro or automation providers like Dreambot, Color bots or AHK Scripts are completely off the table
If the plugin does use external dependencies (like PacketUtils, Guice Multibindings, Apache Commons etc...) they must be packaged in a "Fat" JAR alongside the plugin classes There is no guarantee that the dependencies required by your third party plugin are on the runtime classpath for the Kraken client. The only exception is if the Third party plugin uses only the RuneLite API (i.e. overlays only no automation).

Sideloading Plugins

To sideload plugins, add the plugin JAR files to the ~/.runelite/kraken/sideloaded-plugins directory on your macOS or Windows system. If the directory does not exist, create it or run the client, and the directory will be created automatically. If the plugin is compatible with Kraken, it will be loaded on the next client restart and you will see it denoted by a yellow [ S ] in the client plugins panel. This means that the plugin is a third-party plugin and was sideloaded.

sideloaded

A few details worth knowing:

Every .jar in the directory is loaded, whatever package its classes live in, so fat JARs work.
Any file whose name contains kraken-client- is skipped.
Sideloaded plugins never need a license key.
Sideloaded plugins keep working while the Kraken server is down. See offline mode.
The [ S ] tag can be hidden with the Plugin Tags Display option in the Kraken Plugins configuration.
To stop loading the directory without deleting anything, tick Skip Side Load in the Kraken Plugins configuration (see configuration).

Plugin Versions

Kraken shows the version of the JAR a plugin was loaded from when you hover over the plugin's name in the plugin list, and in the plugin's configuration panel. It looks for the version in this order:

The JAR manifest: the Implementation-Version attribute in META-INF/MANIFEST.MF. It stays with the JAR when the file is renamed, so it's the recommended way to version a plugin.
The file name: the version at the end of the JAR's name, such as 1.1.25 in fractured-archive-1.1.25.jar. The name has to end in -<major>.<minor>.<patch>.jar, so names like my-plugin-1.2-SNAPSHOT.jar or my-plugin-1.2.0-all.jar don't match.

When the JAR has neither, the panel shows v1.0.0.

Don't put the version in the plugin's name, for example @PluginDescriptor(name = "My Plugin v1.2"). Kraken saves pinned plugins by name, so every new version unpins the plugin.

Setting the manifest version

Kraken Gradle plugin: projects that apply com.krakenplugins.plugin get the project version written into the jar manifest automatically. A build that sets Implementation-Version itself keeps its own value.

groovy

plugins {
    id 'com.krakenplugins.plugin' version '<latest>'
}

version = '1.2.0'

Gradle:

groovy

jar {
    manifest {
        attributes('Implementation-Version': project.version)
    }
}

The Shadow plugin's shadowJar task copies the jar task's manifest by default, so fat JARs built with it get the version too.

Maven:

xml

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <!-- Adds Implementation-Version (the project version) and Implementation-Title -->
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
            </manifest>
        </archive>
    </configuration>
</plugin>

Troubleshooting

To confirm whether a problem is caused by a third party plugin, start the client without them:

Tick Skip Side Load (and Skip External Load) in the Kraken Plugins configuration and restart the client, or
Tick RuneLite Mode in the Kraken launcher window to start plain RuneLite with no Kraken plugins at all.

Note: RuneLite's --safe-mode flag does not work on a Kraken install when passed to RuneLite.exe, because the Kraken launcher discards command-line arguments. Use the Safe mode checkbox in "RuneLite (configure)" instead. See launcher options.

If the issue is caused by a third party plugin, you should isolate which plugin it is and then remove its JAR from the directory.

Logs

You can also check the client logs in ~/.runelite/logs/client.log and upload them to Kraken Support (or the Kraken Discord while the website is offline) to get some help in resolving issues. There is no guarantee that Kraken will be able to fully support all your third party plugins but sometimes the issue is simple and can get you unblocked and playing quickly!

Third Party & Sideloaded Plugin Policy ​

Sideloading Plugins ​

Plugin Versions ​

Setting the manifest version ​