Less guessing.
More control.

Evaluates a numeric expression once and returns that snapshot. In the serialized VM, the value also helps unlock protected continuation instructions; the compact VM backends and Minify compare it directly. A mismatch fails the integrity check on every tier.

local place = CTB_ASSUME(game.PlaceId, 123456)
print(place) -- replace 123456 with your actual place ID

Limits: the expected value must be a finite numeric literal in the exact-number range. Protection extends only through VM blocks where the snapshot is provably available, not the whole function. With the non-VM minifier, use an ordinary equality check instead; inside VM(NONE) it is rejected.

Produces an arithmetic predicate that resolves to the boolean you request. Use it in a condition when you want the generated expression to be less direct than a literal.

if CTB_OPAQUE(true) then
  print("this branch runs")
end

CTB_OBFUSCATED becomes true during obfuscation. CTB_LINE becomes the original source line number. Neither takes parentheses.

if CTB_OBFUSCATED then
  print("built from line", CTB_LINE)
end

Obvious literal branches and short-circuits are folded, but this isn't a general dead-code analysis pass.

Protects a quoted or long-bracket string literal with ChaCha20. The short form generates an embedded key; the three-argument form uses the value supplied at runtime to unlock it.

Aliases: CTB_STRENC, LPH_ENCSTR, LPH_STRENC

local runtimeValue = 2468
local message = CTB_ENCSTR("hello", 2468, runtimeValue)
print(message)

Key forms: an exact integer, a 64-character hexadecimal string, or the same hex string wrapped in braces for a 32-byte table. The runtime expression must supply the matching number, hex string, or byte table. The ciphertext is not authenticated; embedded or client-visible keys are recoverable.

Uses the same literal and optional key forms as CTB_ENCSTR, but returns the decoded bytes as a Luau buffer.

Aliases: CTB_BUFENC, LPH_ENCBUF, LPH_BUFENC

local bytes = CTB_ENCBUF("hello")
print(buffer.tostring(bytes))

Requires a host with Luau's buffer library.

Stores a numeric literal as protected text and converts it back at runtime. Optionally bind it to up to eight expected integer values.

Aliases: CTB_NUMENC, LPH_ENCNUM, LPH_NUMENC

local slot = 21
local amount = CTB_ENCNUM(100, { [slot] = 21 })
print(amount)

Expected binding values must be exact integers. The numeric key mixer is not a cryptographic key-derivation function.

Moves a check into the loader and mixes its result into the VM and vault keys. The check must return the expected integer or integer array before the protected payload can be decoded.

CTB_PRECHECK(function()
  return game.PlaceId
end, 123456) -- use your actual place ID
print("check passed")

Limits: use an anonymous function with no parameters or captured outer locals. Expected values must be exact integers; arrays contain 1–64 values. Requires a VM preset and cannot be used with file-level VM(NONE).

Damages the active VM context and raises an error. Catching that error does not restore the wiped VM state. It can be used as a statement or an expression.

if not allowed then
  CTB_CRASH()
end

Without a VM, including file-level VM(NONE), it raises an error instead. Do not use a client-side crash as authorization.

Creates an indexed container with a declared length. The optional second argument chooses the starting index: 1 by default, or 0.

local slots = CTB_STACKALLOC(3, 0)
slots[0] = "first"
local packed = slots:pack()
print(#slots, packed.n)
slots:clear()

Current implementation: this is a table-backed compatibility helper, not actual stack/register allocation. It supports indexing, #, pack, unpack, and clear; it does not enforce non-escaping use. Size must be an integer from 0 to 100,000.

Rewrites a supported arithmetic expression with mixed bitwise and arithmetic operations, while keeping a fallback for values or environments where the rewrite isn't safe.

local a, b = 8, 4
local value = CTB_REWRITE(a + b, {
  preset = "strong", budget = "medium"
})
print(value)

The supported subset includes numeric literals, identifiers, +, -, *, and selected bit32 calls. Options are fast, standard, strong, or extreme presets; small, medium, or large budgets; and an optional identifier context. At most eight distinct identifiers are captured. This is not a complete MBA rewriter.

NONE emits native Lua instead of VM instructions. OPAL and ONYX select distinct custom opcode spaces; ONYX also has a separate operand/mode layout. They are not the proprietary Luraph VMs.

A native function can access mutable locals captured from the VM, and native descendants inherit NONE. Switching a native descendant back to a VM is not supported. File-level NONE cannot be combined with a runtime key or CTB_PRECHECK.

Chooses the VM's opcode-variant count: two for FAST, three for BALANCED, and four for SECURE. Descendant VM functions inherit the setting unless they override it.

This function attribute is separate from the website's Weak, Medium, and Strong pipeline presets. It cannot be applied to a native VM(NONE) function.

Wraps the function in an environment-backed callable with no lexical captures on the wrapper itself. The original function can still capture locals.

Requires getfenv and setfenv. File-level use and nested use inside native functions are not supported. Use a VM preset for this attribute.

On native code, rewrites method-call syntax into ordinary member lookup and calls. The receiver is evaluated once, and method lookup happens before arguments are evaluated. Descendants inherit the transform; TRANSFORM() clears it.

The rewrite introduces closures and stack frames and can change Roblox-specific __namecall behavior. Other transformation options are not implemented.

Asks the minifier to fold the supplied expression where it can safely evaluate a constant.

print(CTB_CONST(6 * 7))

Replaces a string literal with encoded bytes and a small decoder that reconstructs it while the program runs.

Aliases: CTB_OBFUSCATE, CTB_HIDE_CONSTANT

print(CTB_ENCODE_STRING("hello"))

Not encryption: this byte-shift encoding is easy to reverse. It only discourages casual text searching and should not be used for secrets. It requires a literal string.

CTB_RENAME(identifier, "name") sets a local or global identifier's spelling. CTB_KEEP_NAME(local) keeps a local's existing name during renaming.

local count = 42
local label = "wins"
print(CTB_RENAME(count, "score"), CTB_KEEP_NAME(label))

Choose a valid, non-conflicting Luau identifier when using CTB_RENAME. Normal optimization may still remove an unused value.

Each unwraps its expression. CTB_LOCALIZE requests the global-localization pass for the file; CTB_NO_LOCALIZE disables that pass. If both are present, disabling wins.

local say = CTB_NO_LOCALIZE(print)
say("hello")

Unwraps an expression so it can be considered by the minifier's ordinary safe passes. It does not guarantee that a function or expression will be inlined.

local value = CTB_INLINE(20 + 22)
print(value)

In minifier mode, put this as the first statement inside a function. When any function has these attributes, the current minifier skips ordinary optimization passes for the whole file to preserve its structure. NATIVE also emits Luau's @native annotation.

local function add(a, b)
  CTB_ATTRIBUTES(NO_DCE, NO_INLINE)
  return a + b
end
print(add(2, 3))

Accepted names:

These names do not each apply a separate function-level optimization rule yet. This is distinct from obfuscation-mode LPH_ATTRIBUTES / CTB_ATTRIBUTES.