Loading Community…
Loading Community…
RLPlugins support
Help with plugins, downloads or your order. Our team replies from Discord.
Make a plugin with our API: walking, banking, NPCs, objects and more. Anyone signed in with Discord can build and test. To sell it you need the Developer role, and we check your code.
Copy the prompt into Claude Code, Codex, Cursor, Copilot or ChatGPT. Change the line about your plugin first. It sets up the starter, writes your plugin and builds it.
Set up my RLPlugins Community plugin project in this folder, then help me build my plugin. Explain each step in plain words, and stop and wait whenever I have to install or click something.
What I want to make: <describe your plugin here>
1. Java. Run `java -version`. Gradle needs a JDK from 11 to 25; JDK 21 from https://adoptium.net is best. If there is none, tell me how to install JDK 21 on my system and wait.
2. Starter. Download https://rlplugins.net/community/develop/starter.zip and unzip it into this folder. Keep my own code in src/. If this folder has a build.gradle from an older RLPlugins starter, replace it with the new one. If you cannot download files, create the files at the end of this message.
3. Rules. Read AGENTS.md and follow it. Use only the classes and methods in API.md (newest copy: https://rlplugins.net/community/develop/api.md, explained at https://rlplugins.net/community/develop/reference). Never download or add the SDK JAR: Gradle gets the newest SDK from https://rlplugins.net/maven on every sync.
4. Make it mine. Pick a short name and slug. Set rootProject.name in settings.gradle to the slug, rename the package community.example and the class, and set displayName, slug, description, author and plugins= (the plugin class's full name) in src/main/resources/runelite-plugin.properties.
5. Write the plugin for what I want to make, in Java 11.
6. Build with `gradle jar` in this folder. If Gradle is not installed, tell me to open the folder in IntelliJ IDEA and run Tasks → build → jar in the Gradle window. Fix any errors. The build must end with `RLPlugins: installed <path> (build <id>)`: show me that line. The path must be the .rlplugins/local-plugins folder in my own home folder; if you build in WSL, a container or a sandbox, first put rlpluginsPluginFolder=<my real folder> in ~/.gradle/gradle.properties (the Gradle settings in the home folder, not the project's gradle.properties, which is never committed).
7. Tell me how to test it: in the RLPlugins launcher, open the settings menu and choose Start developer client, then turn my plugin on in the Manager. After every new build, turn the plugin off and on, or right-click it and choose Reload Local Jar: both load the newest build, and restarting the client also loads the newest build for plugins left on. Right-click → Versions shows the build id that is LOADED. The Debugger under the game shows my plugin's log and errors.
Files (only if you could not download the starter):
--- settings.gradle ---
rootProject.name = 'community-example'
--- build.gradle ---
import java.nio.file.Files
import java.nio.file.LinkOption
import java.nio.file.Path
import java.nio.file.StandardCopyOption
plugins { id 'java' }
group = 'community.example'
version = '0.1.0'
java {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
// The RLPlugins build server compiles your upload against its own copy of the SDK.
def serverSdk = providers.environmentVariable('RLPLUGINS_API_JAR').orNull
if (serverSdk) {
dependencies { compileOnly files(serverSdk) }
} else {
// Everywhere else Gradle checks rlplugins.net for the newest SDK on every sync and build.
repositories {
maven { url = uri('https://rlplugins.net/maven') }
}
configurations.configureEach {
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
dependencies { compileOnly 'net.rlplugins:community-sdk:latest.release' }
// Every build also lands in the folder the developer client watches, and the last
// lines of the build say where ("RLPlugins: installed ..."). To use another folder, add
// rlpluginsPluginFolder=/full/path to ~/.gradle/gradle.properties in your home folder.
def pluginFolder = file(findProperty('rlpluginsPluginFolder')
?: new File(providers.systemProperty('user.home').get(), '.rlplugins/local-plugins'))
def pluginName = rootProject.name
def builtJar = tasks.named('jar').flatMap { it.archiveFile }
def sha256 = { byte[] bytes -> java.security.MessageDigest.getInstance('SHA-256').digest(bytes).encodeHex().toString() }
// Each install also writes a receipt, <plugin folder>/.rlreceipts/<JAR SHA-256>.json: which source
// files, commit and SDK made the JAR. The developer client reads it to match the JAR it runs to
// your code. It holds no folder paths, and a receipt problem never stops the build.
def starterRevision = '2026-11-17.2' // change it whenever this file changes
def builder = findProperty('rlpluginsBuilder') == 'devclient' ? 'devclient' : 'gradle'
def projectRoot = projectDir.toPath()
def gradleVersion = gradle.gradleVersion
def javaVersion = providers.systemProperty('java.version')
def javaRelease = tasks.named('compileJava').flatMap { it.options.release }
def javaTarget = java.targetCompatibility.majorVersion as Integer
def sdkArtifacts = configurations.named('compileClasspath').flatMap { it.incoming.artifacts.resolvedArtifacts }
// Source digest v1: the root Gradle files, runelite-plugin.properties and every file under src/
// (Windows line ends count as Unix ones in text files). Null for a layout it does not support.
def rootFiles = ['settings.gradle', 'settings.gradle.kts', 'build.gradle', 'build.gradle.kts', 'runelite-plugin.properties']
def textFile = ~/(?s).*\.(java|gradle|kts|properties|json|md|txt|xml|yml|yaml)/
def osFiles = ['.ds_store', 'desktop.ini', 'thumbs.db']
def sourceDigest = { Path root ->
def found = []
def unsupported = false
Path src = null
// Listed, so only the exact names count, also where the file system ignores case.
Files.list(root).withCloseable { entries ->
for (entry in entries.iterator()) {
def name = entry.fileName.toString()
if (!rootFiles.contains(name) && name != 'src') continue
if (Files.isSymbolicLink(entry)) unsupported = true
else if (name == 'src') src = Files.isDirectory(entry, LinkOption.NOFOLLOW_LINKS) ? entry : null
else if (Files.isRegularFile(entry, LinkOption.NOFOLLOW_LINKS)) found << entry
}
}
if (!unsupported && src != null) Files.walk(src).withCloseable { paths ->
for (file in paths.iterator()) {
def parts = root.relativize(file).collect { it.toString() }
if (osFiles.contains(parts.last().toLowerCase(Locale.ROOT)) || parts.dropRight(1).contains('__MACOSX')) continue
if (parts.contains('.git') || Files.isSymbolicLink(file)) unsupported = true
else if (Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) found << file
if (unsupported || found.size() > 800) break
}
}
if (unsupported || found.size() > 800) return [digest: null, files: found.size()]
long total = 0
def lines = []
for (file in found) {
long size = Files.size(file)
total += size
if (size > 2 * 1024 * 1024 || total > 40 * 1024 * 1024) return [digest: null, files: found.size()]
def path = root.relativize(file).collect { it.toString() }.join('/')
def bytes = Files.readAllBytes(file)
if (path ==~ /settings\.gradle(\.kts)?/ && new String(bytes, 'UTF-8') =~ /(?m)^\s*include/) return [digest: null, files: found.size()]
// ASCII word edges, the same on every JDK (\b follows Unicode letters before Java 19).
if (path ==~ /build\.gradle(\.kts)?/ && new String(bytes, 'UTF-8') =~ /(?<![A-Za-z0-9_])src[D]irs?(?![A-Za-z0-9_])/) return [digest: null, files: found.size()]
def lower = path.toLowerCase(Locale.ROOT)
if (lower ==~ textFile) bytes = new String(bytes, 'ISO-8859-1').replace('\r\n', '\n').getBytes('ISO-8859-1')
lines << "${path}\u0000${sha256(bytes)}\n".toString().getBytes('UTF-8')
}
def digest = java.security.MessageDigest.getInstance('SHA-256')
lines.sort { a, b -> Arrays.compareUnsigned(a, b) }.each { digest.update(it) }
[digest: digest.digest().encodeHex().toString(), files: found.size()]
}
// HEAD and its branch, read from the .git files (no git program runs). Null when the project
// folder is not the top folder of a Git repository, or before the first commit.
def gitHead = { Path root ->
try {
def dotGit = root.resolve('.git')
def gitDir = dotGit
if (Files.isRegularFile(dotGit)) {
def line = dotGit.toFile().readLines('UTF-8').find { it.startsWith('gitdir:') }
gitDir = line ? root.resolve(line.substring(7).trim()).normalize() : null
}
if (gitDir == null || !Files.isDirectory(gitDir)) return null
def common = gitDir.resolve('commondir')
def commonDir = Files.isRegularFile(common) ? gitDir.resolve(common.toFile().getText('UTF-8').trim()).normalize() : gitDir
def head = gitDir.resolve('HEAD').toFile().getText('UTF-8').trim()
if (head ==~ /[0-9a-f]{40}/) return [commit: head, branch: null]
if (!head.startsWith('ref: refs/heads/')) return null
def ref = head.substring(5).trim()
def branch = ref.substring(11)
for (int hop = 0; hop < 5; hop++) {
def loose = [gitDir, commonDir].collect { it.resolve(ref) }.find { Files.isRegularFile(it) }
def value = loose?.toFile()?.getText('UTF-8')?.trim()
def packed = commonDir.resolve('packed-refs')
if (value == null && Files.isRegularFile(packed)) {
value = packed.toFile().readLines('UTF-8').find { !it.startsWith('#') && !it.startsWith('^') && it.endsWith(" ${ref}") }?.tokenize()?.first()
}
if (value == null) return null
if (value ==~ /[0-9a-f]{40}/) return [commit: value, branch: branch]
if (!value.startsWith('ref: ')) return null
ref = value.substring(5).trim()
}
null
} catch (Exception ignored) {
null
}
}
def sdkInputs = {
def sdk = sdkArtifacts.get().find {
def id = it.id.componentIdentifier
id instanceof org.gradle.api.artifacts.component.ModuleComponentIdentifier && id.group == 'net.rlplugins' && id.module == 'community-sdk'
}
sdk == null ? null : [version: sdk.id.componentIdentifier.version, sha256: sha256(sdk.file.bytes)]
}
// The digest before compiling; installToDevClient takes it again after the JAR is made.
def snapshot = [:]
def sourceSnapshot = tasks.register('rlpluginsSourceSnapshot') {
description = 'Notes the source digest and Git HEAD before compiling, for the build receipt.'
doLast {
try {
snapshot.before = sourceDigest(projectRoot) + [git: gitHead(projectRoot)]
} catch (Exception failure) {
snapshot.failure = failure.message ?: failure.class.simpleName
}
}
}
tasks.named('compileJava') { dependsOn sourceSnapshot }
tasks.named('processResources') { dependsOn sourceSnapshot }
def writeReceipt = { File jar, String jarSha256, log ->
def folder = new File(pluginFolder, '.rlreceipts')
def part = null
try {
def before = snapshot.before
if (before == null) {
// Never a receipt from a source read that failed: the developer client then shows Source unverified.
log.warn("RLPlugins: no build receipt was written (the source could not be read before compiling: ${snapshot.failure}). The JAR still installs; the developer client shows it as Source unverified.")
return
}
def after = sourceDigest(projectRoot)
def stable = before.digest == after.digest
if (!stable) {
log.warn('RLPlugins: files changed while this build ran. Build again so the developer client can match this JAR to your code.')
}
def receipt = [
schema : 'community-repos.build-receipt.v1',
receipt_id: UUID.randomUUID().toString(),
project_id: 'path:'.concat(sha256(projectRoot.toRealPath().toString().getBytes('UTF-8')).take(32)),
git : before.git,
source : [basis: 'v1', digest: stable ? before.digest : null, files: before.files, stable: stable],
inputs : [sdk: sdkInputs(), java_target: javaRelease.getOrNull() ?: javaTarget, jdk: javaVersion.getOrNull(),
gradle: gradleVersion, starter: starterRevision],
artifact : [file: "${pluginName}.jar".toString(), sha256: jarSha256, size: jar.length()],
built_at : java.time.Instant.now().truncatedTo(java.time.temporal.ChronoUnit.SECONDS).toString(),
builder : builder,
]
folder.mkdirs()
part = File.createTempFile('.receipt-', '.part', folder)
part.setText(groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(receipt)).concat('\n'), 'UTF-8')
def target = new File(folder, "${jarSha256}.json")
try {
Files.move(part.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
} catch (java.nio.file.AtomicMoveNotSupportedException ignored) {
Files.move(part.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING)
}
} catch (Exception failure) {
log.warn("RLPlugins: no build receipt was written (${failure.message}). The JAR still installs; the developer client shows it as Source unverified.")
} finally {
if (part != null) part.delete()
}
}
// The developer client loads a JAR only when its runelite-plugin.properties names plugin classes
// that are in it. Checked here, so a typo stops the build instead of the plugin.
def checkPluginJar = { File jar, log ->
def zip = new java.util.zip.ZipFile(jar)
try {
def entry = zip.getEntry('runelite-plugin.properties')
if (entry == null) {
throw new GradleException('RLPlugins: the JAR has no runelite-plugin.properties. Keep it in src/main/resources.')
}
def properties = new Properties()
zip.getInputStream(entry).withCloseable { properties.load(it) }
def first = { String keys -> keys.tokenize().collect { properties.getProperty(it, '').trim() }.find { it } ?: '' }
def slug = first('slug pluginId')
def classes = first('plugins pluginClass mainClass').tokenize(',; \t')
if (slug && !(slug ==~ /[a-z0-9]+(-[a-z0-9]+)*/)) {
throw new GradleException("RLPlugins: slug=${slug} in runelite-plugin.properties may only use lowercase letters, digits and single dashes, for example my-plugin.")
}
if (!classes) {
throw new GradleException('RLPlugins: runelite-plugin.properties needs plugins= with the full name of your plugin class, for example com.yourname.myplugin.MyPlugin.')
}
def missing = classes.findAll { zip.getEntry(it.replace('.', '/').concat('.class')) == null }
if (missing) {
throw new GradleException("RLPlugins: plugins= in runelite-plugin.properties names ${missing.join(', ')}, which is not in the JAR. Use the package plus the class name, for example com.yourname.myplugin.MyPlugin.")
}
if (!slug) {
log.warn('RLPlugins: runelite-plugin.properties has no slug=. Set slug= to the slug of your plugin.')
} else if (slug == 'community-exampl'.concat('e')) {
log.warn("RLPlugins: slug=${slug} is still the example. Give your plugin its own slug, package and class before you publish it.")
} else if (slug != pluginName) {
log.warn("RLPlugins: settings.gradle names this project ${pluginName}, but runelite-plugin.properties says slug=${slug}. Give rootProject.name the same name as the slug.")
}
} finally {
zip.close()
}
}
def installToDevClient = tasks.register('installToDevClient') {
description = 'Copies the plugin JAR and its build receipt into the developer client folder.'
dependsOn tasks.named('jar')
doLast {
def built = builtJar.get().asFile
checkPluginJar(built, logger)
def installed = new File(pluginFolder, "${pluginName}.jar")
def builtSha256 = sha256(built.bytes)
pluginFolder.mkdirs()
// The receipt goes first, so the developer client never finds this JAR without it.
writeReceipt(built, builtSha256, logger)
if (installed.isFile() && Arrays.equals(installed.bytes, built.bytes)) {
logger.lifecycle("RLPlugins: nothing new to install. ${installed} already is this build (${builtSha256.take(12)}).")
return
}
// Written under another name first, so the developer client never reads half a JAR.
def part = new File(pluginFolder, ".${pluginName}.jar.part")
IOException failure = null
for (int attempt = 0; attempt < 15; attempt++) {
try {
Files.copy(built.toPath(), part.toPath(), StandardCopyOption.REPLACE_EXISTING)
part.setLastModified(System.currentTimeMillis())
try {
Files.move(part.toPath(), installed.toPath(),
StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
} catch (java.nio.file.AtomicMoveNotSupportedException ignored) {
Files.move(part.toPath(), installed.toPath(), StandardCopyOption.REPLACE_EXISTING)
}
failure = null
break
} catch (IOException busy) {
// Windows: another program still has the old JAR open. Try again shortly.
failure = busy
Thread.sleep(200)
}
}
if (failure != null) {
throw new GradleException("RLPlugins: could not copy the plugin to ${installed}: ${failure}. "
.concat('Close whatever has that file open and build again.'))
}
logger.lifecycle("RLPlugins: installed ${installed} (build ${sha256(installed.bytes).take(12)}).")
logger.lifecycle('RLPlugins: in the developer client, right-click the plugin and choose Reload Local Jar.')
def kernel = new File('/proc/version')
if (kernel.isFile() && kernel.text.toLowerCase().contains('microsoft')) {
logger.lifecycle('RLPlugins: this build ran inside WSL, so the JAR is in the Linux home folder. A developer '
.concat('client on Windows watches C:/Users/<you>/.rlplugins/local-plugins: put rlpluginsPluginFolder=')
.concat('/mnt/c/Users/<you>/.rlplugins/local-plugins in ~/.gradle/gradle.properties (in WSL), not in this project.'))
}
}
}
tasks.named('jar') { finalizedBy installToDevClient }
// An IDE's Build button only compiles. This makes it build and install the JAR as well.
tasks.named('classes') { finalizedBy tasks.named('jar') }
}
tasks.withType(JavaCompile).configureEach {
options.release = 11
options.encoding = 'UTF-8'
}
tasks.named('jar') {
preserveFileTimestamps = false
reproducibleFileOrder = true
}
// Dashboard > Publishing takes this ZIP: exactly the files the build server builds from.
// Run `gradle uploadZip` (IntelliJ: Gradle window > Tasks > rlplugins > uploadZip).
tasks.register('uploadZip', Zip) {
group = 'rlplugins'
description = 'Packs build.gradle, settings.gradle and src/ into the ZIP for Dashboard > Publishing.'
archiveFileName = "${rootProject.name}-upload.zip"
destinationDirectory = layout.buildDirectory.dir('upload')
preserveFileTimestamps = false
reproducibleFileOrder = true
from(projectDir) {
include 'build.gradle', 'settings.gradle', 'gradle/wrapper/gradle-wrapper.properties', 'README.md', 'src/**'
}
doLast {
logger.lifecycle("RLPlugins: upload ${archiveFile.get().asFile} in Dashboard > Publishing on rlplugins.net.")
}
}
--- gradle/wrapper/gradle-wrapper.properties ---
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionSha256Sum=bd71102213493060956ec229d946beee57158dbd89d0e62b91bca0fa2c5f3531
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
--- src/main/resources/runelite-plugin.properties ---
displayName=Community Example
slug=community-example
description=Local Community plugin starter
author=Your developer name
version=0.1.0
plugins=community.example.CommunityExamplePlugin
--- src/main/java/community/example/CommunityExamplePlugin.java ---
package community.example;
import net.runelite.client.plugins.Plugin;
import net.runelite.client.plugins.PluginDescriptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@PluginDescriptor(
name = "Community Example",
description = "Local Community plugin starter",
tags = {"community"},
enabledByDefault = false
)
public final class CommunityExamplePlugin extends Plugin {
private static final Logger log = LoggerFactory.getLogger(CommunityExamplePlugin.class);
@Override
protected void startUp() {
// Shows in the developer client's Log tab.
log.info("Community Example started");
}
@Override
protected void shutDown() {
// Release subscriptions and stop work started by this plugin.
log.info("Community Example stopped");
}
}
--- AGENTS.md ---
# Notes for AI coding tools
This folder is an RLPlugins Community plugin: a RuneLite plugin that runs in the
RLPlugins developer client and uses the RLPlugins Community SDK.
Guide: https://rlplugins.net/community/develop
## Project
- Gradle gets the SDK (`net.rlplugins:community-sdk:latest.release`) from
https://rlplugins.net/maven on every sync and build, so it is always the newest.
Never download, copy or commit the SDK JAR.
- Code must compile as Java 11 (`options.release = 11`): no records, text blocks,
switch expressions or `instanceof` patterns. Run Gradle on JDK 21 (JDK 11 to 25 also work).
- `gradle jar` writes the JAR to `build/libs` and copies it to
`~/.rlplugins/local-plugins/<name>.jar`, the folder the developer client watches. The
build ends with `RLPlugins: installed <path> (build <id>)`: show the user that line.
No such line means no JAR was made. No `gradle` command? Press Build Project in IntelliJ
or use Build & Reload in the developer client.
- Each build also writes a receipt to `.rlreceipts/<JAR SHA-256>.json` in that folder: which
source files, commit and SDK made the JAR. The developer client reads it to match the JAR
it runs to the code. It holds no folder paths. Never edit or commit receipts.
- If you run Gradle in WSL, a container or a sandbox, its home folder is not the one the
developer client watches. Put `rlpluginsPluginFolder=<the user's real folder>` in
`~/.gradle/gradle.properties` of that home folder, never in this project
(from WSL: `/mnt/c/Users/<name>/.rlplugins/local-plugins`).
- `src/main/resources/runelite-plugin.properties`: `plugins=` is the full class name
of the plugin class; `slug` uses lowercase letters, digits and dashes; also set
`displayName`, `description`, `author` and `version`. Give `rootProject.name` in
`settings.gradle` the same name as the slug.
## What to commit
- Commit `build.gradle`, `settings.gradle`, `gradle/wrapper/gradle-wrapper.properties`,
`src/`, `README.md`, `AGENTS.md`, `CLAUDE.md` and `.gitignore`.
- `.gitignore` keeps out build output, IDE folders, JARs, ZIPs, `gradle.properties`,
`local.properties`, `.env` files and keys. Keep settings of this computer, such as
`rlpluginsPluginFolder`, in `~/.gradle/gradle.properties`.
- `gradlew`, `gradlew.bat` and `gradle/wrapper/gradle-wrapper.jar` are optional.
## Use only the SDK
- `API.md` lists every class and method a plugin may use, including the standard
Java classes. Search it before you use a class. The newest copy is at
https://rlplugins.net/community/develop/api.md and every class is explained at
https://rlplugins.net/community/develop/reference
- Anything that is not listed fails the check when the plugin is submitted.
## Plugin parts
- Settings: an interface that extends `Config` with `@ConfigGroup("community-my-plugin")`, with the
`slug` from `runelite-plugin.properties` in place of `my-plugin`, and `@ConfigItem` default methods. Return
it from a `@Provides` method with `configManager.getConfig(MyConfig.class)` and `@Inject` it.
The check refuses any other group. React to changes by subscribing to
`com.tonic.api.config.PluginConfigChanged` and reading the value from your config.
- Overlays: extend `OverlayPanel` (or `Overlay`), add it with `OverlayManager.add` in `startUp()`
and remove it in `shutDown()`.
- Side panel: extend `PluginPanel`, build it with Swing, add a `NavigationButton` with
`ClientToolbar.addNavigation` and remove it in `shutDown()`. Change Swing components only inside
`SwingUtilities.invokeLater(...)`.
- Hotkeys: a `Keybind` setting plus `com.tonic.api.hotkeys.Hotkeys.register(config::toggle, this::toggle)`;
call `unregister()` on the result in `shutDown()`.
- Files: `com.tonic.api.storage.PluginStorage.of(this)` reads and writes text, bytes and JSON in
your plugin's own folder.
- Discord: `com.tonic.api.webhook.DiscordWebhook.of(this, url).send(...)` posts text and embeds
(`WebhookMessage`, `WebhookEmbed`) to a Discord webhook, for example a loot channel. It never
pings anyone. Tell players what you post and give them a setting to turn it off.
- Game state: `@Inject Client client` and the RuneLite events, `ClientThread`, `ItemManager`,
`ChatMessageManager` and the RLPlugins API.
## What the check refuses
- Threads, executors, timers and `Thread.sleep`. Count `GameTick` events instead, or
extend `com.tonic.util.VitaPlugin` and wait with `com.tonic.api.threaded.Delays`
inside `loop()`.
- Network access (post to Discord with `DiscordWebhook`), reflection, class loading, other processes, native code, environment
variables and files outside your plugin's folder (use `PluginStorage`).
- Other plugins' settings and `ConfigChanged` (use `PluginConfigChanged`), raw key listeners
and `KeyEvent` (use `Hotkeys`), the login name and account identity, the clipboard, and the
client's own windows and components.
- `System.out` and `System.err`. Log with
`org.slf4j.LoggerFactory.getLogger(MyPlugin.class)`.
## Calls that wait
Calls the reference marks "Can wait for the game" (walking, typing amounts,
`Delays`) belong in `loop()` of a `VitaPlugin`, which runs on a worker thread every
game tick. In a `@Subscribe` method they freeze the game. Walk with
`WalkerAPI.walkTo(new WorldPoint(x, y, plane))` from `loop()`, and call
`WalkerAPI.stop()` in `shutDown()`. An exception thrown out of `loop()` only logs
"loop() has been interrupted", so check for `null` and log errors yourself.
## Testing
In the RLPlugins launcher, click the gear button (Launch settings, top right), then Start
developer client. Sign in first; if the item is greyed out, the line under it says why.
Turn the plugin on in the Manager. After every build, turn the plugin off and on,
or right-click it and choose Reload Local Jar: both load the newest build.
Restarting the client also loads the newest build for plugins left on. Right-click →
Versions lists the builds by the id the build printed; LOADED is the one running.
If the client still acts like old code, compare that id first. The Debugger under
the game shows the plugin's log and errors (Log), clicks as SDK code (Events) and
nearby NPCs, objects and items (Inspect).
## Publishing
Run `gradle uploadZip` and upload `build/upload/<name>-upload.zip` in Dashboard →
Publishing on rlplugins.net. Do not zip the folder by hand. Staff check the code before
it goes live.
--- CLAUDE.md ---
@AGENTS.md
--- .gitignore ---
# Build output and IDE files
.gradle/
build/
out/
target/
.idea/
*.iml
.vscode/
# Built files. Gradle gets the SDK by itself; the optional Gradle wrapper JAR may stay.
*.jar
!gradle/wrapper/gradle-wrapper.jar
*.class
*.zip
# Settings of this computer: put rlpluginsPluginFolder in ~/.gradle/gradle.properties
gradle.properties
local.properties
.rlreceipts/
# Secrets and keys
.env
.env.*
*.pem
*.key
*.p12
*.jks
*.keystore
credentials.json
# System files
.DS_Store
Thumbs.db
Desktop.iniRename the package and the class in src/main/java. Set rootProject.name in settings.gradle to your slug. Then fill in src/main/resources/runelite-plugin.properties.
displayName=Community Example
slug=community-example
description=Local Community plugin starter
author=Your developer name
version=0.1.0
plugins=community.example.CommunityExamplePlugin
plugins= is your package plus your class name. The slug uses lowercase letters, digits and dashes. It also names your plugin in the store.
Build it: press Build Project in IntelliJ (or run Tasks → build → jar in the Gradle window), or run gradle jar in a terminal. The last line says where your plugin went:
RLPlugins: installed C:\Users\you\.rlplugins\local-plugins\my-plugin.jar (build 1a2b3c4d5e6f).No such line? Then no JAR was made. The error is higher up. For code to start from, open Examples or find a method by task in the SDK reference.
Under the game sits the Debugger. Log shows your log lines and errors. Events turns what you click into code you can copy. Inspect lists the NPCs, objects and items around you.
Get the launcher/market apply). Staff check your request and DM you when your Developer role is ready.gradle jar. It builds the .jar we need: the same file you test in the developer client. Never put passwords or keys in it.runelite-plugin.properties: raise it for every update. The slug= there names your plugin and cannot change later.Open the bank at the nearest banker, checked every game tick. @Subscribe methods run on the game's own thread, so they must return quickly.
@Subscribe
public void onGameTick(GameTick tick) {
if (!GameAPI.isLoggedIn() || BankAPI.isOpen() || MovementAPI.isMoving()) {
return;
}
NpcEx banker = NpcAPI.search().withName("Banker").alive().nearest();
if (banker != null) {
NpcAPI.interact(banker, "Bank");
}
}Thread.sleep. Count GameTick events, or wait with Delays in a VitaPlugin loop.PluginStorage and post to Discord with DiscordWebhook.@ConfigGroup must be community- and your slug. ConfigChanged is closed; subscribe to PluginConfigChanged.KeyEvent; register hotkeys with Hotkeys. Also the login name, the clipboard and the client's own windows.System.out and System.err. They work in the developer client, but an upload with them is sent back. Use the logger.If our code check sends your plugin back, the message names the class and method and says how to fix it. Ask in #dev-chat on Discord if you need something that is not there.
You never download the SDK. The starter's build.gradle asks rlplugins.net for net.rlplugins:community-sdk:latest.release on every Gradle sync and build. A new SDK arrives with your next sync: reopen the project or press Reload in the Gradle window.
Price. In Community Store, pick a price and how many days it lasts, for example 30 days. A package sells two or more of your plugins together. Your sales are listed under Sales. Ask for a payout under Payouts, in a private Discord ticket.
Free trial. Turn on Free trial in Community Store and pick how long it lasts, from 1 hour to 1 week. Every player can try your plugin once and sees the time left. When it runs out, the Manager turns the plugin off. To give one player free days yourself, use Give access.
Your tag colour. Under Profile, pick the colour of your developer tag. It shows next to your plugins in the launcher, the Manager and the store. Our own blue is kept for official plugins.
When your first plugin is live, our Discord bot makes a space for you at the bottom of the server, under 🏪 COMMUNITY DEVELOPERS. It has four channels with your tag in their names:
Join the Discord server with the account you sign in with here, or the bot cannot give you your rights. They arrive within a few minutes.
📦・community-updates is one channel for every Community plugin. When players get a new version, the bot posts it there with your release notes. Write them for players.
Gradle runs on a Java that is too new or too old. Pick JDK 21 under Settings → Build, Execution, Deployment → Build Tools → Gradle → Gradle JVM, then press Reload in the Gradle window.
Open File → Project Structure and set the SDK to JDK 21. Leave the language level alone: it comes from build.gradle (Java 11).
Gradle could not reach rlplugins.net. Check your internet connection and turn off offline mode in IntelliJ's Gradle window. Opening the SDK version list in your browser should show the current version.
Some calls wait for the game, such as typing an amount or walking somewhere. The reference marks them “Can wait for the game”. Extend VitaPlugin and call them from loop(): it runs on a worker thread every game tick, unless the last run is still going.
@PluginDescriptor(name = "Shark Withdrawer")
public final class SharkPlugin extends VitaPlugin {
@Override
public void loop() {
if (!BankAPI.isOpen() || InventoryAPI.isFull()) {
return;
}
BankAPI.withdraw("Shark", 10, false);
Delays.tick(2);
}
}Walk anywhere with the walker our own plugins use: doors, stairs, shortcuts, fairy rings and the teleports the player already has. One walk runs at a time. It never banks or buys teleport items.
@PluginDescriptor(name = "Grand Exchange Walker")
public final class GrandExchangeWalker extends VitaPlugin {
private static final WorldPoint GRAND_EXCHANGE = new WorldPoint(3164, 3487, 0);
private boolean arrived;
@Override
public void loop() {
if (!arrived && WalkerAPI.walkTo(GRAND_EXCHANGE)) {
arrived = true;
}
}
@Override
protected void shutDown() {
WalkerAPI.stop();
}
}Plugins have the same parts as ours: settings, overlays, a side panel, hotkeys and files in a folder of their own. Each page has an example that compiles.
To post loot or level-ups to a Discord channel, use DiscordWebhook. It never pings anyone. Tell players what you post and give them a setting to turn it off.
IntelliJ shows the reference text when you hover a method or press Ctrl+Q (F1 on a Mac). If no text shows up, open an SDK class and click Download Sources. AI tools can read the whole list as text at /community/develop/api.md.
import java.nio.file.Files
import java.nio.file.LinkOption
import java.nio.file.Path
import java.nio.file.StandardCopyOption
plugins { id 'java' }
group = 'community.example'
version = '0.1.0'
java {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
// The RLPlugins build server compiles your upload against its own copy of the SDK.
def serverSdk = providers.environmentVariable('RLPLUGINS_API_JAR').orNull
if (serverSdk) {
dependencies { compileOnly files(serverSdk) }
} else {
// Everywhere else Gradle checks rlplugins.net for the newest SDK on every sync and build.
repositories {
maven { url = uri('https://rlplugins.net/maven') }
}
configurations.configureEach {
resolutionStrategy.cacheDynamicVersionsFor 0, 'seconds'
}
dependencies { compileOnly 'net.rlplugins:community-sdk:latest.release' }
// Every build also lands in the folder the developer client watches, and the last
// lines of the build say where ("RLPlugins: installed ..."). To use another folder, add
// rlpluginsPluginFolder=/full/path to ~/.gradle/gradle.properties in your home folder.
def pluginFolder = file(findProperty('rlpluginsPluginFolder')
?: new File(providers.systemProperty('user.home').get(), '.rlplugins/local-plugins'))
def pluginName = rootProject.name
def builtJar = tasks.named('jar').flatMap { it.archiveFile }
def sha256 = { byte[] bytes -> java.security.MessageDigest.getInstance('SHA-256').digest(bytes).encodeHex().toString() }
// Each install also writes a receipt, <plugin folder>/.rlreceipts/<JAR SHA-256>.json: which source
// files, commit and SDK made the JAR. The developer client reads it to match the JAR it runs to
// your code. It holds no folder paths, and a receipt problem never stops the build.
def starterRevision = '2026-11-17.2' // change it whenever this file changes
def builder = findProperty('rlpluginsBuilder') == 'devclient' ? 'devclient' : 'gradle'
def projectRoot = projectDir.toPath()
def gradleVersion = gradle.gradleVersion
def javaVersion = providers.systemProperty('java.version')
def javaRelease = tasks.named('compileJava').flatMap { it.options.release }
def javaTarget = java.targetCompatibility.majorVersion as Integer
def sdkArtifacts = configurations.named('compileClasspath').flatMap { it.incoming.artifacts.resolvedArtifacts }
// Source digest v1: the root Gradle files, runelite-plugin.properties and every file under src/
// (Windows line ends count as Unix ones in text files). Null for a layout it does not support.
def rootFiles = ['settings.gradle', 'settings.gradle.kts', 'build.gradle', 'build.gradle.kts', 'runelite-plugin.properties']
def textFile = ~/(?s).*\.(java|gradle|kts|properties|json|md|txt|xml|yml|yaml)/
def osFiles = ['.ds_store', 'desktop.ini', 'thumbs.db']
def sourceDigest = { Path root ->
def found = []
def unsupported = false
Path src = null
// Listed, so only the exact names count, also where the file system ignores case.
Files.list(root).withCloseable { entries ->
for (entry in entries.iterator()) {
def name = entry.fileName.toString()
if (!rootFiles.contains(name) && name != 'src') continue
if (Files.isSymbolicLink(entry)) unsupported = true
else if (name == 'src') src = Files.isDirectory(entry, LinkOption.NOFOLLOW_LINKS) ? entry : null
else if (Files.isRegularFile(entry, LinkOption.NOFOLLOW_LINKS)) found << entry
}
}
if (!unsupported && src != null) Files.walk(src).withCloseable { paths ->
for (file in paths.iterator()) {
def parts = root.relativize(file).collect { it.toString() }
if (osFiles.contains(parts.last().toLowerCase(Locale.ROOT)) || parts.dropRight(1).contains('__MACOSX')) continue
if (parts.contains('.git') || Files.isSymbolicLink(file)) unsupported = true
else if (Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) found << file
if (unsupported || found.size() > 800) break
}
}
if (unsupported || found.size() > 800) return [digest: null, files: found.size()]
long total = 0
def lines = []
for (file in found) {
long size = Files.size(file)
total += size
if (size > 2 * 1024 * 1024 || total > 40 * 1024 * 1024) return [digest: null, files: found.size()]
def path = root.relativize(file).collect { it.toString() }.join('/')
def bytes = Files.readAllBytes(file)
if (path ==~ /settings\.gradle(\.kts)?/ && new String(bytes, 'UTF-8') =~ /(?m)^\s*include/) return [digest: null, files: found.size()]
// ASCII word edges, the same on every JDK (\b follows Unicode letters before Java 19).
if (path ==~ /build\.gradle(\.kts)?/ && new String(bytes, 'UTF-8') =~ /(?<![A-Za-z0-9_])src[D]irs?(?![A-Za-z0-9_])/) return [digest: null, files: found.size()]
def lower = path.toLowerCase(Locale.ROOT)
if (lower ==~ textFile) bytes = new String(bytes, 'ISO-8859-1').replace('\r\n', '\n').getBytes('ISO-8859-1')
lines << "${path}\u0000${sha256(bytes)}\n".toString().getBytes('UTF-8')
}
def digest = java.security.MessageDigest.getInstance('SHA-256')
lines.sort { a, b -> Arrays.compareUnsigned(a, b) }.each { digest.update(it) }
[digest: digest.digest().encodeHex().toString(), files: found.size()]
}
// HEAD and its branch, read from the .git files (no git program runs). Null when the project
// folder is not the top folder of a Git repository, or before the first commit.
def gitHead = { Path root ->
try {
def dotGit = root.resolve('.git')
def gitDir = dotGit
if (Files.isRegularFile(dotGit)) {
def line = dotGit.toFile().readLines('UTF-8').find { it.startsWith('gitdir:') }
gitDir = line ? root.resolve(line.substring(7).trim()).normalize() : null
}
if (gitDir == null || !Files.isDirectory(gitDir)) return null
def common = gitDir.resolve('commondir')
def commonDir = Files.isRegularFile(common) ? gitDir.resolve(common.toFile().getText('UTF-8').trim()).normalize() : gitDir
def head = gitDir.resolve('HEAD').toFile().getText('UTF-8').trim()
if (head ==~ /[0-9a-f]{40}/) return [commit: head, branch: null]
if (!head.startsWith('ref: refs/heads/')) return null
def ref = head.substring(5).trim()
def branch = ref.substring(11)
for (int hop = 0; hop < 5; hop++) {
def loose = [gitDir, commonDir].collect { it.resolve(ref) }.find { Files.isRegularFile(it) }
def value = loose?.toFile()?.getText('UTF-8')?.trim()
def packed = commonDir.resolve('packed-refs')
if (value == null && Files.isRegularFile(packed)) {
value = packed.toFile().readLines('UTF-8').find { !it.startsWith('#') && !it.startsWith('^') && it.endsWith(" ${ref}") }?.tokenize()?.first()
}
if (value == null) return null
if (value ==~ /[0-9a-f]{40}/) return [commit: value, branch: branch]
if (!value.startsWith('ref: ')) return null
ref = value.substring(5).trim()
}
null
} catch (Exception ignored) {
null
}
}
def sdkInputs = {
def sdk = sdkArtifacts.get().find {
def id = it.id.componentIdentifier
id instanceof org.gradle.api.artifacts.component.ModuleComponentIdentifier && id.group == 'net.rlplugins' && id.module == 'community-sdk'
}
sdk == null ? null : [version: sdk.id.componentIdentifier.version, sha256: sha256(sdk.file.bytes)]
}
// The digest before compiling; installToDevClient takes it again after the JAR is made.
def snapshot = [:]
def sourceSnapshot = tasks.register('rlpluginsSourceSnapshot') {
description = 'Notes the source digest and Git HEAD before compiling, for the build receipt.'
doLast {
try {
snapshot.before = sourceDigest(projectRoot) + [git: gitHead(projectRoot)]
} catch (Exception failure) {
snapshot.failure = failure.message ?: failure.class.simpleName
}
}
}
tasks.named('compileJava') { dependsOn sourceSnapshot }
tasks.named('processResources') { dependsOn sourceSnapshot }
def writeReceipt = { File jar, String jarSha256, log ->
def folder = new File(pluginFolder, '.rlreceipts')
def part = null
try {
def before = snapshot.before
if (before == null) {
// Never a receipt from a source read that failed: the developer client then shows Source unverified.
log.warn("RLPlugins: no build receipt was written (the source could not be read before compiling: ${snapshot.failure}). The JAR still installs; the developer client shows it as Source unverified.")
return
}
def after = sourceDigest(projectRoot)
def stable = before.digest == after.digest
if (!stable) {
log.warn('RLPlugins: files changed while this build ran. Build again so the developer client can match this JAR to your code.')
}
def receipt = [
schema : 'community-repos.build-receipt.v1',
receipt_id: UUID.randomUUID().toString(),
project_id: 'path:'.concat(sha256(projectRoot.toRealPath().toString().getBytes('UTF-8')).take(32)),
git : before.git,
source : [basis: 'v1', digest: stable ? before.digest : null, files: before.files, stable: stable],
inputs : [sdk: sdkInputs(), java_target: javaRelease.getOrNull() ?: javaTarget, jdk: javaVersion.getOrNull(),
gradle: gradleVersion, starter: starterRevision],
artifact : [file: "${pluginName}.jar".toString(), sha256: jarSha256, size: jar.length()],
built_at : java.time.Instant.now().truncatedTo(java.time.temporal.ChronoUnit.SECONDS).toString(),
builder : builder,
]
folder.mkdirs()
part = File.createTempFile('.receipt-', '.part', folder)
part.setText(groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(receipt)).concat('\n'), 'UTF-8')
def target = new File(folder, "${jarSha256}.json")
try {
Files.move(part.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
} catch (java.nio.file.AtomicMoveNotSupportedException ignored) {
Files.move(part.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING)
}
} catch (Exception failure) {
log.warn("RLPlugins: no build receipt was written (${failure.message}). The JAR still installs; the developer client shows it as Source unverified.")
} finally {
if (part != null) part.delete()
}
}
// The developer client loads a JAR only when its runelite-plugin.properties names plugin classes
// that are in it. Checked here, so a typo stops the build instead of the plugin.
def checkPluginJar = { File jar, log ->
def zip = new java.util.zip.ZipFile(jar)
try {
def entry = zip.getEntry('runelite-plugin.properties')
if (entry == null) {
throw new GradleException('RLPlugins: the JAR has no runelite-plugin.properties. Keep it in src/main/resources.')
}
def properties = new Properties()
zip.getInputStream(entry).withCloseable { properties.load(it) }
def first = { String keys -> keys.tokenize().collect { properties.getProperty(it, '').trim() }.find { it } ?: '' }
def slug = first('slug pluginId')
def classes = first('plugins pluginClass mainClass').tokenize(',; \t')
if (slug && !(slug ==~ /[a-z0-9]+(-[a-z0-9]+)*/)) {
throw new GradleException("RLPlugins: slug=${slug} in runelite-plugin.properties may only use lowercase letters, digits and single dashes, for example my-plugin.")
}
if (!classes) {
throw new GradleException('RLPlugins: runelite-plugin.properties needs plugins= with the full name of your plugin class, for example com.yourname.myplugin.MyPlugin.')
}
def missing = classes.findAll { zip.getEntry(it.replace('.', '/').concat('.class')) == null }
if (missing) {
throw new GradleException("RLPlugins: plugins= in runelite-plugin.properties names ${missing.join(', ')}, which is not in the JAR. Use the package plus the class name, for example com.yourname.myplugin.MyPlugin.")
}
if (!slug) {
log.warn('RLPlugins: runelite-plugin.properties has no slug=. Set slug= to the slug of your plugin.')
} else if (slug == 'community-exampl'.concat('e')) {
log.warn("RLPlugins: slug=${slug} is still the example. Give your plugin its own slug, package and class before you publish it.")
} else if (slug != pluginName) {
log.warn("RLPlugins: settings.gradle names this project ${pluginName}, but runelite-plugin.properties says slug=${slug}. Give rootProject.name the same name as the slug.")
}
} finally {
zip.close()
}
}
def installToDevClient = tasks.register('installToDevClient') {
description = 'Copies the plugin JAR and its build receipt into the developer client folder.'
dependsOn tasks.named('jar')
doLast {
def built = builtJar.get().asFile
checkPluginJar(built, logger)
def installed = new File(pluginFolder, "${pluginName}.jar")
def builtSha256 = sha256(built.bytes)
pluginFolder.mkdirs()
// The receipt goes first, so the developer client never finds this JAR without it.
writeReceipt(built, builtSha256, logger)
if (installed.isFile() && Arrays.equals(installed.bytes, built.bytes)) {
logger.lifecycle("RLPlugins: nothing new to install. ${installed} already is this build (${builtSha256.take(12)}).")
return
}
// Written under another name first, so the developer client never reads half a JAR.
def part = new File(pluginFolder, ".${pluginName}.jar.part")
IOException failure = null
for (int attempt = 0; attempt < 15; attempt++) {
try {
Files.copy(built.toPath(), part.toPath(), StandardCopyOption.REPLACE_EXISTING)
part.setLastModified(System.currentTimeMillis())
try {
Files.move(part.toPath(), installed.toPath(),
StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE)
} catch (java.nio.file.AtomicMoveNotSupportedException ignored) {
Files.move(part.toPath(), installed.toPath(), StandardCopyOption.REPLACE_EXISTING)
}
failure = null
break
} catch (IOException busy) {
// Windows: another program still has the old JAR open. Try again shortly.
failure = busy
Thread.sleep(200)
}
}
if (failure != null) {
throw new GradleException("RLPlugins: could not copy the plugin to ${installed}: ${failure}. "
.concat('Close whatever has that file open and build again.'))
}
logger.lifecycle("RLPlugins: installed ${installed} (build ${sha256(installed.bytes).take(12)}).")
logger.lifecycle('RLPlugins: in the developer client, right-click the plugin and choose Reload Local Jar.')
def kernel = new File('/proc/version')
if (kernel.isFile() && kernel.text.toLowerCase().contains('microsoft')) {
logger.lifecycle('RLPlugins: this build ran inside WSL, so the JAR is in the Linux home folder. A developer '
.concat('client on Windows watches C:/Users/<you>/.rlplugins/local-plugins: put rlpluginsPluginFolder=')
.concat('/mnt/c/Users/<you>/.rlplugins/local-plugins in ~/.gradle/gradle.properties (in WSL), not in this project.'))
}
}
}
tasks.named('jar') { finalizedBy installToDevClient }
// An IDE's Build button only compiles. This makes it build and install the JAR as well.
tasks.named('classes') { finalizedBy tasks.named('jar') }
}
tasks.withType(JavaCompile).configureEach {
options.release = 11
options.encoding = 'UTF-8'
}
tasks.named('jar') {
preserveFileTimestamps = false
reproducibleFileOrder = true
}
// Dashboard > Publishing takes this ZIP: exactly the files the build server builds from.
// Run `gradle uploadZip` (IntelliJ: Gradle window > Tasks > rlplugins > uploadZip).
tasks.register('uploadZip', Zip) {
group = 'rlplugins'
description = 'Packs build.gradle, settings.gradle and src/ into the ZIP for Dashboard > Publishing.'
archiveFileName = "${rootProject.name}-upload.zip"
destinationDirectory = layout.buildDirectory.dir('upload')
preserveFileTimestamps = false
reproducibleFileOrder = true
from(projectDir) {
include 'build.gradle', 'settings.gradle', 'gradle/wrapper/gradle-wrapper.properties', 'README.md', 'src/**'
}
doLast {
logger.lifecycle("RLPlugins: upload ${archiveFile.get().asFile} in Dashboard > Publishing on rlplugins.net.")
}
}
Made your project with an older starter, or does your build not end with RLPlugins: installed …? Replace your build.gradle with this one and press Reload. To build into another folder, add rlpluginsPluginFolder=/full/path to ~/.gradle/gradle.properties in your home folder, not to the project: the project's gradle.properties is never committed.
You have a build.gradle from an older starter. Replace it with the one under SDK updates, or let the AI prompt do it.
Three checks. The build must end with RLPlugins: installed …: if it does not, replace your build.gradle with the one under SDK updates and build again. The folder in that line must be .rlplugins/local-plugins in your own home folder; a build inside WSL or a sandbox lands somewhere else. Then turn the plugin off and on, or right-click it and choose Reload Local Jar: both load the newest build. If off and on still runs the old build, close the launcher and your clients and start the launcher again once; that fix came with Manager 0.3.54. Versions shows the build id that is LOADED.
plugins= must be the full class name, for example com.yourname.myplugin.MyPlugin, and the slug may only use lowercase letters, digits and dashes. Right-click the plugin or open Debug Terminal to see why a JAR did not load.
Your loop() threw an exception, often a NullPointerException. Check for null, and catch and log errors yourself while you test.
Rather not use Gradle? Download the SDK JAR, add it in IntelliJ under Project Structure → Libraries, and build an artifact into ~/.rlplugins/local-plugins. You then have to download the SDK again after each update.