UI - Starline Lua API

Load-time only. Calling ui.* from a callback errors.

Tabs and groups

Elements can be organized into tabs and groups.

local general = ui.Tab("general")
local trigger = general.Group("triggerbot")
local enabled = trigger.Checkbox("enabled", true)

local advanced = ui.Tab("advanced")
advanced.Group("filtering").Checkbox("head only", false)

These tabs appear inside your script’s page, not in the main menu bar. Members take a dot. Groups lay out across two columns in declaration order. Skip either level and it falls back to something named after your script:

local g = ui.Group("misc")      -- no tab -> auto tab
local loose = ui.Checkbox("x")  -- no tab, no group -> auto tab, auto group

The tab bar hides itself when there is only one tab.

Elements

Every element exists on ui and on every group handle.

Function	Returns
`Tab(name)`	tab handle	only `Group` exists on it
`Group(name)`	group handle
`Checkbox(name, default)`	handle
`SliderInt(name, min, max[, default])`	handle	`default` falls back to `min`; `min` must be less than `max`
`SliderFloat(name, min, max[, default])`	handle	same
`Combo(name, items[, default])`	handle	`default` is a 0-based index into `items`, defaults to `0`
`MultiCombo(name, items)`	handle	all items start unselected
`ListBox(name, items[, rows])`	handle	`items` may be empty; `rows` defaults to `6` and is clamped to `1..32`
`TextInput(name[, default[, placeholder]])`	handle	`placeholder` shows while the field is empty
`Button(name, on_click)`	handle
`ColorPicker(name, r, g, b[, a])` or `ColorPicker(name, Color(...))`	handle	`a` defaults to `255`
`ExpandableGroup(name[, default])`	expandable group	see Expandable groups
`Hotkey(name[, key[, mode]])`	handle	`key` is a virtual-key code, defaults to `0` (unbound); `mode` is `"hold"` (default) or `"toggle"`
`Label(text)`	handle	no value; only `SetVisible` and `SetLabel`
`Divider()`	handle	no value; only `SetVisible`

Every element except TextInput and Hotkey gets a right-click hotkey automatically.

local aimbot = ui.Tab('general').Group('aimbot')

local enabled = aimbot.Checkbox('enabled', true)
local delay   = aimbot.SliderInt('delay (ms)', 0, 250, 35)
local fov     = aimbot.SliderFloat('fov', 0.0, 180.0, 45.5)
local team    = aimbot.Combo('target team', { 'enemies', 'teammates', 'all' }, 0)
local hitbox  = aimbot.MultiCombo('hitboxes', { 'head', 'chest', 'stomach' })
local col     = aimbot.ColorPicker('chams', 255, 0, 0)
local tag     = aimbot.TextInput('clantag', '', 'starline')

local peek    = aimbot.Hotkey('peek key', 0x05, 'hold')

aimbot.Button('reset', function() print('clicked') end)
aimbot.Label('experimental')
aimbot.Divider()

IDs

Saved values and keybinds are matched by tab, group and label, so renaming a label loses them. To keep them across a rename, pass a table with an id instead of a name:

local enabled = ui.Checkbox({ id = 'enabled', label = 'Enabled' }, true)

Field
`label`	String, the text shown in the menu. Required for every element except `Divider`.
`id`	String, optional. Must be unique within your script.

Values saved before you added the id are picked up once by the old label.

Expandable groups

ExpandableGroup adds a checkbox row that expands to show the elements inside it, like the menu’s own expandable rows.

local aimbot = ui.Group('aimbot')
local smooth = aimbot.ExpandableGroup('smoothing', true)

local amount = smooth.SliderFloat('amount', 0, 100, 30)
local curve  = smooth.Combo('curve', { 'linear', 'ease' }, 0)

if smooth:Get() then
    -- the checkbox on the row is ticked
end

The returned value works two ways:

Use	Example
Dot, like a group	`smooth.Checkbox(...)`	adds an element inside the expandable group. Every element works except another `ExpandableGroup`.
Colon, like a checkbox handle	`smooth:Get()`	`Get`, `Set`, `OnChange`, `SetVisible` and `SetLabel` act on the row’s checkbox. `AddColorPicker` and `AddFolderButton` act on the row.

default sets whether the checkbox starts ticked, and defaults to false. Hiding it with SetVisible(false) hides everything inside too. The path of an element inside one includes the row’s label: scripts.<script>.<tab>.<group>.<expandable>.<label>.

Handles

Get and Set take a colon.

local v = enabled:Get()
enabled:Set(false)

