Potassium Pro

https://docs.potassium.pro/
Admin
Potassium Pro is a comprehensive Luau standard library environment for game development, providing...
Tokens:48,587
Snippets:493
Trust Score:5.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Write File Example

Source: https://docs.potassium.pro/api-reference/FileSystem Library/writefile

This example demonstrates how to write the current server time to a file named 'test.txt' in the workspace directory.

```lua
writefile("test.txt", tostring(workspace:GetServerTimeNow()))
```

--------------------------------

### Print Environment of a Script

Source: https://docs.potassium.pro/api-reference/Environment Library/getsenv

This example demonstrates how to get the environment of the first running script and print its contents. Ensure a script is running before executing.

```lua
local script = getrunningscripts()[1]
table.foreach(getsenv(script), print)
```

--------------------------------

### Example Usage of rconsoledestroy

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoledestroy

Demonstrates how to create, print to, destroy, and then recreate the console. This effectively clears the console and starts a new output session.

```lua
rconsolecreate()
rconsoleprint("Hello, world!\n")

rconsoledestroy() -- Destroy console and clear old messages.

rconsolecreate()
rconsoleprint("Hello, world! Again!\n")
```

--------------------------------

### SaveInstance Example

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/saveinstance

Example of how to use the saveinstance function to save the entire game with decompilation enabled and a specified number of threads.

```lua
saveinstance(game, {
    FileName = "game.rbxl",
    Decompile = true,
    MaxThreads = 5 -- Adjust depending on PC specs
})
```

--------------------------------

### Send Packet Example

Source: https://docs.potassium.pro/api-reference/RakNet Library/raknet.add_send_hook

This example demonstrates how to send a packet using raknet.send. Ensure RakNet is enabled in the internal UI settings before use. Bans may occur from misuse.

```lua
local buf = buffer.create(2);
buffer.writeu8(buf, 1, 123);

raknet.send(buf, 1, 0, 0)
```

--------------------------------

### Create Console and Print Message

Source: https://docs.potassium.pro/api-reference/Console Library/rconsolecreate

This example demonstrates creating a console and then printing a message to it using rconsoleprint.

```lua
rconsolecreate()
rconsoleprint("Hello, world!\n")
```

--------------------------------

### Example: Press and Release 'H' Key

Source: https://docs.potassium.pro/api-reference/Input Library/keyrelease

This example shows how to press and then release the 'H' key. A short delay is included to allow the user to focus Roblox before the key events are processed.

```lua
task.wait(1) -- Give the user time to put roblox in focus.

local H_KEYCODE = 0x48

keypress(H_KEYCODE)
task.wait()
keyrelease(H_KEYCODE)
```

--------------------------------

### Example Usage of getpcd

Source: https://docs.potassium.pro/api-reference/Reflection Library/getpcd

This example demonstrates how to call the `getpcd` function with a new UnionOperation instance and prints the returned hash and binary data to the console. This is useful for testing or inspecting the function's output.

```lua
print(getpcd(Instance.new("UnionOperation")))

```

--------------------------------

### Example of setnamecallmethod

Source: https://docs.potassium.pro/api-reference/Metatable Library/setnamecallmethod

Demonstrates how to get the current namecall method, set a new one using `setnamecallmethod`, and then verify the change. It also shows calling the raw metatable's `__namecall` method.

```lua
game:GetFullName()
print(getnamecallmethod()) --> GetFullName

setnamecallmethod("getFullName")
print(getnamecallmethod()) --> getFullName

print(getrawmetatable(game).__namecall(game)) --> Ugc

```

--------------------------------

### Get Raw Metatable Example

Source: https://docs.potassium.pro/api-reference/Metatable Library/getrawmetatable

Demonstrates the difference between getmetatable and getrawmetatable. getmetatable returns the value of __metatable if set, while getrawmetatable always returns the actual metatable.

```lua
local t = setmetatable({}, {
  __index = function(self, index) 
      print(index)
  end,
  __metatable = "This table is locked."
})

print(getmetatable(t)) --> This table is locked.
print(getrawmetatable(t)) --> table: 0x.....
```

--------------------------------

### Iterate and Print Scripts

Source: https://docs.potassium.pro/api-reference/Script Library/getscripts

This example demonstrates how to iterate through all scripts obtained from the getscripts function and print each one.

```lua
for _, script in getscripts() do
    print(script)
end
```

--------------------------------

### Example Usage of getgenv

Source: https://docs.potassium.pro/api-reference/Environment Library/getgenv

Demonstrates how to use getgenv to store and retrieve a value, preventing a script from running multiple times.

```lua
local alreadyRan = getgenv().alreadyRan

if alreadyRan then
    print("Already ran!")
else
    print("Hello, world!")
    getgenv().alreadyRan = true
end
```

--------------------------------

### Example of Clearing Teleport Queue

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/clearteleportqueue

This example demonstrates how to use `queueonteleport` to queue a function and then immediately clear it using `clearteleportqueue`. No code will be executed after the teleport is initiated because the queue is cleared.

```lua
queueonteleport([[
    print("Hello, world!")
]])

-- No code will be executed after teleport
clearteleportqueue()
```

--------------------------------

### Example Usage of MessageBox

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/messagebox

Demonstrates how to use the `messagebox` function with warning and cancel/try/continue flags. It shows how to interpret the return value to determine user input.

```lua
local MB_ICONWARNING = 0x00000030
local MB_CANCELTRYCONTINUE = 0x00000006
local MB_DEFBUTTON2 = 0x00000100

local IDCANCEL = 0x00000002
local IDTRYAGAIN = 0x0000000A
local IDCONTINUE = 0x0000000B

local input = messagebox(
	"?",
	"Resource not found",
	bit32.bor(MB_ICONWARNING, MB_CANCELTRYCONTINUE, MB_DEFBUTTON2)
)

if input == IDCANCEL then
    print("IDCANCEL")
elseif input == IDTRYAGAIN then
    print("IDTRYAGAIN")
elseif input == IDCONTINUE then
    print("IDCONTINUE")
end
```

--------------------------------

### Connect a callback to a PsmSignal and fire it

