Documentation

Write to the executor's output console. print-family logs at info level, warn at warning level, error-family at error level. printl and errorl are aliases.

Returns "yuari" and the current version string.

local name, version = identifyexecutor()
print(name, version) -- yuari, 0.1

Yields the current thread for seconds (default 0.03). Resumes on the VM scheduler.

Runs fn immediately on a new coroutine. Errors are logged, not propagated.

Seconds elapsed since the VM started (a monotonic timer, not the Unix epoch).

Type name for any value. VM userdata report as "Vector3", "Vector2", "CFrame", "Color3", "RBXScriptConnection" or "Drawing"; everything else uses standard Luau type names.

Creates a plain userdata, optionally with an empty metatable — same behaviour as Roblox.

Approximate memory in use by the external VM, in kilobytes.

Alias of table.unpack.

Shows a message in the executor console. title defaults to "Yuari", duration to 3 seconds.

Ping compatibility shim (currently returns 0).

Name of the current place (reads the Workspace name), or "Unknown".

Standard Base64 helpers.

Yields for seconds (default 0.03).

Runs fn on a new thread immediately.

Schedules fn to run after seconds. Returns a handle usable with task.cancel.

Runs fn as soon as the current thread yields.

Cancels a thread or a task.delay handle.

Live proxies to the DataModel and Workspace. game.PlaceId, game.GameId and game.JobId are supported.

Creates an instance through Roblox's own class registry (with a creatability check) and optionally parents it. Returns nil and logs a reason on failure (class not found, not creatable, etc.).

local part = Instance.new("Part", workspace)
part.Name = "MyPart"
part.Position = Vector3.new(0, 10, 0)

Direct children, or the full descendant tree.

First matching child, or nil.

First matching ancestor, or nil.

Yields until the child exists (or times out).

Class checks understand common hierarchies (BasePart, Model, GuiObject, ValueBase, LuaSourceContainer, Tool, …).

Reads/writes instance attributes.

Dotted path, e.g. "Workspace.Map.Spawn".

Finds a top-level service by class name.

All current players (from the Players service).

Fires when the given property changes.

Projects a world position through the camera. Returns (x, y, depth) in screen space plus true when on screen.

local cam = workspace.CurrentCamera
local pos, visible = cam:WorldToViewportPoint(target.Position)
if visible then
    print(math.floor(pos.X), math.floor(pos.Y), pos.Z)
end

Pivot of a Model (uses its PrimaryPart).

Removes the instance by unparenting it.

Equips a Tool on a character through the game's own bound functions.

Fires a BindableEvent (any arguments) or a ProximityPrompt (defaults the player argument to the local player).

Synthesizes a click at the detector's on-screen position. event may be "MouseClick" (default), "RightMouseClick", "MouseHoverEnter" or "MouseHoverLeave". Accepts either the ClickDetector or its parent BasePart. The cursor is restored afterwards.

Triggers a ProximityPrompt by simulating the hold interaction on its parent part.

Simulates a Touched event by briefly moving the local character's HumanoidRootPart (or a custom mover) onto part. Pass false/0 as the third argument for a no-op (untequal) touch. firetouchtransmitter is an alias.

type is one of "Line", "Text", "Circle", "Square".

local box = Drawing.new("Square")
box.Position = Vector2.new(100, 100)
box.Size = Vector2.new(160, 220)
box.Color = Color3.fromRGB(120, 130, 255)
box.Thickness = 2
box.Visible = true

Removes every drawing object at once.

Flushes the render cache (all objects).

Font selector constants: UI (0), System (1), SystemBold (2), Minecraft (3), Monospace (4), Pixel (5), Fortnite (6), ProximaSoftBold (7).

Cursor position in client space.

Whether the Roblox window is focused.

Accepts a virtual-key code, a name ("space", "shift", "ctrl", "alt", "tab", "escape", "left", "right", "up", "down", "lmb", "rmb", "mmb", letters…), or an Enum.KeyCode item. Only reports true while the game is focused.

Left / right mouse button state (focus-gated).

Synthesize a key tap using Windows virtual-key codes.

Move the cursor absolutely (client coords) or relatively; mousescroll sends wheel notches.

Left button control (click = press + release).

Right button control.

Copy text to the Windows clipboard, or read it back (Unicode text supported).

Input-routing compatibility shim (no-op).

Roblox-style request. Options: Url (required), Method (default "GET"), Body, Headers (table).