Element	`Get()` returns	`Set(...)` takes
`Checkbox`	Boolean	Boolean
`SliderInt`	Integer	Number, clamped to `min..max`
`SliderFloat`	Number	Number, clamped to `min..max`
`Combo`	Integer, 0-based index	Integer, clamped
`MultiCombo`	`Get(index)`, Boolean. 0-based, errors out of range	`Set(index, bool)`, 0-based
`ListBox`	Integer, 0-based index; `-1` when empty	Integer, clamped
`TextInput`	String	String, max 512 chars
`ColorPicker`	`Color` and mode	`Set(Color[, mode])` or `Set(r, g, b[, a][, mode])`
`Hotkey`	Boolean, whether the hotkey is active	Boolean
`Button`, `Label`, `Divider`	nothing	not supported

At load time, Get() returns the declared default. Restored values are applied after loading. MultiCombo also takes Set(table) with a whole array of booleans.

Labels

handle:SetLabel(text) changes the text shown in the menu. It works on every element except Divider.

local status = ui.Label('status: idle')

events.On('paint', function()
    status:SetLabel('status: ' .. (enabled:Get() and 'on' or 'off'))
end)

Change callbacks

handle:OnChange(fn) calls fn with the new value whenever the element’s value changes. It works on Checkbox, SliderInt, SliderFloat, Combo, MultiCombo, ListBox, ColorPicker and Hotkey. For TextInput, use OnSubmit.

local fov = ui.SliderFloat('fov', 0, 180, 45)

fov:OnChange(function(value)
    print('fov is now ' .. value)
end)

Element	`fn` receives
`MultiCombo`	the whole array of booleans
`ColorPicker`	the color and the mode
everything else	the same value as `Get()`

It fires for changes from the menu, hotkeys and config loads, including the restore right after your script loads. Changes made from Lua don’t fire it. Sliders and color pickers fire once, when you let go of the mouse. OnChange returns the handle for chaining. Pass nil to remove the handler. It can be called from callbacks.

Hotkeys

Hotkey is a standalone keybind row.

local peek = ui.Hotkey('peek key', 0x05, 'hold')   -- mouse 4

events.On('paint', function()
    if peek:Get() then
        -- active
    end
end)

Mode	`Get()` is `true`
`"hold"`	while the key is held
`"toggle"`	from one press until the next

handle:GetKey() returns the bound virtual-key code, 0 when unbound. handle:SetKey(code) binds a new one. Set(bool) changes the toggle state; in hold mode the key overrides it on the next frame.

Color modes

Script color pickers offer solid, rainbow and pulse. Get() returns two values: the color as it currently shows (animated for rainbow and pulse) and the mode, "solid", "rainbow" or "pulse".

local col = ui.ColorPicker('glow', 255, 0, 0)

events.On('paint', function()
    local c, mode = col:Get()
    renderer.RectFilled(10, 10, 50, 50, c)
end)

col:Set(Color(0, 255, 0), 'rainbow')

Set takes the mode after the color. Leave it out to keep the current mode.

Next to a checkbox, combo or expandable group

handle:AddColorPicker(r, g, b[, a]) or handle:AddColorPicker(Color(...)) puts a color swatch at the end of a Checkbox, Combo or ExpandableGroup row, like the visuals tab. It returns a ColorPicker handle. At load time only.

Row	Swatches
`Checkbox`, `Combo`	up to 4
`ExpandableGroup`	1, next to the row’s checkbox

local chams   = ui.Checkbox('chams', true)
local visible = chams:AddColorPicker(255, 0, 0)
local hidden  = chams:AddColorPicker(0, 0, 255)

local glow     = ui.ExpandableGroup('glow', true)
local glow_col = glow:AddColorPicker(Color(0, 200, 255))
glow.SliderFloat('thickness', 0, 10, 2)

Its path is the row’s path plus .color, then .color2, .color3 and .color4.

Per-item colors

handle:AddItemColors([colors]) gives every item of a MultiCombo its own swatch, drawn on the item’s row in the dropdown. At load time only, once per element.

`colors`
omitted	every item starts white
a `Color`	every item starts with it
a table of `Color`	one per item, in order; a missing entry starts white

It returns an array of ColorPicker handles, 1-based like the item list.

local flags  = ui.MultiCombo('flags', { 'armor', 'defuser', 'scoped' })
local colors = flags:AddItemColors({ Color(255, 255, 255), Color(0, 160, 255), Color(255, 200, 0) })

events.On('paint', function()
    local armor_col = colors[1]:Get()
end)

Each one’s path is the multi-combo’s path plus the item’s name: scripts.<script>.<group>.flags.armor.

Folder buttons