Source: https://docs.potassium.pro/api-reference/PsmSignal Library/PsmSignal.new

This example demonstrates creating a signal, connecting a callback to fire only once using `Once`, and then firing the signal. The callback will execute when `Fire` is called.

```lua
local signal = PsmSignal.new()

signal:Once(function()
    print("Signal fired!")
end)

signal:Fire()
```

--------------------------------

### Create Console and Print Message

Source: https://docs.potassium.pro/api-reference/Console%20Library/rconsolecreate

This example demonstrates creating a console and then printing a message to it using rconsoleprint. Ensure rconsolecreate is called before attempting to print.

```lua
rconsolecreate()
rconsoleprint("Hello, world!\n")

```

--------------------------------

### Disable a Player Idled Connection

Source: https://docs.potassium.pro/api-reference/Signal Library/getconnections

This example demonstrates how to get the first connection for the LocalPlayer's Idled signal and then disable it, preventing the player from being marked as idle.

```lua
local connection = getconnections(game.Players.LocalPlayer.Idled)[1]
connection:Disable()
```

--------------------------------

### Example: Drawing Circles and Clearing Cache

Source: https://docs.potassium.pro/api-reference/Drawing Library/cleardrawcache

This example demonstrates drawing multiple circle objects and then using cleardrawcache to remove them all from the cache simultaneously. It's useful for scenarios where you need to refresh the entire drawing canvas.

```lua
for i = 1, 10 do
    local circle = Drawing.new("Circle")
    circle.Radius = 50
    circle.Color = Color3.fromRGB(255, 0, 0)
    circle.Filled = true
    circle.NumSides = 32
    circle.Position = Vector2.new(100 * i, 100)
    circle.Transparency = 0.7
    circle.Visible = true
end

task.wait(1)

cleardrawcache()
```

--------------------------------

### Get All Instances

Source: https://docs.potassium.pro/api-reference/Instance Library/getinstances

This function returns a table containing all instances in the game. It requires no arguments.

```lua
function getinstances(): { Instance }
```

--------------------------------

### Example Usage of makereadonly

Source: https://docs.potassium.pro/api-reference/Metatable Library/makereadonly

Demonstrates how to use makereadonly to protect a table from modification. Attempts to change a value in the read-only table will result in an error.

```lua
local protected = { foo = "bar" }

makereadonly(protected) -- Equivalent to setreadonly(protected, true) or table.freeze(protected)

protected.foo = "test" --> attempt to modify a readonly table

```

--------------------------------

### Replicate Player Kill Event

Source: https://docs.potassium.pro/api-reference/Signal Library/replicatesignal

This example shows how to use replicatesignal to fire a player's Kill signal without any additional arguments.

```lua
local player = game.Players.LocalPlayer

replicatesignal(player.Kill)
```

--------------------------------

### Example Usage of Crypt Library Hash Function

Source: https://docs.potassium.pro/api-reference/Crypt%20Library/crypt.lz4decompress

Demonstrates how to use the crypt.hash function to generate hashes for a username using a list of supported algorithms. Ensure the 'crypt' library is available in your environment.

```lua
local data = game:GetService("Players").LocalPlayer.Character.Name
print("Username:", data)

local hashAlgorithmList = {
    "md5", 
    "sha256", 
    "sha1", 
    "sha384", 
    "sha512", 
    "sha3-224", 
    "sha3-256",
    "sha3-384", 
    "sha3-512", 
    "sha224"
}

for _, algorithm in hashAlgorithmList do
    print(algorithm .. ":", crypt.hash(data, algorithm))
end
```

--------------------------------

### Example Usage of firesignal

Source: https://docs.potassium.pro/api-reference/Signal Library/firesignal

Connects a function to the LocalPlayer's Idled signal and then fires it using the firesignal function.

```lua
local localPlayer = game.Players.LocalPlayer

localPlayer.Idled:Connect(function()
    print("Fired!")
end)

firesignal(localPlayer.Idled)
```

--------------------------------

### Get All Instances

Source: https://docs.potassium.pro/api-reference/Instance Library/getinstances

Returns a table containing all instances in the game. This can be used to access and manipulate various game objects.

```APIDOC
## getinstances

### Description
Returns a table of every instance in the game.

### Method Signature
```lua
function getinstances(): { Instance }
```

### Example
This script will print every instance in the game.

```lua
for _, instance in getinstances() do
    print(instance)
end
```
```

--------------------------------

### Iterate and Print Potassium Threads

Source: https://docs.potassium.pro/api-reference/Closure Library/isourthread

This example demonstrates how to iterate through all available threads and print only those created by Potassium using the isourthread function.

```lua
for _, thread in getallthreads() do
    if isourthread(thread) then
        print(thread)
    end
end
```

--------------------------------

### Iterate and Print Script Closures

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptclosure

This example demonstrates how to iterate through all currently running scripts and print the main function (closure) of each one. This can be useful for debugging or introspection.

```lua
for _, script in getrunningscripts() do
    print(getscriptclosure(script))
end
```

--------------------------------

### Iterate and Print Scripts From Threads

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptfromthread

This example iterates through all available threads, retrieves the associated script for each, and prints the script if it exists. Ensure threads are properly managed before iteration.

```lua
for _, thread in getallthreads() do
    local script = getscriptfromthread(thread)
    if script then
        print(script)
    end
end
```

--------------------------------

### Example Usage of FireClickDetector

Source: https://docs.potassium.pro/api-reference/Instance Library/fireclickdetector

Demonstrates how to set up a ClickDetector and use the fireclickdetector function to trigger its 'MouseClick' and 'RightMouseClick' signals. The default signal is 'MouseClick'.

```lua
local part = Instance.new("Part")
local clickdetector = Instance.new("ClickDetector", part)

clickdetector.MouseClick:Connect(function()
    print("fired MouseClick")
end)

clickdetector.RightMouseClick:Connect(function()
    print("fired RightMouseClick")
end)

fireclickdetector(clickdetector) -- Will fire "MouseClick"
task.wait(1)
fireclickdetector(clickdetector, 0, "RightMouseClick")
```

--------------------------------

### Print Bytecode of Animate Script

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptbytecode

This example iterates through all running scripts, identifies the 'Animate' script within the player's character, and prints its bytecode.

```lua
for _, script in getrunningscripts() do
    if script.Name == "Animate" then
        print(getscriptbytecode(script))
    end
end
```

--------------------------------

### Example: Anti-AFK Script using GetConnection

Source: https://docs.potassium.pro/api-reference/Signal Library/getconnection

This script demonstrates a common use case for getconnection: creating an anti-AFK system. It disables the 'Idled' signal to prevent the player from being kicked for inactivity.

```lua
local connection = getconnection(game.Players.LocalPlayer.Idled, 1)
connection:Disable()
```

--------------------------------

### Replicate Mouse Click Event

Source: https://docs.potassium.pro/api-reference/Signal Library/replicatesignal

This example demonstrates how to use replicatesignal to replicate a mouse click event on a ClickDetector, passing player and a numeric argument.

```lua
local clickDetector = Instance.new("ClickDetector")
local player = game.Players.LocalPlayer

replicatesignal(clickDetector.MouseActionReplicated, player, 0)
```

--------------------------------

### Example Usage of get_comm_channel

Source: https://docs.potassium.pro/api-reference/Actor Library/get_comm_channel

Demonstrates how to create a communication channel, connect an event listener, and then fire an event from another actor using get_comm_channel. Ensure the 'id' is correctly passed when running code on a different actor.

```lua
local id, channel = create_comm_channel()
channel.Event:Connect(function(data)
    print(data)
end)

run_on_actor(getactors()[1], [[
    local id = ...
    local channel = get_comm_channel(id)
    channel:Fire("Hello, World!")
]], id)
```

--------------------------------

### Example Usage of Lua loadstring

Source: https://docs.potassium.pro/api-reference/Closure Library/loadstring

Demonstrates creating and executing chunks using loadstring. The first chunk prints a message, while the second intentionally errors.

```lua
local source = "print('Hello, world!')"
local chunk = loadstring(source, "hello")
chunk() --> Hello, world!

source = "error('Goodbye, world!')"
chunk = loadstring(source, "goodbye")
chunk() --> Error: Goodbye, world!
```

--------------------------------

### Iterate and Print Whitelisted Signals

Source: https://docs.potassium.pro/api-reference/Signal Library/getsignalwhitelist

This example demonstrates how to iterate through the whitelist returned by getsignalwhitelist and print the parent and event names of each whitelisted signal.

```lua
local whitelist = getsignalwhitelist()
for _, signal in whitelist do
    print(string.format("%s.%s", signal.Parent, signal.Event))
end
```

--------------------------------

### Get Roblox Global Environment

Source: https://docs.potassium.pro/api-reference/Environment Library/getrenv

This is the function signature for getrenv. It returns the global environment table.

```lua
function getrenv(): { any }
```

--------------------------------

### Hooking a function with hookfunction

Source: https://docs.potassium.pro/api-reference/Closure%20Library/hookfunction

This example demonstrates how to hook the global 'print' function. If 'Hello, world!' is passed to print, it will instead trigger a warning. Otherwise, the original print behavior is preserved. The original function is stored in 'old' to allow calling it.

```lua
function hookfunction(target: function, hook: function): function
```
```

```lua
local old = nil
old = hookfunction(print, function(...)
    if select(1, ...) == "Hello, world!" then
        return warn(...)
    end

    return old(...)
end)

print("Hello, world!") -- This will be a warning.
print("Goodbye, world!") -- This will be a print.
```

--------------------------------

### Get All Scripts

Source: https://docs.potassium.pro/api-reference/Script Library/getscripts

This function returns a table of every script in the game. It is useful for iterating through all available scripts.

```lua
function getscripts(): { BaseScript }
```

--------------------------------

### Example Usage of getnamecallmethod

Source: https://docs.potassium.pro/api-reference/Metatable Library/getnamecallmethod

Demonstrates how to use `getnamecallmethod` within an `xpcall` to print the namecall method when an error occurs during a game method call.

```lua
xpcall(function()
  return game:method()
end, function()
  print(getnamecallmethod()) --> method
end)

```

--------------------------------

### Example Usage of isrenderobj

Source: https://docs.potassium.pro/api-reference/Drawing Library/isrenderobj

Demonstrates how to use isrenderobj to check if a Circle is a DrawingObject (true) and if a standard Instance is a DrawingObject (false).

```lua
local circle = Drawing.new("Circle")
local part = Instance.new("Part")

print(isrenderobj(circle))
print(isrenderobj(part))
```

--------------------------------

### Clear Console - Lua

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoleclear

This example demonstrates how to create a console, print a message, wait for a short duration, and then clear the console using rconsoleclear().

```lua
rconsolecreate()
rconsoleprint("Goodbye, world!\n")
task.wait(1)
rconsolewarn("Clearing console...")
task.wait(1)
rconsoleclear()
```

--------------------------------

### Hooking a Function with Custom Logic

Source: https://docs.potassium.pro/api-reference/Closure Library/hookfunction

This example demonstrates how to hook the built-in 'print' function. If the argument is 'Hello, world!', it triggers a warning; otherwise, it proceeds with the original print behavior. The original function is stored to be called conditionally.

```lua
local old = nil
old = hookfunction(print, function(...)
    if select(1, ...) == "Hello, world!" then
        return warn(...)
    end

    return old(...)
end)

print("Hello, world!") -- This will be a warning.
print("Goodbye, world!") -- This will be a print.
```

--------------------------------

### DrawingImmediate Circle Example

Source: https://docs.potassium.pro/api-reference/DrawingImmediate Library/DrawingImmediate.GetPaint

This script demonstrates how to use DrawingImmediate.GetPaint to continuously render a circle at the mouse position. It connects to the paint signal and draws a circle every render step.

```lua
local signal = DrawingImmediate.GetPaint(1)
local uis = game:GetService("UserInputService")

