1 of 100

CS2 Lua API

Overview

Official lua API documentation for fatality.win

Introduction

Creating scripts

Welcome to the basics of scripting with our API.

Fatality’s API is designed to mirror the software’s internal structure, giving you substantial control over its subsystems. Some features that could cause instability or damage are restricted.

Basic Concepts

Our scripting engine uses LuaJIT 2.1 (with minor customizations). It’s fully compatible with Lua 5.1 and includes some Lua 5.2 enhancements.

The standard libraries baselib, bit, ffi, math, string and table are available. Note that the ffi library is only available if the Allow insecure option is enabled. Refer to the official Lua documentation for more details.

If we ever modify any standard functions, we will document those changes to keep you informed.

Documentation Overview

Throughout the API reference, you’ll encounter various labels used to describe a certain method or a field.

Labels:

Field Function Method Constructor Read only Insecure only

All the possible labels are listed above.

Field: this label indicates that the item is a standard field. It's type will be explained just below the name.
Function: this label indicates that the item is a function, which you call using a dot syntax (obj.fn()).
Method: this label indicates that the item is a method, which is also a function, but it's advised to call it with the colon syntax (obj:fn()).
Constructor: this label indicates that the item is a constructor definition. You don't have to call any field in particular, but instead you must invoke the type itself (example: vector has __call, meaning you should invoke it like this: vector()).
Read Only: this label indicates that the item is read only, and it's value cannot be changed. Typically, this restriction does not extend to any child elements.
Insecure only: this label indicates that the item is only available if the insecure mode is turned on.

Argument and return lists

Arguments and return values are listed in the exact order you must supply or capture them. For instance, if a parameter is shown first, it is to be passed as the first argument to the function. The same goes for return values: the first listed value will be placed in the first variable you declare, and so on.

Types

Some type descriptions have special symbols in place:

type? means that the type might be nil.
type<other> means that inner methods or fields will use other type.
<other> means that the type will be either other, or any of its child types.

Rules

To keep your scripts safe and easy to use, we have quite a lot of safety measures in place. But, due to how specific stuff works, we are unable to fully make it as safe as possible. Therefore, here are some notes you should know before writing scripts:

You Control the Lua State

You may replace or override API functions, but you’re responsible for maintaining stable behavior. If you encounter any bugs in the default API (excluding FFI), please report them so we can address the issue.

Prioritize Safety

Using FFI grants you extensive freedom. Keep in mind that scripts which could harm users in any way are disallowed and will be removed. Whenever possible, rely on the provided API or request additional functionality if you need something not currently offered. Custom “script loaders” are strictly disallowed.

Keep the Software Usable

Avoid hiding unrelated UI elements, obstructing user input, or interfering with the overall user experience. Scripts that disrupt functionality or harass users risk removal from the Workshop.

First Steps

Now that you’ve covered the essentials, it’s time to start scripting.

Fire up a text editor

Feel free to use any text editor you prefer: , , or even a simple Notepad.

Local scripts are located here: <CS2_Directory>/game/csgo/fatality/scripts. You may notice there's also a lib directory, but we’ll get to that later.

Create a new file ending with .lua, and begin your work on the script.

.ljbc format cannot be loaded from local sources.

Writing your first script

A typical “Hello world!” example can be a bit trivial, so let’s try something slightly more advanced instead.

Now, let's break down this example script:

Defining a callback function

Most of your scripting will run within we provide. Each event has its own signature, so pay attention to the parameters your callback function should accept. present_queue doesn’t provide any parameters, so our function doesn’t need any either.

Defining something local is optional, although recommended for clearer scope management.

Accessing drawing layer

With the callback function defined, let’s actually render something on the screen!

To do this, you first need to access the . We provide a single drawing layer that’s safe to use within the game thread. Due to how the game functions internally, it’s strongly discouraged to call game functions in other threads. Luckily all of our events run in the game thread.

This setup allows you not only to draw but also to query information on player health or other entities.

To access the layer, simply reference the surface field in the draw table:

You don't have to store it in a variable, but it would be nicer if you don't have to type out draw.surface every time, right?

Setting a font

After retrieving the layer, you must set a font object before drawing any text on the screen. This is purely for performance reasons, so you don’t have to pass a heavy font object every time you draw text.

All fonts are stored in . To access a font, either use dot syntax, or treat it like a dictionary:

Drawing text

With the font set, it’s time to draw some text.

Invoke the method on the layer. Notice that it’s called using the colon syntax: obj:fn(), because it’s a method.

You can also invoke methods with a dot syntax, as long as you provide the object in the first argument. Both calls: obj:fn() and obj.fn(obj) are identical.

Registering a callback

Now that you’ve created your first callback, you need to register it so Fatality knows to invoke it. This is done by calling the method on .

Result

That's it! If you've done everything correctly, you should see something like this:

Adding UI

Now that you know the basics, let’s extend our script by allowing the user to toggle the text. We can do this by adding a control to the menu.

Creating a control

Let’s start by creating a simple checkbox:

local cb = gui.checkbox(gui.control_id('my_checkbox'));

Each control has a unique ID, which the UI framework uses to distinguish controls within containers. It’s very important that your control’s ID doesn’t conflict with others, as that could result in a broken state or worse.

To create the ID, call gui.control_id and pass the desired ID.

Then, create the checkbox by calling gui.checkbox and passing the ID structure you've created.

Constructing the row

By default, controls are typically placed in rows - layouts that stack elements in a specific manner. We provide a simple helper function - gui.make_control.

local row = gui.make_control('My checkbox', cb);

Adding the row to a group

With the control and row ready, let’s add them to a group.

To view group and control IDs, you can enable Debug mode in the SCRIPTS tab.

In this example, we'll use the lua>elements a group. First, locate that group in the global context:

local group = gui.ctx:find('lua>elements a');

Then call its add method to include your row:

group:add(row);

That's it!

It is very important to call reset() method if you add multiple controls, so the layout will stack everything correctly.

Using the value

Next, let’s modify our previous script so the text only appears if the checkbox is checked. Wrap your drawing code in an if statement before rendering the text:

if cb:get_value():get() then

and close it after.

The final script should look something like this:

local cb = gui.checkbox(gui.control_id('my_checkbox'));
local row = gui.make_control('My checkbox', cb);
local group = gui.ctx:find('lua>elements a');
group:add(row);

local function on_present_queue()
    if cb:get_value():get() then
        local d = draw.surface;
        d.font = draw.fonts['gui_main'];
        d:add_text(draw.vec2(50, 50),
            'Hello drawing! My first script speaking.',
            draw.color.white()
        );
    end
end

events.present_queue:add(on_present_queue);

And here's the result:

Creating Libraries

Libraries are not yet supported, but will be available soon.

Workshop

Getting Started

Workshop allows you to publish, advertise, and earn from your items. It provides a broad set of features for both publishers and end users, making the storefront easy to use and reliable to manage.

Core Concepts

Before publishing, it's important to understand the key concepts used in Workshop:

Storefront - the main Workshop UI where users search, view, subscribe to, or purchase items;
Publishing Tool - the area where item authors create, update, and manage their entries in the storefront;
Item - a single Workshop entry. This can be a script, a library, or a config;
Build - a specific version of an item that gets delivered to the end user;
Branch - a channel that holds a single build (e.g. stable, beta);
Dependency - a required library that an item relies on to function;
Capability - a permission that unlocks restricted API functions (e.g. filesystem access, clipboard).