handle:AddFolderButton(path[, hint[, root]]) adds a folder icon to a Checkbox, Combo or ExpandableGroup row, like the skybox row in the visuals tab. Clicking it opens path in Explorer, creating the folder first if it is missing. hint shows when you hover the icon. At load time only. Returns the handle for chaining.

`root`	`path` is relative to
`"data"` (default)	`Documents\Starline\scripts\data`, the `file` folder
`"game"`	the game’s `csgo` folder

local sound = ui.Combo('hit sound', { 'none', 'custom' }, 0)
sound:AddFolderButton('hitsounds', 'drop .wav files here')

local sky = ui.Checkbox('custom sky', false)
sky:AddFolderButton('materials/skybox', 'drop custom skyboxes here (.vmat_c)', 'game')

path follows the same rules as file paths, except that it may be empty to open the root itself. A bad path raises an error. Nothing happens on click if a file sits where the folder would be.

Lists

ListBox is an always-open scrolling list with one selected row. handle:SetItems(table) replaces the whole list from any callback — that is how you build a list that grows.

local nades = {}
local list  = ui.ListBox('nades', nades, 8)

ui.Button('add', function()
    nades[#nades + 1] = 'nade ' .. #nades
    list:SetItems(nades)
end)

ui.Button('remove', function()
    local i = list:Get()
    if i >= 0 then
        table.remove(nades, i + 1)   -- Get is 0-based, table.remove is 1-based
        list:SetItems(nades)
    end
end)

SetItems accepts only strings. Selection stays at the same index when possible, clamps when the list shrinks, and becomes -1 when empty.

Text

TextInput is a one-line field. Read it with Get, or take handle:OnSubmit(fn) to be called when the user presses enter or leaves the field.

local tag = ui.TextInput('clantag', '', 'type a tag')

tag:OnSubmit(function(text)
    print(text)
end)

OnSubmit returns the handle for chaining. Pass nil to remove the handler. It can be called from callbacks.

Showing and hiding

handle:SetVisible(bool) on any handle, including Label and Divider. Siblings reflow, the group shrinks. Call it from a paint callback to drive it off another element:

local mode  = ui.Combo('mode', { 'off', 'legit', 'rage' }, 0)
local speed = ui.SliderInt('speed', 1, 10, 5)

events.On('paint', function()
    speed:SetVisible(mode:Get() == 2)   -- rage only
end)

Elements start visible. Hiding an element does not change its value.

Controls by path

ui.Get and ui.Set read and write controls by path. They work on the cheat’s own controls and on any script’s controls.

local on = ui.Get("aimbot.legit.triggerbot.enabled")
ui.Set("aimbot.legit.triggerbot.enabled", true)
ui.Set("aimbot.legit.weapons.max fov", 3.5)
ui.Set("visuals.world.modulation.world.color", Color(255, 0, 0))

Both error if no control matches the path.

Script controls

A script control’s path is scripts.<script>.<tab>.<group>.<label>. The tab is optional. <script> is the file name without .lua. Auto tabs and auto groups use the script’s name, the same as the menu shows.

-- in other.lua: ui.Tab('main').Group('aimbot').Checkbox('enabled', true)
local on = ui.Get("scripts.other.main.aimbot.enabled")
ui.Set("scripts.other.aimbot.enabled", false)   -- tab omitted

-- in other.lua: ui.Checkbox('x')  (auto tab, auto group)
ui.Get("scripts.other.other.x")

Values have the same shapes as the handle’s Get and Set, with two exceptions: MultiCombo reads and writes the whole array of booleans, and a ColorPicker returns its saved color rather than the animated one.

Control	Value
checkbox	boolean
slider	number
combo	number, 0-based index
multi-combo	array of booleans
keybind	number, virtual-key code
color picker	`Color`, or a `{r,g,b,a}` table, plus a mode

Color modes

On a color picker, ui.Get returns two values: the color and its mode. The mode is "solid", "gradient", "rainbow" or "pulse".

local col, mode = ui.Get("visuals.world.modulation.world.color")
ui.Set("visuals.world.modulation.world.color", Color(255, 0, 0), "rainbow")
ui.Set(path, ui.Get(path))   -- keeps the color and the mode

ui.Set takes the mode as an optional third argument. Leave it out to keep the current mode. A picker that doesn’t offer the mode you pass falls back to solid. Setting "gradient" keeps the picker’s existing second color.

Buttons

Buttons have no value. Use ui.Click(path) to activate one.

ui.Click("visuals.world.view.viewmodel changer.reset")

Returns
`true`	the button fired
`false`	the control is greyed out, same as the menu refusing the click

Errors if nothing matches the path, or if the path matches a control that is not a button. The button callback runs on the thread that called ui.Click.