signal:Connect(function()
    local mousepos = uis:GetMouseLocation()

    DrawingImmediate.Circle(mousepos, 100, Color3.new(1, 1, 1), 1, 100, 1)
end)
```

--------------------------------

### Get PhysicalConfigData Hash and Binary

Source: https://docs.potassium.pro/api-reference/Reflection Library/getpcd

This function retrieves the 16-byte hash and binary data for the PhysicalConfigData property of a given TriangleMeshPart instance. It is aliased as `getpcdprop`. Use this when you need to access the raw configuration data.

```lua
function getpcd(trianglemeshpart: Instance): string, string
```

--------------------------------

### Iterate and Print Script Name

Source: https://docs.potassium.pro/api-reference/Script Library/getrunningscripts

This example iterates through all running scripts and prints the name of the parent of any script named 'Animate'. This is useful for finding specific scripts by name.

```lua
for _, script in getrunningscripts() do
    if script.Name == "Animate" then
        print(script.Parent.Name)
    end
end
```

--------------------------------

### Get All Properties of an Instance

Source: https://docs.potassium.pro/api-reference/Reflection Library/getproperties

Iterates through all properties of the 'workspace' instance and prints each property name and its value. This is useful for inspecting the state of an object.

```lua
function getproperties(instance: Instance): { property: value }

```

```lua
for property, value in getproperties(workspace) do
    print(property, value)
end
```

--------------------------------

### Get Thread Identity

Source: https://docs.potassium.pro/api-reference/Script Library/getthreadidentity

This function returns the current thread's identity. Aliases include getidentity, getthreadcontext, get_thread_identity, and getthreadcaps. The example shows how to print the identity.

```lua
function getthreadidentity(): number
```

```lua
print(getthreadidentity()) --> 8 (without previous changes)
```

--------------------------------

### Set FPS Cap

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/setfpscap

Sets the frames per second cap for the client. Use a very large value to effectively uncap the frame rate. This example bypasses the default 240fps cap.

```lua
print(setfpscap(2000))
```

--------------------------------

### Example: Hooking __newindex

Source: https://docs.potassium.pro/api-reference/Metatable Library/hookmetamethod

Demonstrates how to use hookmetamethod to intercept '__newindex' calls. The hook prevents changes to the 'game' object and ignores calls not made by the executor.

```lua
local old = nil
old = hookmetamethod(game, "__newindex", function(self, index, value)
  if not checkcaller() then --> Ignore non-executor newindex calls
      return old(self, index, value)
  end

  if value == game then --> Prevent any changes from being made to game
      return nil
  end

  return old(self, index, value)
end)

local objectValue = Instance.new("ObjectValue")
objectValue.Value = workspace
print(objectValue.Value) --> Workspace

objectValue.Value = game
print(objectValue.Value) --> Workspace
```

--------------------------------

### Making a Table Writable

Source: https://docs.potassium.pro/api-reference/Metatable Library/makewritable

Demonstrates how to make a read-only table writable using `makewritable`. It shows that direct modification fails on a frozen table but succeeds after calling `makewritable`. The example also shows how to re-freeze the table.

```lua
function makewritable(table: table): ()
end
```

```lua
local protected = table.freeze({ foo = "bar" })

print(pcall(function() protected.bar = "foo" end)) --> false, attempt to modify a readonly table

makewritable(protected) -- Equivalent to setreadonly(protected, false)

protected.bar = "foo"
print(protected.bar, table.isfrozen(protected)) --> foo, false

makereadonly(protected) -- Equivalent to setreadonly(protected, true) or table.freeze(protected)
```

--------------------------------

### Get BinaryString Property Value

Source: https://docs.potassium.pro/api-reference/Reflection Library/getbspval

Use this function to read the value of a BinaryString property. Specify whether the value is Base64 encoded. The example demonstrates reading the 'SmoothGrid' property from workspace.Terrain.

```lua
function getbspval(instance: Instance, property: string, base64: boolean): string
```

```lua
local result = getbspval(workspace.Terrain, "SmoothGrid", true)
print(result) --> AQU= (Example output)
```

--------------------------------

### Get Thread Environment

Source: https://docs.potassium.pro/api-reference/Environment Library/gettenv

Use this to print all variables stored in a thread's environment. If no thread is specified, the current thread is used.

```lua
local thread = coroutine.create(function() end)
table.foreach(gettenv(thread), print)
```

--------------------------------

### httpget Function

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/httpget

This function sends an HTTP GET request. It can be called with just a URL, or with an optional first argument (e.g., `game`) for backwards compatibility.

```APIDOC
## httpget Function

### Description
Performs an HTTP GET request to the specified `url`.

### Signature
```lua
function httpget(self: any?, url: string): ()
```

### Parameters
#### Parameters
- **self** (any) - Optional. An optional legacy first argument (e.g. `game`) used for backwards compatibility. When provided, the second `url` argument is used as the request target.
- **url** (string) - Required. The URL to send the HTTP GET request to.

### Tip
Alias: `HttpGet`

### Example
```lua
-- Basic usage
print(httpget("https://httpbin.org/get")) --> HTTP body

-- With legacy argument
print(httpget(game, "https://httpbin.org/get")) --> HTTP body
```
```

--------------------------------

### HTTP GET Request

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/httpget

Use this function to send an HTTP GET request to a URL. The `self` argument is optional and for legacy purposes. The URL is required.

```lua
function httpget(self: any?, url: string): ()

```

```lua
print(httpget("https://httpbin.org/get")) --> HTTP body

-- Backwards compatibility but functions exactly the same
print(httpget(game, "https://httpbin.org/get")) --> HTTP body

```

--------------------------------

### Get Signal Argument Information

Source: https://docs.potassium.pro/api-reference/Signal Library/getsignalargumentsinfo

This function returns a table of expected argument information for a given RBXScriptSignal. Use this information to replicate signals.

```lua
function getsignalargumentsinfo(signal: RBXScriptSignal): { ArgumentInfo }
```

```lua
local signal = game.Players.LocalPlayer.Idled
local signalArgumentInfo = getsignalargumentsinfo(signal)

for _, argumentInfo in signalArgumentInfo do
    print(argumentInfo)