Returns { Success, StatusCode, Body, StatusMessage, Headers }.

local res = request({
    Url = "https://httpbin.org/get",
    Method = "GET",
    Headers = { ["User-Agent"] = "yuari" }
})

if res.Success then
    print(res.StatusCode, #res.Body)
end

GET a URL and return the response body as a string.

POST with an optional content type (default "application/json").

Service-style wrapper: HttpService:GetAsync(url, headers?), HttpService:RequestAsync(options), HttpService:JSONEncode(value), HttpService:JSONDecode(string).

local json = HttpService:JSONEncode({ health = 100, name = "bot" })
local data = HttpService:JSONDecode('{"health": 100}')
print(data.health)

Collects every script (LocalScript, Script, ModuleScript) in the tree under root — defaults to the whole DataModel. Capped at 8000 scripts.

Raw Luau bytecode of a script. Returns an empty string for non-scripts.

Decompiles a script instance (or a raw bytecode string) back to Luau source.

for _, s in ipairs(getscripts()) do
    local src = decompile(s)
    if src and src:find("RemoteEvent") then
        print(s:GetFullName())
    end
end

Script environment accessor (compatibility shim).

FNV-1a hash of the script's bytecode, as a decimal string ("0" when unavailable).

Compiles a string with the Luau compatibility pass applied. Like Roblox, syntax errors yield a function that raises the error when called.

local fn = loadstring("print('hello from a string')")
fn()

Alias of loadstring.

Environment get/set for functions, Roblox-style. getfenv() with no usable argument returns the global table.

Frame signals that fire every tick with the delta time. Use in a loop with task.wait().

RunService.Heartbeat:Connect(function(dt)
    -- runs every frame
end)

Fire with an input object { KeyCode = { Name, Value }, UserInputType = { Name } }.

Cursor position in client space.

State queries — accepts the same key formats as iskeypressed.

Virtual input shims for UI automation.

Anti-AFK helpers. ClickButton1 takes a Vector2 or x, y.

Compatibility shim returning a table with Play, Cancel, Pause, Destroy and a Completed signal.

Full bit32 library: band, bor, bxor, bnot, lshift, rshift, arshift, lrotate, rrotate, extract, replace.

Virtual-key code tables for input functions.

• KeyCode — Space, Tab, Escape, Return/Enter, Backspace, arrow keys, LeftShift/RightShift, LeftControl/RightControl, LeftAlt/RightAlt, letters A–Z, digits 0–9, F1–F12.
• UserInputType — MouseButton1 (1), MouseButton2 (2), MouseButton3 (3), Keyboard (8), Touch (9), Gamepad1 (10).

With no argument, returns GC statistics (same shape as getgc_info). With true, returns a generic-for iterator over every live table in the game's VM (up to 120,000 entries).

for _, tbl in getgc(true) do
    local v = rawget(tbl, "Money")
    if type(v) == "number" then
        print("found:", v)
    end
end

Snapshot of the game's GC state: kb, gcstate, isrunning, pause, stepmul, pages, gray, grayagain, weak, total, by_type, samples, plus the addresses L and G as hex strings.

Controls the game's collector directly: "stop" (freeze), "restart" (resume), "count" (total KB), "isrunning", "pause" / "setpause" (get/set, 0–1000), "stepmul" / "setstepmul" (get/set, 0–10000).

setgc("stop")      -- freeze the game's GC
print(setgc("count"))
setgc("restart")   -- resume

Scans all game VMs for tables containing the given string key (or a list of keys), optionally matching a specific string value. Returns table proxies you can index directly. Returns nil, "no game lua state" when no state is found.

local hits = findgc("Leaderstats", "Cash")
for _, tbl in ipairs(hits) do
    print(tbl)
end

Dumps the raw string keys of a game table proxy (read from the hash nodes in memory), paired with their values.

Overridden to work on game table proxies as well as normal tables.

Advanced diagnostics: number of game VMs (vm_count), per-VM stats (G/L addresses, table counts, string-key samples) and ammo_vm — the index of the VM holding the tracked data. Mostly a debugging tool.

Reads from the game process. type is one of "int", "float", "double", "byte", "string", "uintptr_t". Returns nil for a null address.

local v = memory_read("float", 0x1A2B3C4D)
print(v)

Writes to the game process using the same type names as memory_read.

Base address of the Roblox module — handy as a starting point for offset math with memory_read.