Skip to main content

​
What are Modules?

Modules (also called “hacks”) are the core features of LiquidBounce. Each module provides specific functionality that can be enabled or disabled. Modules can handle events, respond to game actions, and modify player behavior.
Modules are defined in ClientModule.kt and extend the ToggleableValueGroup class, making them event listeners that can be configured.

​
Module Categories

LiquidBounce organizes modules into categories to help you find what you need. Each module belongs to one of these categories:

Combat

Modules that enhance combat capabilities, such as auto-aiming, criticals, and velocity modifications.

Movement

Modules that affect player movement, including speed, flight, and step modifications.

Player

Player-related modules like auto-armor, inventory management, and auto-tool.

Render

Visual modules such as ESP, tracers, and HUD elements.

World

World interaction modules including scaffold, auto-mine, and chest stealer.

Exploit

Modules that exploit game mechanics or server vulnerabilities.

Misc

Miscellaneous utility modules that don’t fit other categories.

Fun

Entertainment modules for fun effects and animations.

​
Module States

Modules have two important states:

​
Enabled State

The enabled state determines whether a module is active. You can toggle modules on or off using:
  • The ClickGUI interface
  • Keybinds
  • Commands (.toggle <module>)

​
Running State

The running state is separate from enabled. A module is running when:
  • It is enabled (or marked as notActivatable)
  • The player is in-game
  • The module hasn’t been paused
override val running: Boolean
    get() = super<EventListener>.running && inGame && (enabled || notActivatable)
Source: ClientModule.kt:74-75

​
Keybinds

Every module can be assigned a keybind for quick access. The keybind system supports:
  • Key Type: Keyboard keys, mouse buttons, or other input types
  • Bind Action: What happens when the key is pressed (toggle, hold, etc.)
Keybinds are stored in the module’s bindValue property: 
internal val bindValue = bind("Bind", InputBind(InputConstants.Type.KEYSYM, bind, bindAction))
Source: ClientModule.kt:77

​
Setting Keybinds

You can set keybinds through:
  1. ClickGUI: Click the bind button in the module settings
  2. Command: Use .bind <module> <key>
  3. Config Files: Edit the configuration manually

​
Module Configuration

Modules can have various configuration options called “values” or “settings”. These allow you to customize how each module behaves.

​
Accessing Settings

Modules expose their settings through the settings property: 
open val settings by lazy { inner.associateBy { it.name } }
Source: ClientModule.kt:110

​
Value Types

Modules support many types of configuration values:
  • Boolean: On/off toggles
  • Integer/Float: Numeric ranges
  • Choice: Selection from predefined options
  • Text: String input
  • Color: Color pickers
  • Blocks/Items: Minecraft object selections
Learn more about value types in the Configuration page.

​
Hidden Modules

Modules can be hidden from the HUD arraylist while still being active. This is useful for modules you want to use discreetly. 
var hidden by boolean("Hidden", hide)
    .doNotIncludeWhen { !AutoConfig.includeConfiguration.includeHidden }
    .independentDescription()
Source: ClientModule.kt:86-88
Set a module as hidden using:
  • .hide <module> command
  • The “Hidden” setting in ClickGUI

​
Module Tags

Some modules display a tag on the HUD arraylist showing their current configuration or state. For example:
  • Speed: “Vanilla” or “Custom”
  • Flight: Current mode
  • KillAura: Range setting
Tags are defined by the module using the tagBy() method: 
open val tag: String?
    get() = this.tagValue?.getTagValue()?.toString()
Source: ClientModule.kt:101-102

​
Common Module Operations

​
Enable/Disable a Module

// Enable a module
module.enabled = true

// Disable a module
module.enabled = false

// Toggle a module
module.enabled = !module.enabled

​
Check if Module is Enabled

if (ModuleKillAura.enabled) {
    // Module is enabled
}

​
Access Module Settings

val range = ModuleKillAura.range.get()
ModuleKillAura.attackSpeed.set(15)

​
Module Events

Modules can react to game events by implementing event handlers. Common events include:
  • Player Movement: PlayerMoveEvent
  • Packet Handling: PacketEvent
  • Rendering: ScreenRenderEvent
  • Combat: AttackEvent
When a module is enabled, it registers as an event listener. When disabled, it unregisters.

​
Not Activatable Modules

Some modules cannot be toggled on/off in the traditional sense. These are marked with notActivatable = true and are always considered “running” when in-game. Examples include:
  • ClickGUI: The interface itself
  • HUD: Always-on display elements
Not activatable modules cannot be toggled using keybinds or the toggle command.

​
Best Practices

1

Organize by Category

Use the category system to quickly find modules you need
2

Use Keybinds

Set keybinds for frequently used modules for quick access
3

Configure Settings

Customize module settings to match your playstyle and server requirements
4

Hide When Needed

Hide modules from the arraylist for a cleaner HUD or discretion
5

Use Auto-Config

Load server-specific configurations for optimal performance

Commands

Learn about the command system for controlling modules

Configuration

Understand how configuration and values work

Scripting

Create custom modules using scripts

ClickGUI

Using the ClickGUI to manage modules

Build docs developers (and LLMs) love

Get started for freeTalk to us