end
```

--------------------------------

### Get RenderStepped Callbacks

Source: https://docs.potassium.pro/api-reference/Instance Library/getrendersteppedlist

This script iterates through all callbacks bound to 'RenderStepped' and prints their associated function, thread, priority, and name. Ensure that callbacks have been previously bound using BindToRenderStep.

```lua
function getrendersteppedlist(): { function }
```
```

```lua
local connections = getrendersteppedlist()

for _, callback in connections do
    print("Function:", callback.Function)
    print("Thread:", callback.Thread)
    print("Priority:", callback.Priority)
    print("Name:", callback.Name)
end
```

--------------------------------

### Extract ID using Regex

Source: https://docs.potassium.pro/api-reference/Regex Library/Regex.new

This example demonstrates creating a Regex object to extract a specific ID from an input string and then printing the extracted ID. It utilizes the Match and Replace methods.

```lua
local input = "My Cool Id: 31235335"
local regex = Regex.new("My Cool Id:\s*(\w+)")
local match = regex:Match(input)

if match then
    print("ID:", regex:Replace(match, "$1"))
end
```

--------------------------------

### Receive Console Input

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoleinput

This script demonstrates how to use rconsoleinput to get user input. The script will pause execution until the user enters text and presses Enter. Ensure rconsolecreate() is called before using console functions.

```lua
rconsolecreate()
rconsoleprint("What's your name?\n")
local username = rconsoleinput()
print(username)
```

--------------------------------

### Compare Hashes of Two Lua Functions

Source: https://docs.potassium.pro/api-reference/Closure%20Library/getfunctionhash

This example demonstrates how to use getfunctionhash to compare the hashes of two distinct Lua functions. It defines two simple functions, foo and bar, calculates their respective hashes, and then prints whether the hashes are equal.

```lua
local function foo()
    print("Hello, world!")
end

local function bar(x, y)
    return x + y
end

local firstHash = getfunctionhash(foo)
local secondHash = getfunctionhash(bar)

print(firstHash == secondHash) --> false
```

--------------------------------

### getrenderproperty

Source: https://docs.potassium.pro/api-reference/Drawing Library/getrenderproperty

Gets a property value from a `DrawingObject`.

```APIDOC
## getrenderproperty

### Description
Gets a property value from a `DrawingObject`.

### Signature
```lua
function getrenderproperty(drawing: DrawingObject, property: string): any
```

### Parameters
#### Path Parameters
- **drawing** (DrawingObject) - Required - The drawing object to retrieve the property from.
- **property** (string) - Required - The property to retrieve.

### Example
This script will make a print the default radius for a `Circle`.

```lua
local circle = Drawing.new("Circle")

print("Radius:", getrenderproperty(circle, "Radius"))
```
```

--------------------------------

### Create Folder with makefolder

Source: https://docs.potassium.pro/api-reference/FileSystem Library/makefolder

Use makefolder to create a new directory. The function accepts the desired path as a string argument.

```lua
print(makefolder("mk"))
```

--------------------------------

### getfflagtype

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/getfflagtype

Gets the type of a Fast Flag. An alias for this function is `getfastflagtype`.

```APIDOC
## getfflagtype

### Description
Gets the type of a Fast Flag.

### Method
```lua
function getfflagtype(fflag: string): string
```

### Parameters
#### Path Parameters
- **fflag** (string) - Required - The name of the Fast Flag to get the type of.

### Example
```lua
print(getfflagtype("TaskSchedulerTargetFps")) --> int
print(getfflagtype("AddClassFullName")) --> flag
```

### Alias
`getfastflagtype`
```

--------------------------------

### Get Script Bytecode

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptbytecode

This function returns the bytecode of a given script. It is aliased as `dumpstring`.

```lua
function getscriptbytecode(script: BaseScript): string
```

--------------------------------

### getnamecallmethod

Source: https://docs.potassium.pro/api-reference/Metatable Library/getnamecallmethod

Gets the current thread's `__namecall` method. An alias for this function is `get_namecall_method`.

```APIDOC
## getnamecallmethod

### Description
Gets the current thread's `__namecall` method.

### Method Signature
```lua
function getnamecallmethod(): string?
```

### Alias
`get_namecall_method`

### Example
```lua
xpcall(function()
  return game:method()
end, function()
  print(getnamecallmethod()) --> method
end)
```
```

--------------------------------

### Get All Actors

Source: https://docs.potassium.pro/api-reference/Actor%20Library/getactors

This function returns a table of all active actors. It does not include actors that have been deleted.

```lua
function getactors(): {Actor}

```

--------------------------------

### Create a Console Window

Source: https://docs.potassium.pro/api-reference/Console Library/rconsolecreate

Use this function to create a new console window. Only one console can be active at a time, and previous output is preserved.

```lua
function rconsolecreate()

```

--------------------------------

### makefolder

Source: https://docs.potassium.pro/api-reference/FileSystem Library/makefolder

Creates a folder in the specified 'path'.

```APIDOC
## makefolder

### Description
Creates a folder in the specified 'path'.

### Signature
```lua
function makefolder(path: string): ()
```

### Parameters
#### Path Parameters
- **path** (string) - Required - The path you want to create a folder with

### Example
```lua
print(makefolder("mk"))
```
```

--------------------------------

### Get Script Hash

Source: https://docs.potassium.pro/api-reference/Script Library/getscripthash

This function returns a hash for a given script. It requires a BaseScript object as input.

```lua
function getscripthash(script: BaseScript): string
```

--------------------------------

### Get Script Closure Signature

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptclosure

This is the function signature for getscriptclosure. It takes a BaseScript object and returns a function.

```lua
function getscriptclosure(script: BaseScript): function
```

--------------------------------

### List Files in Directory

Source: https://docs.potassium.pro/api-reference/FileSystem Library/listfiles

Use this function to list files from a specified directory. Provide an empty string to list files from the workspace root.

```lua
function listfiles(path: string): {string}

```

```lua
for index, file in listfiles("") do -- list files from workspace root
  print(index, file)
end

```

--------------------------------

### Get Proximity Prompt Duration

Source: https://docs.potassium.pro/api-reference/Reflection Library/getproximitypromptduration

This function returns the duration of a ProximityPrompt. It requires a ProximityPrompt object as input.