Next Steps

Read the .
Complete a tutorial.

Guidelines

All items published on the Storefront must follow these guidelines to keep the Workshop safe, usable, and fair for everyone.

1. Provide meaningful descriptions

Your description should clearly explain what the item does, what it requires, and any limitations it may have. Do not use vague, misleading, or clickbait-style descriptions. End users should know exactly what they are getting before they subscribe to or purchase an item.

2. Maintain a minimum quality standard

Trivial one-line scripts, spam items, or submissions with no meaningful functionality are not allowed. All items must undergo basic quality assurance to ensure they work as described and do not pollute the Workshop with junk content.

3. Respect capability requests

Always use the provided APIs and tools in a way that respects user choice of permissions. Do not attempt to bypass or override capability restrictions. If your item does not need filesystem access, for example, you must not request it.

4. Practice fair market behavior

Artificial price dumping, manipulative pricing strategies, or exploitative sales tactics are not allowed. The Workshop should remain a healthy, competitive, and sustainable marketplace for all developers.

5. Do not publish malicious code

This includes malware, exploits, spyware, or any script designed to harm users or their systems. While beta branches exist for unverified testing, all items submitted to live must be safe and secure. Any attempt to sneak in harmful code will result in removal and possible bans.

6. Ensure compatibility with existing features

Scripts and configs must not intentionally disrupt core software features, other Workshop items, or the overall stability of the platform. If your item modifies functionality, it must do so safely and predictably.

7. Keep content respectful

Item names, descriptions, scripts, and configs must not contain harassment, hate speech, targeted attacks, or inappropriate material. All content must follow the same standards as the forum and community guidelines.

8. Maintain and update your items

If your script or config breaks due to updates in the core software or APIs, you are responsible for updating it. If you choose to stop maintaining an item, you must clearly mark it as deprecated so users are not misled.

9. Be transparent with monetization

Paid items must disclose exactly what features are included. You may not hide critical functionality behind unexpected paywalls or release crippled versions that require additional payment to work as advertised.

10. Respect licensing and attribution

If your item uses external code, libraries, or assets, you are responsible for ensuring that you follow their licensing terms. Proper credit must be given where required, and you may not repackage or sell work you do not have rights to.

Publishing Tool

Welcome to the Publishing Tool documentation.

Creating a script: Step By Step Guide
Using branches: Branches
Using libraries: Libraries & Dependencies

Step By Step Guide

In this tutorial you’ll create and publish a script to the Storefront. The same flow applies to Libraries and Configs.

Create the item

Go to Workshop -> Manage Items and click Create new item.

Fill out:

Title
Game (the supported title your script targets)
Item type (Script / Library / Config)

Warning: You cannot change the item type later.

Upload a build

Open the Builds tab and click Upload new build.

Fill out:

Version (use semantic versioning like 1.0.0 if possible)
Changelog (short, factual)
File upload (your .lua file or a .zip)

Note: You can upload a ZIP to bundle assets alongside the script. See

Click Save. The build is created in the Draft state.

Click Submit for review. The build state changes to Under review.

After moderation approves it, you’ll get a notification and the state changes to Approved.

Click Set to branch and choose Default.

This makes the approved build the version users receive when they add your script to their library.

Tip: Use a Beta branch to test new builds with a subset of users before moving them to Default. See

Configure capabilities

If your script needs restricted APIs (e.g. FFI, filesystem, clipboard), enable the required Capabilities so users can grant permission.

In Builds -> Capabilities (right side), select only what you need and click Save.

Best practice: Request the minimum capabilities your script actually uses. Users will see and approve these.

Prepare the Storefront listing

Open the General tab and complete all fields in the Release Checklist.

When the checklist is complete, click Submit for review on the item. After moderation approves it, the item is automatically published on the Storefront and users can purchase or subscribe.

Updating Items

In order to update an item you need to follow these steps:

Upload a new build & wait for approval

Check on how to upload a build.

Set build active

Navigate to Builds and find the approved build.
Click Set to branch
Select Default branch
Click Save

After these actions are complete, your new build will be available for users instantly.

Builds are NOT automatically set to the Default branch upon approval! Once you get the notification that your build has been approved, proceed to set its branch to Default.

Additionally, you may want to test upcoming builds before they hit the Live item. For that, we recommend looking into Branches.

Branches

Branches let you create separate versions of your items so users can test upcoming builds before they are pushed to the live Default branch.

Open the Branches tab to manage existing branches or create new ones:

Creating a branch

Click Add branch, enter a branch title, and confirm.

You can create as many branches as you need.

After a branch is created, you can:

Add users (they’ll be allowed to opt in).
Set a price (makes the branch public so anyone can purchase it).

Note: Adding users does not automatically enable the branch for them. It only gives them the option to join.

Managing Builds

Branches can hold any builds - both verified and unverified.

To assign a build to a branch:

Go to the Builds tab.
Find the build you want to assign.
Click Set branch.
Select the branch and submit.

This immediately makes that build available to anyone using the branch.

Libraries & Dependencies

Libraries are specialized items that are not visible in the Storefront. Instead, they are available for other publishers to reference inside their scripts.

Creating a Library

Creating a library works the same way as creating a script (see).

The only difference is that a library requires a Library ID.

The Library ID is a unique identifier used by scripts to reference your library.
Without it, other publishers cannot include your library as a dependency.

You can create and assign a Library ID in the General tab:

Once published and approved, your library becomes available for others to use as a dependency.

Referencing Libraries

When your script references a library, the library is automatically loaded alongside your script at runtime.

To add a library dependency:

Go to the Dependencies tab.
Click Add dependency.
Find the library you want to reference and click Add.
The library will appear in your dependencies list.

It is recommended to reference a specific version of a library rather than always pulling the latest. This ensures your script continues to work even if the library author publishes breaking changes later.

Bundled Assets

If you want to include additional files with your script (e.g. sounds, images, or data), you can bundle them inside a ZIP archive with a defined structure.

The archive must contain a script.lua file in the root.
The archive must not contain a scripts/remote/ directory or any files inside it.

All bundled assets are automatically installed to a directory chosen by the API engine. See ws for usage details.

API

Global Functions

Below is a list of all global functions. By “global”, we mean these functions do not require a preceding namespace - so you can call them directly, unlike other functions.

print

Function

Prints text to game's console.

Arguments

Name

Type

Description

Example

error

Function

Prints an error text to game's console, and shuts down the script. Try to avoid using this function - use it only if an error happens which you can't recover from.

Arguments

Name

Type

Description

Example

Instances

event_t

Event usertype. An instance of this type can be found in events.

add

Method

Adds a callback to the event.

Arguments

Name

Type

Description

fn

function

Callback function. Arguments that are accepted by the function are dictated by the event instance.

Returns

Nothing.

Example

events.present_queue:add(function ()
    -- will be called every time game queues a frame for rendering
end);

remove

Method

Removes a callback from the event.

Arguments

Name

Type

Description

fn

function

Callback function, that was earlier passed to the add() function.

Returns

Nothing.

Example

