API Reference

Represents the local player character. Provides access to player information like stats, location, and equipment.

The main client interface. Provides access to game state, players, NPCs, items, and more. This is the entry point for most plugin functionality.

Fired every game tick (0.6 seconds). This is the most common event for plugins that need to run continuously.

Base class for rendering overlays on the game screen. Extend this to draw text, shapes, and images on top of the game. Use PanelComponent for text rendering (recommended).

Base interface for plugin configuration. Create an interface extending Config to define your plugin's settings.

Annotation to group configuration items together. Use this on your config interface to organize settings.

Annotation to create sections within your configuration. Use this to organize related settings into groups.

Represents a non-player character in the game. Use this to interact with NPCs, check their health, names, and locations.

Represents a container of items, such as inventory, equipment, or bank. Provides methods to access and iterate through items.

Fired when player data changes, such as combat level, stats, or appearance. Use this to react to player state changes.

Manages overlay registration and rendering. Use this to add and remove overlays from your plugin.

Annotation for individual configuration items. Use this to define specific settings in your config interface.

Represents a point in the game world with X, Y, and plane coordinates. Use this for location-based calculations.

Fired when an item container (inventory, equipment, bank) changes. Use this to track item additions, removals, and quantity changes.

Fired when a skill's level or experience changes. Perfect for tracking XP gains, level ups, and stat changes.

Enum representing all skills in the game. Use this to access skill-specific data like experience, levels, and boosts.

Manages keyboard input listeners. Use this to register KeyListeners for handling keyboard shortcuts and hotkeys.

Annotation for dependency injection. Marks fields that RuneLite should automatically provide with instances.

Annotation that marks a method as an event listener. RuneLite automatically registers @Subscribe methods in Plugin subclasses — no manual registration required.

Base class for Player and NPC. Provides common functionality like location, animation, and appearance.

Represents a single item in a container. Contains the item ID and quantity.

Represents a single entry in the right-click menu. Use this to add, remove, or modify menu options.

Fired when a menu entry is added to the right-click menu. Use this to modify menus before they're displayed.

Enum containing IDs for different item containers. Use these constants instead of magic numbers.

Enum representing different types of menu actions. Use this to identify what type of action a menu entry represents.

Enum defining overlay rendering layers. Use this to control when your overlay is drawn relative to game elements.

Enum defining overlay positioning. Use this to control where your overlay appears on screen.

Interface for handling keyboard input. Implement this to respond to key presses, releases, and typing.

Required annotation for all plugins. Tells RuneLite about your plugin's name and description.

Base class that all RuneLite plugins must extend. Provides lifecycle methods and plugin infrastructure.

Java's graphics context for drawing. Used in Overlay.render(Graphics2D) methods to draw text, shapes, and images. Note: For text rendering, prefer PanelComponent and LineComponent over raw graphics.drawString().

Represents a color in RGB or RGBA format. Use this for setting colors in overlays and configs.

Represents width and height. Return this from overlay render() methods to specify overlay size.

Represents X and Y coordinates. Used for screen positions and locations.

Represents a font for text rendering. Use this to set font family, style, and size.

Java utility for scheduling tasks. Rarely used in RuneLite plugins — prefer GameTick events or clientThread.invokeLater() for timing.

Java's string class. Used extensively for text manipulation, comparisons, and formatting.

Java interface for ordered collections. Use ArrayList or LinkedList implementations for storing multiple items.

Java interface for key-value pairs. Use HashMap implementation for storing data with keys.

Resizable array implementation of List. Use this for dynamic lists that need fast access by index.

Hash table implementation of Map. Use this for fast key-value lookups.

Pre-built component for rendering text in overlays. Provides better text rendering than raw Graphics2D.

Pre-built component for creating panels with backgrounds and borders. Makes overlay UI creation easier.

Utility class for image operations. Provides methods for loading, resizing, and manipulating images.

Utility class for text rendering in overlays. Provides text measurement and drawing utilities.

Represents a point in local coordinates (relative to the current scene). Use this for scene-based calculations.

Represents a tile on the game map. Provides access to ground items, objects, and wall decorations.

Represents the current game scene. Provides access to tiles, objects, and the loaded area.

Represents a game object on a tile (trees, doors, chests, etc.). Use this to interact with game objects.

Ensures code runs on the game thread. Critical for safe chat messages, menu changes, and any client-modifying operations outside event handlers.

Safe way to add/modify menu entries without breaking compatibility. Prefer this over direct client.setMenuEntries() manipulation.

Gets item prices, definitions, icons, and other item-related information. Essential for loot trackers, price checkers, and bank value calculators.

Sends notifications to users. Perfect for level-up alerts, achievements, warnings, and other important messages.

Constants for accessing game state variables (varbits). Used for special attack energy, run energy, combat style, and many other game values.

Constants for accessing player-specific variables (varplayers). Used for run energy, special attack energy, and other player state values.

Java utility for scheduling background tasks. Useful for periodic operations, delays, and async work that doesn't need to run on the game thread.

Builder for creating formatted chat messages with colors, links, and special formatting. More flexible than direct client.addChatMessage().

Utility class for coordinate conversions between world, local, and screen coordinates. Essential for drawing overlays at specific world locations.

Constants for accessing client-side variables like camera angle, zoom level, and viewport settings. Useful for camera and rendering plugins.