```lua
function getproximitypromptduration(proximityprompt: ProximityPrompt): number
```

```lua
local proximityprompt = Instance.new("ProximityPrompt")
proximityprompt.HoldDuration = 3

local duration = getproximitypromptduration(proximityprompt)
print(duration)
```

--------------------------------

### Get Communication Channel Signature

Source: https://docs.potassium.pro/api-reference/Actor Library/get_comm_channel

This is the function signature for get_comm_channel. It takes a numeric ID and returns a BindableEvent.

```lua
function get_comm_channel(id: number): BindableEvent
```

--------------------------------

### rconsolecreate

Source: https://docs.potassium.pro/api-reference/Console Library/rconsolecreate

Creates a console window. Text previously output to the console will not be cleared. Only 1 console can be created.

```APIDOC
## rconsolecreate

### Description
Creates a console window. Text previously output to the console will not be cleared. Only 1 console can be created.

### Syntax
```lua
function rconsolecreate()
```

### Example

This script will create a console and print a basic message.

```lua
rconsolecreate()
rconsoleprint("Hello, world!\n")
```
```

--------------------------------

### Line Object Properties

Source: https://docs.potassium.pro/api-reference/Drawing Library/DrawingObject

Properties specific to Line objects, defining their start and end points, and thickness.

```APIDOC
## Line Object Properties

### Description
Properties specific to the Line object, defining its geometry and appearance.

### Properties
- **From** (Vector2) - Default: `Vector2.new(0, 0)` - The starting point of the line.
- **To** (Vector2) - Default: `Vector2.new(0, 0)` - The ending point of the line.
- **Thickness** (number) - Default: `1` - The width of the line.
```

--------------------------------

### debug.setupvalue

Source: https://docs.potassium.pro/api-reference/Debug Library/debug.setupvalue

Sets a singular upvalue that's derived from a function's upvalue list. Selected via index.

```APIDOC
## debug.setupvalue

### Description
Sets a singular upvalue that's derived from a function's upvalue list. Selected via index.

### Signature
```lua
function debug.setupvalue(function: function | number, index: number, replacement: any): ()
```

### Parameters
#### function
- **function** (function | number) - Required - The function whose upvalue is set.

#### index
- **index** (number) - Required - The index of the upvalue to set.

#### replacement
- **replacement** (any) - Required - The replacement object. Must be of the same type.

### Example

This script will set a function's upvalue.

```lua
local upvalue = 0

local function foo()
    return upvalue
end

local function bar()
    upvalue += 1
end

print(foo())

debug.setupvalue(foo, 1, 10000)

print(foo())
```
```

--------------------------------

### Get Running Scripts

Source: https://docs.potassium.pro/api-reference/Script Library/getrunningscripts

This function returns a table of all currently running scripts. It is useful for inspecting script execution.

```lua
function getrunningscripts(): { BaseScript }
```

--------------------------------

### Iterate and Print Instances

Source: https://docs.potassium.pro/api-reference/Instance Library/getinstances

This script iterates through all instances returned by getinstances() and prints each one to the console. Ensure getinstances() is available in your environment.

```lua
for _, instance in getinstances() do
    print(instance)
end
```

--------------------------------

### Get Namecall Method Signature

Source: https://docs.potassium.pro/api-reference/Metatable Library/getnamecallmethod

This is the function signature for `getnamecallmethod`. It returns an optional string representing the `__namecall` method.

```lua
function getnamecallmethod(): string?

```

--------------------------------

### Send and Close WebSocket Connection

Source: https://docs.potassium.pro/api-reference/WebSocket Library/WebSocket.connect

Demonstrates creating a WebSocket connection, sending a message, and then closing the connection. Ensure the URL is valid before connecting.

```lua
local ws = WebSocket.connect("wss://echo.websocket.org")
ws:Send("Hello, WebSocket!")
ws:Close()
```

--------------------------------

### Get Deleted Actors

Source: https://docs.potassium.pro/api-reference/Actor%20Library/getdeletedactors

Returns a table of every deleted actor. Some games delete their actors while they're running.

```APIDOC
## getdeletedactors

### Description
Returns a table of every deleted actor. Some games delete their actors while they're running.

### Method Signature
```lua
function getdeletedactors(): {Actor}
```

### Alias
`get_deleted_actors`

### Example
```lua
for _, deletedActor in getdeletedactors() do
    print(deletedActor)
end
```
```

--------------------------------

### Get Deleted Actors

Source: https://docs.potassium.pro/api-reference/Actor Library/getdeletedactors

Returns a table of every deleted actor. Some games delete their actors while they're running.

```APIDOC
## getdeletedactors

### Description
Returns a table of every deleted actor. Some games delete their actors while they're running.

### Method
`getdeletedactors()`

### Returns
- **{Actor}**: A table containing deleted actors.
```

--------------------------------

### Print Info Message to Console

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoleinfo

This script will both create a console and print a basic message. The text argument is the message to be printed and does not clear existing text or create a new line.

```lua
function rconsoleinfo(text: string): ()

-- The text to be printed. Does not clear existing text or create a new line.

rconsoleinfo("INFO!\n")
```

--------------------------------

### Check if a function is a C closure

Source: https://docs.potassium.pro/api-reference/Closure%20Library/iscclosure

Use iscclosure to differentiate between Lua-implemented and C-implemented functions. This example demonstrates its usage with both types.

```lua
function iscclosure(func: function): boolean
```

```lua
local function foo() 
    print("Hello, world!") 
end 

print(iscclosure(foo)) --> false 
print(iscclosure(print)) --> true
```

--------------------------------

### Get Loaded Modules Function Signature

Source: https://docs.potassium.pro/api-reference/Script Library/getloadedmodules

This is the function signature for getloadedmodules. It indicates that the function returns a table of ModuleScript objects.

```lua
function getloadedmodules(): { ModuleScript }
```

--------------------------------

### Get Hardware ID

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/gethwid

Call the gethwid function to obtain the device's unique identifier. This function has aliases for convenience.

```lua
function gethwid(): string
```

```lua
print("HWID:", gethwid())
```

--------------------------------

### Get Signal Whitelist