local function on_present()
    if some_condition then
        events.present_queue:remove(on_present)
    end
end

events.present_queue:add(on_present)

Usage:

Usage: game.input.{field_or_method}

This type represents the game's command input system.

in_third_person

FieldRead only

Type: bool

true if currently in the third person.

get_view_angles

Method

Returns current camera view angles.

Arguments

None.

Returns

Type

Description

Example

set_view_angles

Method

Sets new camera view angles.

Arguments

Name

Type

Description

Returns

Nothing.

Example

cinput_system

Usage: game.input_system:{method}

This type represents the game's control input system.

vk_to_button_code

Method

Converts a virtual key to button code.

Arguments

Name

Type

Description

Returns

Type

Description

Example

cgame_ui_funcs

Usage: game.game_ui_funcs:{method}

This type represents the game's UI functions.

get_binding_for_button_code

Method

Returns the binding name for a button code.

Arguments

Name

Type

Description

code

int

Button code.

Returns

Type

Description

string

Binding.

Example

local bind = game.game_ui_funcs:get_binding_for_button_code(code);

ccvar

Usage:

Usage: game.cvar:{method}

This type represents the game's cvar system.

find

Method

Get the game's cvar under this name.

Arguments

Returns

Example

convar

Represents a convar used by the game.

name

FieldRead only

Type: string

description

FieldRead only

Type: string

flags

FieldRead only

Type: int

value

FieldRead only

Type: <type>

The value of the convar represented in its type

mods

Usage: mods.{mod_name}

This table exposes several mods (short for Module, not Modification), that Fatality uses to operate.

events

Field

Type:

Event manager. Use this mod if you want to listen to more in-game events.

events_t

Usage: mods.events.{method}

This module lets you manage custom in-game event listener.

Please note that the game server knows which events you are listening to. Internally, we only listen to events that will get sent to the client anyway in one way or another. If you decide to listen to something the server generally does not expect, it may cause issues on official servers.

add_listener

Method

Adds a game event to the listener.

Internally we listen to the following events:

bullet_impact
weapon_fire
bomb_beginplant
bomb_abortplant
bomb_planted
bomb_defused
bomb_exploded
round_start
game_newmap
map_shutdown

Adding those events to the listener is not needed.

Arguments

Name

Type

Description

name

string

Event name.

Returns

Nothing.

Example

mods.events:add_listener('round_end');

Types

In this section, the most common renderer types are listed, that are not particularly bound to a specific part of the renderer.

Use the left menu (or hamburger menu on mobile) to navigate between types.

Adapter

This type represents a rendering adapter used within the rendering system.

get_back_buffer

Returns a back buffer texture. May return a blank or outdated texture, if the back buffer texture was not updated.

Arguments

None.

Returns

Example

get_back_buffer_downsampled

Returns a 4x down sampled version of the back buffer texture.

Arguments

None.

Returns

Example

get_shared_texture

Returns a shared texture. This texture usually replicates the down sampled back buffer texture, although it is updated automatically ONCE before the rendering on the layer starts.

Arguments

None.

Returns

Example

outline_mode

This enum is used to determine the outline mode for outlined shapes.

inset

Inset outlining. This means that the outline will be inside the shape (+1px from top-left, -1px from bottom-right).

outset

Outset outlining. This means that the outline will be outside of the shape (-1px from top-left, +1px from bottom-right).

center

Center outlining. This means that the outline will match the shape size.

rounding

Last modified: 03 January 2025

This enum is used to determine the rounding for rounded shapes.

tl

Round top-left corner.

tr

Round top-right corner.

bl

Round bottom-left corner.

br

Round bottom-right corner.

t

Round both of the top corners. This produces the same result as using bit.bor(draw.rounding.tl, draw.rounding.tr).

l

Round both of the left corners. This produces the same result as using bit.bor(draw.rounding.tl, draw.rounding.bl).

r

Round both of the right corners. This produces the same result as using bit.bor(draw.rounding.tr, draw.rounding.br).

b

Round both of the bottom corners. This produces the same result as using bit.bor(draw.rounding.bl, draw.rounding.br).

all

Round all corners. This produces the same result as using bit.bor(draw.rounding.tl, draw.rounding.tr, draw.rounding.bl, draw.rounding.br).

text_alignment

This enum determines how to align the text when drawing it.

left and top, as well as right and bottom are interchangeable. It means that if you use left for vertical alignment, it will produce exactly the same result as using top, and vice versa. top/bottom are here only for the sake of convenience and readability.

left

Align left. It will mean that the text position's X coordinate is located at the left side of the text area.

center

Align center. It will mean that the text position's X (or Y) coordinate is located at the center of the text area.

right

Align right. It will mean that the text position's X coordinate is located at the right side of the text area.

top

Align top. It will mean that the text position's Y coordinate is located at the top side of the text area.

bottom

Align bottom. It will mean that the text position's Y coordinate is located at the bottom side of the text area.

shadow_dir

This enum is used to determine shadow direction for add_shadow_line method.

up

The darkest side of the shadow will be at the bottom.

down

The darkest side of the shadow will be at the top.

left

The darkest side of the shadow will be on the left side.

right

The darkest side of the shadow will be on the right side.

render_mode

This enum is used to toggle rendering modes.

normal

Normal, opaque rendering. All polygons will get filled with color, and texture sampling will be fully supported. This is the default mode to render shapes in layer.

wireframe

Wireframe rendering. This means that the polygons will no longer be filled with color, nor texture sampling will ever work.

Managed

This type represents a managed object. You cannot create an instance of this type directly.

Every object, that inherits from this type, must be created before use. The rendering system will only create them automatically, if you happen to lose a device object (e.g. minimize the game window, and then restore it) and only if you add your objects to manage table in .

obj

Type:

Pointer to a GPU object. If this object is not created, this field will be nil. You can use the value of this field to pass it to directly for example, or if you (for whatever reason we don't recommend you doing) want to have a direct control over the pointer - cast it to FFI's cdata.

create

Creates a managed object in GPU memory.

You should create() an object only once. Invoking this method after the object was created will be meaningless.

Arguments

None.

Returns

Nothing.

Example

destroy

Destroys a managed object in GPU memory.

Never destroy a GPU object if it is being used in rendering (for example, when you have pushed some shape that uses a texture, and then destroyed that texture). This will lead to undefined behavior, and most likely, **crash the game **.

Arguments

None.

Returns

Nothing.

Example

svg_texture

This type represents an SVG texture object.

This type inherits type. All of its base methods and fields are also available in this type.

Passing invalid SVG data to the constructor will cause a crash. We will fix this issue in future updates.

__call

Constructs an SVG texture.

Arguments

Returns

Example

font_gdi

This type represents a font object. Internally, this type uses GDI library to rasterize font glyphs.

This type inherits type. All of its base methods and fields are also available in this type.

__call

Constructs a font object.

Arguments

Returns

Example

glyph_t

This type represents a glyph object.

codepoint

Type: int

Character codepoint.

size

Type: vec2

Glyph dimensions.

offset

Type: vec2

Glyph offset.

uv

Type: rect

UV rect on the texture atlas.

font_flags

This enum determines which flags a font object should possess. Setting those flags is only possible during type construction.

shadow

Adds a 1px shadow to font glyphs.

outline

Adds a 1px outline to font glyphs.

anti_alias

Enable antialiasing on font glyphs. This flag only works on GDI fonts.

no_dpi

Disable DPI scaling on this font. By default, font glyphs will be scaled in accordance to the global DPI scale.

no_kern

Disable glyph kerning on this font.

mono

Enables a strong hinting algorithm for rasterization. Only works on FreeType fonts.

light

Enables a light hinting algorithm for rasterization. Only works on FreeType fonts.

entity_list_t

This type represents an entity list.

Never save any entities you get from this list if you don't know what you are doing! You may be left with dangling pointers, which will inevitably lead to a crash.

for_each

Loops the entities.

Arguments

Returns

Nothing.

Example

for_each_z

Loops the entities in the reverse order.

Arguments

Returns

Nothing.

Example

entity_entry_t

Represents an entity entry.

entity

Type: <type>

Entity instance. Type depends on the list you get it from.

had_dataupdate

Type: bool

true if the client had received any updates to this entity at least once.

handle

Type: chandle<type>

Entity's handle. You may store this elsewhere if you need to have global access to an entity.

avatar

Type: texture

This field is only available on entries that use cs2_player_controller type.

Player's profile picture. Will be nil if was yet to be initialized.

schema_accessor_t

This type represents a special structure that references a certain field in the entity object.

You can check the returned type by using type() function.

Do not ever store an instance of this type anywhere but in a scope of an event because entity might be removed.

get

Returns the value.

Arguments

None.

Returns

Type

Description

<type>

Value.

Example

local health = player.m_iHealth:get();

set

Sets the value.

Arguments

Name

Type

Description

value

<type>

Value.

Returns

Nothing.

Example

player.m_iHealth:set(50); -- won't really do anything with the health

cs2_grenade_projectile

This type represents a grenade projectile.

This type inherits type. All of its base methods and fields are also available in this type.

get_abs_origin

Returns the absolute origin (the one that is used for rendering).

Arguments

None.

Returns

Example

get_grenade_type

Returns the grenade type.

Arguments

None.

Returns

Example

ccsweapon_base_vdata

This type represents a weapon's static data.

__index

Attemps to search for a field in this class.

Arguments

Returns

Example

cfiring_mode

Firing mode information.

values_arr

Type: <type>

Values.

chandle

This type represents an entity handle.

You can also compare this type using a == operator.

get

Returns the entity, or nil if nothing found.

Arguments

None.

Returns

Type

Description

<type>

Entity instance.

Example

local ent = handle:get();

valid

Returns true if the handle is valid.

Arguments

None.

Returns

Type

Description

bool

true if valid.

Example

if handle:valid() then
    -- ...
end

is_clientside

Returns true if the handle links to a client-side entity.

Arguments

None.

Returns

Type

Description

bool

true if client-sided.

Example

if handle:is_clientside() then
    -- ...
end

csweapon_mode

This enum represents the firing mode for a weapon.

primary_mode

Primary mode (usually left mouse button).

secondary_mode

Secondary mode (usually right mouse button).

csweapon_category

This enum represents the category classification for weapons in the game.

other

Represents weapons or items that don't fit into any specific category.

melee

Represents melee weapons, such as knives or other close-combat tools.

secondary

Represents secondary weapons, such as pistols.

smg

Represents submachine guns (SMGs).

rifle

Represents rifles, including assault rifles and sniper rifles.

heavy

Represents heavy weapons, such as machine guns and shotguns.

observer_mode_t

This enum represents the observer modes available in the game.

none

Represents no observer mode (not spectating anyone).

fixed

Represents a fixed camera position.

in_eye

Represents observing from the perspective of the player being spectated.

chase

Represents a chase camera that follows the player being spectated.

roaming

Represents a free-roaming camera.

directed

Represents an automatically directed camera, typically controlled by the game or server.

Types

In this section, the most common gui types are listed, that are not particularly bound to a specific part of the gui.

Use the left menu (or hamburger menu, if you are on mobile) to navigate between types.

control_id

This type represents a control ID.

__call

Constructs the ID structure.

Arguments

Returns

Example

id

Type: int

Hashed representation of the ID.

id_string

Type: string

Normal representation of the ID.

context

This type represents the GUI context.

find

Finds a control by ID.

Arguments

Name

Type

Description

id

string

Control ID.

Returns

Type

Description

<control>?

Casted control. Returns nil if the control was not found, or casting failed.

Example

local some_cb = ctx:find('some_cb');

user

Field

Type: user_t

User's basic information.

user_t

This type represents basic user information.

avatar

Type:

User's avatar. May be nil.

username

Type: string

User's username.

mouse_button

This enum represents mouse buttons.

left

Left mouse button.

right

Right mouse button.

middle

Middle (scroll wheel) mouse button

back

"Back" mouse button (side button 1).

forward

"Forward" mouse button (side button 2).

notification_system

This type represents a notification system.

add

Adds a notification to the list.

Arguments

Name

Type

Description

notif

Notification object.

Returns

Nothing.

Example

notif:add(my_notification);

notification

This type represents a notification item.

__call

Constructs the notification.

Arguments

Name

Type

Description

hdr

string

Header (title).

txt

string

Text (body).

ico

Icon. Defaults to nil.

Returns

Type

Description

notification

Notification object.

Example

local notif = gui.notification('Hello', 'Lua works!');

label

This type represents a label control.

This type inherits type. All of its base methods and fields are also available in this type.

__call

Constructs the label.

Arguments

Returns

Example

set_text

Sets the new text.

Arguments

Returns

Nothing.

Example

selectable

This type represents a selectable control.

This type inherits control type. All of its base methods and fields are also available in this type.

__call

Constructs the selectable.

Arguments

Name

Type

Description

id

Control ID.

str

string

Text string.

Returns

Type

Description

selectable

Selectable object.

Example

local sel = gui.selectable(id, 'Hello!');

button

This type represents a button control.

This type inherits control type. All of its base methods and fields are also available in this type.

__call

Constructs the button.

Arguments

Name

Type

Description

id

Control ID.

str

string

Text string.

Returns

Type

Description

button

Button object.

Example

local btn = gui.button(id, 'Hello!');

spacer

This type represents a spacer control.

This type inherits type. All of its base methods and fields are also available in this type.

__call

Constructs the spacer.

Arguments

Returns

Example

text_input

This type represents a text input control.

This type inherits type. All of its base methods and fields are also available in this type.

__call

Constructs the text input.

Arguments

Returns

Example

placeholder

Type: string

Placeholder text.

value

Type: string

Value.

set_value

Sets the new text.

Arguments

Returns

Nothing.

Example

image

This type represents an image control.

This type inherits type. All of its base methods and fields are also available in this type.

__call

Constructs the image.

Arguments

Returns

Example

math

Usage: math.{func}

This table extends the existing math table that is a part of Lua.

calc_angle

Function

Calculates angles between 2 vectors.

Arguments

Name

Type

Description

src

Source vector.

dst

Destination vector.

Returns

Type

Description

Angles.

Example

local ang = math.calc_angle(vec1, vec2);

angle_normalize

Function

Normalizes an angle.

Arguments

Name

Type

Description

angle

float

Input angle.

Returns

Type

Description

float

Normalized angle.

Example

local norm = math.angle_normalize(560);

approach_angles

Function

Approaches an angle over time.

Arguments

Name

Type

Description

from

Start angle.

to

End angle.

speed

float

Approach speed.

Returns

Type

Description

Delta angle.

Example

local ang = math.approach_angles(from, to, 1.0 / game.global_vars.frametime);

edge_point

Function

Returns a point on the edge of a box.

Arguments

Name

Type

Description

mins

Box mins.

maxs

Box maxs.

dir

Point direction (angle).

radius

float

Area radius.

Returns

Type

Description

Point.

Example

local point = math.edge_point(mins, maxs, dir, 5);

lerp

Function

Linear interpolation.

Arguments

Name

Type

Description

t1

float

Start value.

t2

float

End value.

progress

float

Interpolation amount.

Returns

Type

Description

float

Interpolated value.

Example

local mid = math.lerp(0, 100, 0.5);

vector_angles

Function

Calculates angles from a vector.

Arguments

Name

Type

Description

forward

Source vector.

up

Up vector. Defaults to nil.

Returns

Type

Description

Angles.

Example

local ang = math.vector_angles(fw);

world_to_screen

Function

Transforms a point in the game world onto the viewport.

Arguments

Name

Type

Description

xyz

Point in the world.

round

bool

Whether should round the output. Defaults to true.

Returns

Type

Description

Point on the viewport.

Example

local point = math.world_to_screen(game_point);

clamp

Function

Clamps a value between min and max.

Arguments

Name

Type

Description

n

float

Value.

lower

float

Lowest value.

upper

float

Highest value.

Returns

Type

Description

float

Clamped value.

Example

local x = math.clamp(50, 5, 25); -- 25

remap_val

Function

Maps the value from one range to another range.

Arguments

Name

Type

Description

val

float

Value.

a

float

Lowest source value.

b

float

Highest source value.

c

float

Lowest destination value.

d

float

Highest destination value.

Returns

Type

Description

float

Mapped value.

Example

local mapped = math.remap_val(0.5, 0, 1, 0, 100); -- 50

remap_val_clamped

Function

Maps the value from one range to another range. Additionally, clamps the value based on the source range.

Arguments

Name

Type

Description

val

float

Value.

a

float

Lowest source value.

b

float

Highest source value.

c

float

Lowest destination value.

d

float

Highest destination value.

Returns

Type

Description

float

Mapped value.

Example

local mapped = math.remap_val_clamped(5, 0, 1, 0, 100); -- 100

vec2

Function

An alias to draw.vec2().

Example

local vec = math.vec2(5, 5);

vec3

Function

An alias to vector().

Example

local vec = math.vec3(5, 12, 5);

context_input

This type represents the GUI input context.

You can use cursor, is_mouse_up, is_mouse_down, is_key_up and is_key_down methods outside input context. Using other methods will not make any sense, as the information will be outdated.

cursor

Returns current cursor position.

Arguments

None.

Returns

Type

Description

Cursor position.

Example

local cur = gui.input:cursor();

cursor_prev

Returns previous cursor position.

Arguments

None.

Returns

Type

Description

Previous cursor position.

Example

local prev = gui.input:cursor_prev();

cursor_delta

Delta value between previous and current cursor positions.

Arguments

None.

Returns

Type

Description

Cursor delta.

Example

local delta = gui.input:cursor_delta();

did_cursor_move

Returns true if the cursor did move since the last input.

Arguments

None.

Returns

Type

Description

bool

true if moved.

Example

if gui.input:did_cursor_move() then
    -- ...
end

did_wheel_move

Returns true if mouse scroll wheel did move since the last input.

Arguments

None.

Returns

Type

Description

bool

true if moved.

Example

if gui.input:did_wheel_move() then
    -- ...
end

did_process_mouse

Returns true if any mouse key's state had changed.

Arguments

None.

Returns

Type

Description

bool

true if processed.

Example

if gui.input:did_process_mouse() then
    -- ...
end

button_released

Returns true if any key was released since the last input.

Arguments

None.

Returns

Type

Description

bool

true if released.

Example

if gui.input:button_released() then
    -- ...
end

wheel_delta

Returns the amount of rows scrolled this input.

Arguments

None.

Returns

Type

Description

float

Rows scrolled.

Example

local scroll = gui.input:wheel_delta();

is_mouse_up

Returns true if the mouse key is up (depressed).

Arguments

Name

Type

Description

mb

Mouse button.

Returns

Type

Description

bool

true if depressed.

Example

if gui.input:is_mouse_up(gui.mouse_button.left) then
    -- ...
end

is_mouse_down

Returns true if the mouse key is down (pressed).

Arguments

Name

Type

Description

mb

Mouse button.

Returns

Type

Description

bool

true if pressed.

Example

if gui.input:is_mouse_down(gui.mouse_button.left) then
    -- ...
end

is_mouse_clicked

Returns true if the mouse key is clicked (switched from depressed to pressed state).

Arguments

Name

Type

Description

mb

Mouse button.

Returns

Type

Description

bool

true if clicked.

Example

if gui.input:is_mouse_clicked(gui.mouse_button.left) then
    -- ...
end

is_mouse_released

Returns true if the mouse key is released (switched from pressed to depressed state).

Arguments

Name

Type

Description

mb

Mouse button.

Returns

Type

Description

bool

true if released.

Example

if gui.input:is_mouse_released(gui.mouse_button.left) then
    -- ...
end

did_process_key

Returns true if any key's state had changed.

Arguments

None.

Returns

Type

Description

bool

true if state changed.

Example

if gui.input:did_process_key() then
    -- ...
end

is_key_up

Returns true if a key is up (depressed).

Arguments

Name

Type

Description

k

int

Virtual key.

Returns

Type

Description

bool

true if depressed.

Example

if gui.input:is_key_up(0x41) then -- 0x41 = "A"
    -- ...
end

is_key_down

Returns true if a key is down (pressed).

Arguments

Name

Type

Description

k

int

Virtual key.

Returns

Type

Description

bool

true if pressed.

Example

if gui.input:is_key_down(0x41) then -- 0x41 = "A"
    -- ...
end

is_key_clicked

Returns true if a key is clicked (switched from depressed to pressed state).

Arguments

Name

Type

Description

k

int

Virtual key.

Returns

Type

Description

bool

true if clicked.

Example

if gui.input:is_key_clicked(0x41) then -- 0x41 = "A"
    -- ...
end

is_key_released

Returns true if a key is released (switched from pressed to depressed state).

Arguments

Name

Type

Description

k

int

Virtual key.

Returns

Type

Description

bool

true if released.

Example

if gui.input:is_key_released(0x41) then -- 0x41 = "A"
    -- ...
end

rect

__call

Constructor

Creates a new rectangle.

Arguments

1. Default rectangle (0, 0 position; 0, 0 size).

None.

2. Single value.

Name

Type

Description

value

float

Mins XY, maxs XY value.

3. Single vector.

Name

Type

Description

value

Mins vector, maxs vector.

4. Double value.

Name

Type

Description

x

float

Mins/maxs X coordinate.

y

float

Mins/maxs Y coordinate.

5. Double vector.

Name

Type

Description

mins

Mins vector.

maxs

Maxs vector.

6. Four values.

Name

Type

Description

x0

float

Mins X coordinate.

y0

float

Mins Y coordinate.

x1

float

Maxs X coordinate.

y1

float

Maxs Y coordinate.

Returns

Type

Description

rect

New rectangle.

Example

local my_rect = draw.rect(50, 50, 150, 150);

mins

Field

Type: vec2

Mins (top-left) vector.

maxs

Field

Type: vec2

Maxs (bottom-right) vector.

width

Method

Either returns rectangle's width, or sets a new width.

Arguments

1. Get width.

None.

2. Set width.

Name

Type

Description

value

float

New width.

Returns

1. Get width.

Type

Description

float

Width.

2. Set width.

Type

Description

rect

New rectangle with changed width.

Example

local half_width = rect:width(rect:width() * 0.5);

height

Method

Either returns rectangle's height, or sets a new height.

Arguments

1. Get height.

None.

2. Set height.

Name

Type

Description

value

float

New height.

Returns

1. Get height.

Type

Description

float

Height.

2. Set height.

Type

Description

rect

New rectangle with changed height.

Example

local half_height = rect:height(rect:height() * 0.5);

size

Method

Either returns rectangle's size, or sets a new size.

Arguments

1. Get size.

None.

2. Set size.

Name

Type

Description

value

New size.

Returns

1. Get size.

Type

Description

Size.

2. Set size.

Type

Description

rect

New rectangle with changed size.

Example

local half_size = rect:size(rect:size() * draw.vec2(0.5, 0.5));

explode

Method

Explodes the rectangle by given vector (increase size from center into all directions by coordinates in the vector).

Arguments

Name

Type

Description

value

Explode size.

Returns

Type

Description

rect

Exploded rectangle.

Example

local exp = rect:explode(draw.vec2(6, 6)); -- will subtract -3,-3 from mins and add 3,3 to maxs

half_width

Method

Returns a rectangle with half of the width of this rectangle.

Arguments

None.

Returns

Type

Description

rect

Rectangle with halved width.

Example

local half = rect:half_width();

translate

Method

Translates (moves) this rectangle by vector coordinates.

Arguments

Name

Type

Description

value

Translation amount.

Returns

Type

Description

rect

Translated rectangle.

Example

local rect = draw.rect(50, 50, 150, 150);
local translated = rect:translate(draw.vec2(5, 5)); -- mins/maxs will be 55,55 and 155,155

margin_left

Method

Move rectangle from the left by given amount.

Arguments

Name

Type

Description

value

float

Margin amount.

Returns

Type

Description

rect

Moved rectangle.

Example

local new = rect:margin_left(5); -- moves to the right by 5px

margin_right

Method

Move rectangle from the right by given amount.

Arguments

Name

Type

Description

value

float

Margin amount.

Returns

Type

Description

rect

Moved rectangle.

Example

local new = rect:margin_right(5); -- moves to the left by 5px

margin_top

Method

Move rectangle from the top by given amount.

Arguments

Name

Type

Description

value

float

Margin amount.

Returns

Type

Description

rect

Moved rectangle.

Example

local new = rect:margin_top(5); -- moves to the bottom by 5px

margin_bottom

Method

Move rectangle from the bottom by given amount.

Arguments

Name

Type

Description

value

float

Margin amount.

Returns

Type

Description

rect

Moved rectangle.

Example

local new = rect:margin_bottom(5); -- moves to the top by 5px

padding_left

Method

Adds the value to the left side of the rectangle.

Arguments

Name

Type

Description

value

float

Padding amount.

Returns

Type

Description

rect

Resized rectangle.

Example

local new = rect:padding_left(5); -- adds 5 to mins x

padding_right

Method

Adds the value to the right side of the rectangle.

Arguments

Name

Type

Description

value

float

Padding amount.

Returns

Type

Description

rect

Resized rectangle.

Example

local new = rect:padding_right(5); -- adds 5 to maxs x

padding_top

Method

Adds the value to the top side of the rectangle.

Arguments

Name

Type

Description

value

float

Padding amount.

Returns

Type

Description

rect

Resized rectangle.

Example

local new = rect:padding_top(5); -- adds 5 to mins y

padding_bottom

Method

Adds the value to the bottom side of the rectangle.

Arguments

Name

Type

Description

value

float

Padding amount.

Returns

Type

Description

rect

Resized rectangle.

Example

local new = rect:padding_bottom(5); -- adds 5 to maxs y

shrink

Method

Shrinks (implodes) the rectangle by given amount.

Arguments

Name

Type

Description

value

float

Shrink value.

Returns

Type

Description

rect

Resized rectangle.

Example

local shrinked = rect:shrink(5); -- adds 5,5 to mins and subtracts 5,5 from maxs

expand

Method

Expands (explodes) the rectangle by given amount.

Arguments

Name

Type

Description

value

float

Expand value.

Returns

Type

Description

rect

Resized rectangle.

Example

local expanded = rect:expand(5); -- subtracts 5,5 from mins and adds 5,5 to maxs

contains

Method

Returns true if this rectangle contains either vector or another rectangle.

Rectangle overload will return true ONLY of entire other rectangle is within the bounds of this one.

Arguments

1. Vector variant.

Name

Type

Description

other

Vector to check against.

2. Rectangle variant.

Name

Type

Description

other

rect

Rectangle to check against.

Returns

Type

Description

bool

true if other object is in bounds of this rectangle.

Example

if rect:contains(cursor_pos) then
    -- ...
end

overlaps

Method

Returns true if the other rectangle overlaps with this rectangle.

Arguments

Name

Type

Description

other

rect

Rectangle to check against.

Returns

Type

Description

bool

true if other rectangle overlaps with this rectangle.

Example

if rect:overlaps(another_rect) then
    -- ...
end

intersect

Method

Intersects this rectangle with another rectangle.

Arguments

Name

Type

Description

other

rect

Rectangle to intersect with.

Returns

Type

Description

rect

Intersected rectangle.

Example

local intersected = rect:intersect(another_rect);

tl

Method

Returns top-left vector.

Arguments

None.

Returns

Type

Description

Top-left vector.

Example

local tl = rect:tl();

tr

Method

Returns top-right vector.

Arguments

None.

Returns

Type

Description

Top-right vector.

Example

local tr = rect:tr();

br

Method

Returns bottom-right vector.

Arguments

None.

Returns

Type

Description

Bottom-right vector.

Example

local br = rect:br();

bl

Method

Returns bottom-left vector.

Arguments

None.

Returns

Type

Description

Bottom-left vector.

Example

local bl = rect:bl();

center

Method

Returns center point of this rectangle.

Arguments

None.

Returns

Type

Description

Center point.

Example

local center = rect:center();

circle

Method

Treats this rectangle as an ellipsis and returns point on it. Note, that this "ellipsis" will be perfect with no modified curvature (basically if this rectangle is a box - you will get a point on a perfect circle).

Arguments

Name

Type

Description

r

float

Radians value.

Returns

Type

Description

Point on the ellipsis.

Example

local point = rect:circle(rad(250)); -- returns point on the 250th degree

floor

Method

Returns floored rectangle.

Arguments

None.

Returns

Type

Description

rect

Floored rectangle.

Example

local floored = rect:floor();

ceil

Method

Returns ceiled rectangle.

Arguments

None.

Returns

Type

Description

rect

Ceiled rectangle.

Example

local ceiled = rect:ceil();

round

Method

Returns rounded rectangle.

Arguments

None.

Returns

Type

Description

rect

Rounded rectangle.

Example

local rounded = rect:round();

is_zero

Method

Returns true if both mins and maxs are equal to 0.

Arguments

None.

Returns

Type

Description

bool

true if this is a zero rectangle.

Example

if rect:is_zero() then
    -- ...
end

Layer

A layer is a type that is used to store render commands, as well as vertex and index data. This is the only way to push shapes and control rendering state.

g

Type: command

The next render command to be pushed to the queue. This is the object you want to change to, for example, set a texture, or change rendering modes.

font

Type: font_base

Font to use with add_text. If nothing has been set, no text will get rendered.

tex_sz

Type: vec2?

Texture dimensions. This value is only required if you are trying to render rounded shapes with a texture, so the rendering system will correctly map your UV coordinates to whatever shape you are rendering.

skip_dpi

Type: bool

If set to true, will skip global DPI scale. Defaults to true.

add_triangle_filled

Adds a filled triangle with a single color.

Arguments

Name

Type

Description

a

A point.

b

B point.

c

C point.

col

Shape color.

Returns

Nothing.

Example

layer:add_triangle_filled(
    draw.vec2(50, 50), draw.vec2(25, 75),
    draw.vec2(75, 75), draw.color(255, 255, 255));

add_quad_filled

Adds a filled quad with a single color.

Arguments

Name

Type

Description

tl

Top left point.

tr

Top right point.

br

Bottom right point.

bl

Bottom left point.

col

Shape color.

Returns

Nothing.

Example

layer:add_quad_filled(
    draw.vec2(50, 50), draw.vec2(100, 60),
    draw.vec2(100, 100), draw.vec2(30, 70),
    draw.color(255, 255, 255));

add_rect_filled

Adds a filled rectangle with a single color.

Arguments

Name

Type

Description

r

Rectangle.

col

Shape color.

Returns

Nothing.

Example

layer:add_rect_filled(draw.rect(50, 50, 150, 150), draw.color(255, 255, 255));

add_circle_filled

Adds a filled circle with a single color.

Arguments

Name

Type

Description

center

Center point.

radius

float

Circle radius.

c

Shape color.

segments

int

Circle segments. If set to 0, will attempt automatic segment deduction. Defaults to 0.

fill

float

Fill amount (clockwise, 0 to 1). Defaults to 1.

Returns

Nothing.

Example

layer:add_circle_filled(draw.vec2(50, 50), 10, draw.color(255, 255, 255));

add_triangle_filled_multicolor

Adds a filled, multicolor triangle.

Arguments

Name

Type

Description

a

A point.

b

B point.

c

C point.

cols

table[color, color, color]

Colors for each point. Colors go in the very same order as the parameter list.

Returns

Nothing.

Example

layer:add_triangle_filled_multicolor(
     draw.vec2(50, 50), draw.vec2(25, 75),
     draw.vec2(75, 75), {
        draw.color(255, 0, 0),
        draw.color(0, 255, 0),
        draw.color(0, 0, 255)
     });

add_rect_filled_multicolor

Adds a filled, multicolor rectangle.

Arguments

Name

Type

Description

r

Rectangle.

cols

table[color, color, color, color]

Colors for each corner of the rectangle, in clockwise order starting from top-left.

Returns

Nothing.

Example

layer:add_rect_filled_multicolor(
    draw.rect(50, 50, 150, 150), {
        draw.color(255, 0, 0),
        draw.color(0, 255, 0),
        draw.color(0, 0, 255),
        draw.color(255, 255, 0)
    });

add_circle_filled_multicolor

Adds a filled, multicolor circle.

Arguments

Name

Type

Description

center

Center point.

radius

float

Circle radius.

cols

table[color, color]

Colors for the gradient, starting with the inner and ending with the outer color.

segments

int

The number of segments to approximate the circle. Defaults to 36.

fill

float

The portion of the circle to fill, where 1.0 is a full circle. Defaults to 1.0.

Returns

Nothing.

Example

layer:add_circle_filled_multicolor(
    draw.vec2(100, 100), 50, {
        draw.color(255, 0, 0),
        draw.color(0, 0, 255)
    }, 36, 1.0);

add_quad_filled_multicolor

Adds a filled, multicolor quad.

Arguments

Name

Type

Description

tl

Top left point.

tr

Top right point.

br

Bottom right point.

bl

Bottom left point.

cols

table[color, color]

Colors for the gradient, applied from bottom to top.

Returns

Nothing.

Example

layer:add_quad_filled_multicolor(
    draw.vec2(50, 50), draw.vec2(150, 50),
    draw.vec2(150, 150), draw.vec2(50, 150), {
        draw.color(255, 0, 0),
        draw.color(0, 0, 255)
    });

add_pill_multicolor

Adds a multicolor pill shape.

Arguments

Name

Type

Description

mins

Top left point of the pill.

maxs

Bottom right point of the pill.

radius_min

float

The minimum radius of the pill's rounded edges.

radius_max

float

The maximum radius of the pill's rounded edges.

cols

table[color, color]

Colors for the gradient, applied from bottom to top.

segments

int

The number of segments for approximating rounded edges. Defaults to 16.

Returns

Nothing.

Example

layer:add_pill_multicolor(
    draw.vec2(50, 50), draw.vec2(150, 100),
    10, 20, {
        draw.color(255, 0, 0),
        draw.color(0, 0, 255)
    }, 16);

add_shadow_line

Adds a shadow line.

Arguments

Name

Type

Description

r

Bounding box for the shadow line.

dir

Shadow direction.

a

float

Max opacity. Defaults to 0.25.

Returns

Nothing.

Example

layer:add_shadow_line(
    draw.rect(50, 50, 150, 150), draw.shadow_dir.down, 0.25);

add_shadow_rect

Adds a shadowed rectangle.

Arguments

Name

Type

Description

r

Rectangle.

radius

float

Shadow distance, in pixels, outwards.

bg

bool

Whether to draw a background for the rectangle. Defaults to true.

a

float

Max opacity of the shadow. Defaults to 0.25.

Returns

Nothing.

Example

layer:add_shadow_rect(
    draw.rect(50, 50, 150, 150), 15, true, 0.25);

add_glow

Adds a glow box.

Arguments

Name

Type

Description

r

Box rectangle.

radius

float

Glow distance, in pixels, outwards.

c

Glow color.

parts

Parts of the glow to enable. Defaults to all.

Returns

Nothing.

Example

layer:add_glow(draw.rect(50, 50, 150, 150), 15, draw.color(255, 0, 0));

add_rect_filled_rounded

Adds a filled, rounded rectangle.

Arguments

Name

Type

Description

r

Rectangle.

c

Fill color.

amount

float

Rounding amount.

rnd

Rounding mode. Defaults to all.

Returns

Nothing.

Example

layer:add_rect_filled_rounded(
    draw.rect(50, 50, 150, 150),
    draw.color(255, 0, 0),
    10,
    draw.rounding.all
);

add_rect_filled_rounded_multicolor

Adds a filled, multicolor rounded rectangle.

Arguments

Name

Type

Description

r

Rectangle.

c

table[color, color, color, color]

Fill colors. Used clockwise, starting from top left.

amount

float

Rounding amount.

rnd

Rounding mode. Defaults to all.

Returns

Nothing.

Example

layer:add_rect_filled_rounded_multicolor(
    draw.rect(50, 50, 150, 150), {
        draw.color(255, 0, 0),
        draw.color(0, 255, 0),
        draw.color(0, 0, 255),
        draw.color(255, 255, 0)
    },
    10,
    draw.rounding.all
);

add_triangle

Adds a stroked triangle.

Arguments

Name

Type

Description

a

Point A.

b

Point B.

c

Point C.

col

Line color.

thickness

float

Line thickness. Defaults to 1.0.

mode

Outline mode. Defaults to inset.

Returns

Nothing.

Example

layer:add_triangle(
    draw.vec2(50, 50),
    draw.vec2(25, 75),
    draw.vec2(75, 75),
    draw.color(255, 0, 0),
    1.0,
    draw.outline_mode.inset
);

add_quad

Adds a stroked quad.

Arguments

Name

Type

Description

tl

Top-left point.

tr

Top-right point.

br

Bottom-right point.

bl

Bottom-left point.

c

Line color.

thickness

float

Line thickness. Defaults to 1.0.

mode

Outline mode. Defaults to inset.

Returns

Nothing.

Example

layer:add_quad(
    draw.vec2(50, 50),
    draw.vec2(150, 50),
    draw.vec2(150, 150),
    draw.vec2(50, 150),
    draw.color(255, 0, 0),
    1.0,
    draw.outline_mode.inset
);

add_rect

Adds a stroked rectangle.

Arguments

Name

Type

Description

r

Rectangle.

c

Line color.

thickness

float

Line thickness. Defaults to 1.0.

mode

Outline mode. Defaults to inset.

Returns

Nothing.

Example

layer:add_rect(
    draw.rect(50, 50, 150, 150),
    draw.color(255, 0, 0),
    1.0,
    draw.outline_mode.inset
);

add_circle

Adds a stroked circle.

Arguments

Name

Type

Description

center

Center point.

radius

float

Circle radius.

c

Line color.

segments

int

Circle segments. Defaults to 36.

fill

float

Fill amount. Defaults to 1.0.

thickness

float

Line thickness. Defaults to 1.0.

mode

Outline mode. Defaults to inset.

Returns

Nothing.

Example

layer:add_circle(
    draw.vec2(100, 100),
    50,
    draw.color(255, 0, 0),
    36,
    1.0,
    1.0,
    draw.outline_mode.inset
);

add_line

Adds a line.

Arguments

Name

Type

Description

a

Start point.

b

End point.

c

Line color.

thickness

float

Line thickness. Defaults to 1.0

Returns

Nothing.

Example

layer:add_line(
    draw.vec2(50, 50),
    draw.vec2(150, 150),
    draw.color(255, 0, 0)
);

add_line_multicolor

Adds a multicolor line.

Arguments

Name

Type

Description

a

Start point.

b

End point.

c

Start color.

c2

End color.

thickness

float

Line thickness. Defaults to 1.0.

Returns

Nothing.

Example

layer:add_line_multicolor(
    draw.vec2(50, 50),
    draw.vec2(150, 150),
    draw.color(255, 0, 0),
    draw.color(0, 0, 255),
    2.0
);

add_rect_rounded

Adds a rounded, filled rectangle.

Arguments

Name

Type

Description

r

Rectangle.

c

Line color.

amount

float

Rounding amount.

rnd

Rounding mode. Defaults to all.

thickness

float

Line thickness. Defaults to 1.0.

mode

Outline mode. Defaults to inset.

Returns

Nothing.

Example

layer:add_rect_rounded(draw.rect(50, 50, 150, 150),
    draw.color(255, 255, 255), 14);

add_text

Adds text.

If font wasn't set, this function will do nothing.

You can control the color while rendering the text. To change the color, add \fRRGGBBAA to the string. To reset the color, add \b.

Arguments

Name

Type

Description

p

Text origin point.

text

string

Text.

c

Text color.

params

Text aligning parameters. Defaults to nil.

Returns

Nothing.

Example

layer:add_text(draw.vec2(50, 50), 'Hello world!', draw.color(255, 255, 255));

override_clip_rect

Overrides clip rectangle with support of intersection.

Arguments

Name

Type

Description

r

New clip rect.

intersect

bool

Whether this function should intersect previous rect with the new one. Defaults to true.

Returns

Nothing.

Example

layer:override_clip_rect(draw.rect(50, 50, 150, 150));

CS2 Lua API

Overview

Official lua API documentation for fatality.win​

Introduction

Creating scripts

Welcome to the basics of scripting with our API.

Basic Concepts

Documentation Overview

Labels:

Argument and return lists

Types

Rules﻿

You Control the Lua State﻿

Prioritize Safety﻿

Keep the Software Usable﻿

First Steps

Fire up a text editor﻿

Writing your first script﻿

Defining a callback function﻿

Accessing drawing layer﻿

Setting a font﻿

Drawing text﻿

Registering a callback﻿

Result﻿

Adding UI

Adding UI﻿

Creating a control﻿

Constructing the row﻿

Adding the row to a group﻿

Using the value﻿

Creating Libraries

Workshop

Getting Started

Core Concepts

Next Steps

Guidelines

1. Provide meaningful descriptions

2. Maintain a minimum quality standard

3. Respect capability requests

4. Practice fair market behavior

5. Do not publish malicious code

6. Ensure compatibility with existing features

7. Keep content respectful

8. Maintain and update your items

9. Be transparent with monetization

10. Respect licensing and attribution

Publishing Tool

Step By Step Guide

Create the item

Upload a build

Configure capabilities

Prepare the Storefront listing

Updating Items

Upload a new build & wait for approval

Set build active

Branches

Creating a branch

Managing Builds

Libraries & Dependencies

Creating a Library

Referencing Libraries

Bundled Assets

API

Global Functions

print﻿

Arguments

error﻿

Arguments

Instances

event_t

add﻿

remove﻿

game

global_vars﻿

engine﻿

input﻿

input_system﻿

game_ui_funcs﻿

global_vars_t

real_time﻿

Official lua API documentation for fatality.win

Rules

You Control the Lua State

Prioritize Safety

Keep the Software Usable

Fire up a text editor

Writing your first script

Defining a callback function

Accessing drawing layer

Setting a font

Drawing text

Registering a callback

Result

Adding UI

Creating a control

Constructing the row

Adding the row to a group

Using the value

print

error

add

remove

global_vars

engine

input

input_system

game_ui_funcs

real_time

frame_count

abs_frame_time

max_clients

ticks_this_frame

frame_time

cur_time

tick_fraction

tick_count

map_path

map_name

in_third_person

get_view_angles

set_view_angles

vk_to_button_code

get_binding_for_button_code

find

name

description

flags

value

events

add_listener

get_back_buffer

get_back_buffer_downsampled

get_shared_texture

inset

outset

center

rounding

tl

tr

bl

br

t

l

r

b

all

left

center

right

top

bottom

up

down

left

right

normal

wireframe

obj

create

destroy