Source: https://docs.potassium.pro/api-reference/Signal Library/getsignalwhitelist

This function returns a table of SignalWhitelistInfo objects. Each object contains the 'Parent' and 'Event' names of a whitelisted signal.

```lua
function getsignalwhitelist(): { SignalWhitelistInfo }
```

--------------------------------

### Get Connections for a Signal

Source: https://docs.potassium.pro/api-reference/Signal Library/getconnections

This function retrieves all active connections for a given RBXScriptSignal. It is useful for inspecting or managing existing signal connections.

```lua
function getconnections(signal: RBXScriptSignal): {Connection}

```

--------------------------------

### Connect to WebSocket

Source: https://docs.potassium.pro/api-reference/WebSocket Library/WebSocket.connect

Establishes a WebSocket connection to the specified URL. This function is an alias for WebSocket.new.

```lua
function WebSocket.connect(url: string): WebSocket
```

--------------------------------

### Get Script Thread

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptthread

This function returns the execution thread of a BaseScript. It can be used to check the status of a script's execution or to cancel it.

```lua
function getscriptthread(script: BaseScript): thread?
```

```lua
for _, script in getnilinstances() do
    if not script:IsA("LocalScript") then
        continue
    end

    local thread = getscriptthread(script);

    if thread and coroutine.status(thread) ~= "dead" then
        task.cancel(thread)
    end
end
```

--------------------------------

### Iterate and Print ModuleScript Path

Source: https://docs.potassium.pro/api-reference/Script Library/getloadedmodules

This script iterates through all loaded ModuleScripts and prints the full path of any script named 'PlayerModule'. Ensure that 'PlayerModule' is loaded for this to output anything.

```lua
for _, script in getloadedmodules() do
    if script.Name == "PlayerModule" then
        print(script:GetFullName())
    end
end
```

--------------------------------

### Get Executor Name and Version

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/identifyexecutor

Call this function to retrieve the executor's name and version. The output format is 'ExecutorName, vX.Y.Z'.

```lua
function identifyexecutor(): (string, string)
end
```

```lua
print(identifyexecutor()) --> Ex: Potassium, v1.0.0
```

--------------------------------

### Get Fast Flag Value

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/getfflag

Use getfflag to retrieve the string value of a Fast Flag. The alias getfastflag can also be used.

```lua
function getfflag(fflag: string): string
```

```lua
local fps = getfflag("TaskSchedulerTargetFps")
print("Current FPS cap:", fps)

local dpiFix = getfflag("FixDPIScaling")
print("DPI fix enabled:", dpiFix)
```

--------------------------------

### Iterate Through Registry

Source: https://docs.potassium.pro/api-reference/Environment Library/getreg

Iterates through the global registry and prints each key-value pair. Use this to inspect the contents of the registry.

```lua
local registry = getreg()
for i, v in registry do
    print(i, v)
end

```

--------------------------------

### Decompile LuaSourceContainer to Pseudocode

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/decompile

Use this function to get pseudocode from the bytecode of a LuaSourceContainer. Ensure the script is a LocalScript or ModuleScript and the RunContext is Client.

```lua
function decompile(script: LuaSourceContainer): string
```

```lua
local script = game:GetService("Players").LocalPlayer.Character.Animate

print(decompile(script)) --> Psuedocode of the bytecode from the script
```

--------------------------------

### saveinstance

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/saveinstance

Saves an Instance to a file with customizable options.

```APIDOC
## saveinstance

### Description
Saves an Instance in .rbxl or .rbxm format. This function is useful for exporting game data or specific objects.

### Signature
```lua
function saveinstance(object: Instance, options: table?): ()
```

### Parameters
#### object
- **object** (Instance) - Required - The `Instance` to save. Typically `game` to save the entire DataModel.

#### options
- **options** (table) - Optional - A table of options controlling decompilation, threading, filtering, and output behaviour. See the Options table below.

### Options Table
| Option                   | Type    | Default                             | Description                                                           |
| ------------------------ | ------- | ----------------------------------- | --------------------------------------------------------------------- |
| `FileName`               | string  | Varies                              | Output file name                                                      |
| `Decompile`              | boolean | `false`                             | Should scripts be decompiled during saveinstance                      |
| `NilInstances`           | boolean | `false`                             | Save instances that are not parented in the DataModel (nil instances) |
| `RemovePlayerCharacters` | boolean | `true`                              | Ignore characters whilst doing saveinstance                           |
| `SavePlayers`            | boolean | `false`                             | Save player instances                                                 |
| `DecompileTimeout`       | number  | `10`                                | Timeout (in seconds) for decompile jobs                               |
| `MaxThreads`             | number  | `3`                                 | Number of threads used to decompile scripts                           |
| `DecompileIgnore`        | table   | `{"Chat","CoreGui","CorePackages"}` | Services to ignore during decompile                                   |
| `ShowStatus`             | boolean | `true`                              | Show saveinstance status while running                                |
| `IgnoreDefaultProps`     | boolean | `true`                              | Ignore default properties                                             |
| `IsolateStarterPlayer`   | boolean | `true`                              | Clears StarterPlayer and places saved version into folders            |

### Example
```lua
saveinstance(game, {
    FileName = "game.rbxl",
    Decompile = true,
    MaxThreads = 5 -- Adjust depending on PC specs
})
```
```

--------------------------------

### Get Global Registry

Source: https://docs.potassium.pro/api-reference/Environment Library/getreg

Retrieves the global registry table. This table holds strong references to objects, preventing garbage collection.

```lua
function getreg(): { [any]: any }

```

--------------------------------

### Get All Actor Threads

Source: https://docs.potassium.pro/api-reference/Actor%20Library/getactorthreads

This function returns a table of every thread connected to every actor. An alias, get_actor_threads, is also available.

```lua
function getactorthreads(): {thread}

```

--------------------------------

### Get All Actor Threads

Source: https://docs.potassium.pro/api-reference/Actor Library/getactorthreads

This function returns a table of every thread connected to every actor. It can be iterated over to process each thread individually.

```lua
function getactorthreads(): {thread}
```
```

```lua
for _, actorThread in getactorthreads() do
    print(actorThread)
end
```

--------------------------------

### PsmSignal.new

Source: https://docs.potassium.pro/api-reference/PsmSignal Library/PsmSignal.new

Constructs a new PsmSignal object. This is the primary way to create a signal instance.

```APIDOC
## PsmSignal.new

### Description
Constructs a new `PsmSignal` object.

### Signature
```lua
function PsmSignal.new(): PsmSignal
```

### Alias
`Signal.new`

### Methods
#### Connect
Connects a callback function to the signal.

- **callback** (function) - The function to be called when the signal fires.

#### Once
Connects a callback function to the signal that fires only once.

- **callback** (function) - The function to be called when the signal fires.

#### Wait
Yields until the signal fires.

#### Fire
Fires the signal with the given arguments.

- **...** (any) - Arguments to pass to the connected callbacks.

### Example
```lua
local signal = PsmSignal.new()

signal:Once(function()
    print("Signal fired!")
end)

signal:Fire()
```
```

--------------------------------

### Simulate Right Mouse Press and Release

Source: https://docs.potassium.pro/api-reference/Input Library/mouse2press

This script demonstrates how to simulate a right mouse press and release. It includes a delay to ensure Roblox is in focus before executing the actions.

```lua
task.wait(1) -- Give the user time to put roblox in focus.

mouse2press()
task.wait()
mouse2release()
```

--------------------------------

### rconsoleinfo

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoleinfo

Prints a message to the console. Creates the console if it doesn't exist.

```APIDOC
## rconsoleinfo

### Description
Prints a dark blue message to the console. If the console hasn't been already created, `rconsoleinfo` will create one.

### Signature
```lua
function rconsoleinfo(text: string): ()
```

### Parameters
#### Path Parameters
- **text** (string) - Required - The text to be printed. Does not clear existing text or create a new line.

### Example
This script will both create a console and print a basic message.

```lua
rconsoleinfo("INFO!\n")
```
```

--------------------------------

### Print to Console - Lua

Source: https://docs.potassium.pro/api-reference/Console Library/rconsoleprint

This script demonstrates how to create a console and print a basic message to it using rconsoleprint. The text argument does not clear existing content or add a new line.

```lua
rconsoleprint("Hello, world!\n")
```

--------------------------------

### Simulate Mouse Press and Release

Source: https://docs.potassium.pro/api-reference/Input Library/mouse1release

This script demonstrates how to simulate a full mouse click by pressing and then releasing the left mouse button. It includes a delay to allow the user to focus on the Roblox window.

```lua
task.wait(1) -- Give the user time to put roblox in focus.

mouse1press()
task.wait()
mouse1release()
```

--------------------------------

### decompile

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/decompile

Returns pseudocode from the bytecode of a `LuaSourceContainer`.

```APIDOC
## decompile

### Description
Returns pseudocode from the bytecode of 'LuaSourceContainer' with RunContext of 'Client', Legacy with a LocalScript or a ModuleScript.

### Function Signature
```lua
function decompile(script: LuaSourceContainer): string
```

### Parameters
#### Request Body
- **script** (LuaSourceContainer) - Required - The `LuaSourceContainer` (e.g. a `LocalScript` or `ModuleScript`) whose bytecode will be decompiled into pseudocode.

### Request Example
```lua
local script = game:GetService("Players").LocalPlayer.Character.Animate

print(decompile(script)) --> Psuedocode of the bytecode from the script
```
```

--------------------------------

### Get Script From Thread Function Signature

Source: https://docs.potassium.pro/api-reference/Script Library/getscriptfromthread

Defines the function signature for getscriptfromthread, indicating it takes a thread object and returns an optional BaseScript.

```lua
function getscriptfromthread(thread: thread): BaseScript?
```

--------------------------------

### request

Source: https://docs.potassium.pro/api-reference/Miscellaneous Library/request

Creates a HTTP request with specified options. Aliases include `http_request` and `http.request`.

```APIDOC
## request

### Description
Creates a HTTP request with specified options.

### Function Signature
```lua
function request(options: HttpRequest): ()
```

### Parameters
#### options (HttpRequest) - Required
The options for the HTTP request.

##### HttpRequest Table
| Field     | Type    | Description              |
| --------- | ------- | ------------------------ |
| `Url`     | string  | The URL for the request. |
| `Method`  | string  | The HTTP method to use.  |
| `Body`    | string? | The body of the request. |
| `Headers` | table?  | A table of headers.      |
| `Cookies` | table?  | A table of cookies.      |

### Response
#### Success Response
- **Body** (string) - The body of the response.
- **StatusCode** (number) - The number status code of the response.
- **StatusMessage** (string) - The status message of the response.
- **Success** (boolean) - Whether or not the request was successful.
- **Headers** (table) - A dictionary of headers.

### Example
```lua
local response = request({
	Url = "https://httpbin.org", Method = "GET"
})

print(response.Success)
print(response.StatusCode)
print(response.StatusMessage)
```
```

--------------------------------

### Get and Set Simulation Radius

Source: https://docs.potassium.pro/api-reference/Reflection Library/getsimulationradius

Use getsimulationradius to retrieve the current simulation radius. Call setsimulationradius to change it. The radius is returned in units.

```lua
print(getsimulationradius()) --> 1000
setsimulationradius(2000)
print(getsimulationradius()) --> 2000
```

--------------------------------

### rconsolesettitle

Source: https://docs.potassium.pro/api-reference/Console Library/rconsolesettitle

Sets the title of the console window. Accepts a string argument for the new title.

```APIDOC
## rconsolesettitle

### Description
Sets the title of the console window.

### Parameters
#### Path Parameters
- **title** (string) - Required - The string that the title will be set to.

### Request Example
```lua theme={null}
rconsolecreate()
rconsolesettitle("Custom Title")
```

### Tip
Alias: `rconsolename`
```

--------------------------------

### Construct a new PsmSignal object

Source: https://docs.potassium.pro/api-reference/PsmSignal Library/PsmSignal.new

Use this function to create a new PsmSignal instance. The alias `Signal.new` can also be used.

```lua
function PsmSignal.new(): PsmSignal
```
Tokens:
Raw