memory
Raw process-memory access into the attached Roblox engine (reads, writes, scanning, region mapping, watch helpers).
Attach & addresses
Section titled “Attach & addresses”memory.IsEnabled
Section titled “memory.IsEnabled”memory.IsEnabled() -> boolean
Returns true if Conduit is attached to a running engine.
if memory.IsEnabled() then print("attached") endmemory.GetBase
Section titled “memory.GetBase”memory.GetBase() -> number
Returns the base address of the engine module.
local base = memory.GetBase()memory.IsValid
Section titled “memory.IsValid”memory.IsValid(address: number) -> boolean
Returns true if the given address is currently readable in the engine process.
if memory.IsValid(addr) then print("readable") endmemory.AddressOf
Section titled “memory.AddressOf”memory.AddressOf(instance: Instance) -> number?
Returns the native memory address backing a Roblox Instance, or nil if unresolved.
local addr = memory.AddressOf(workspace)Reading
Section titled “Reading”memory.Read
Section titled “memory.Read”memory.Read(address: number, count: number) -> string?
Reads a raw byte buffer of up to 1 MiB from the given address, returned as a Lua string; nil on failed read.
local bytes = memory.Read(addr, 16)memory.ReadPointer
Section titled “memory.ReadPointer”memory.ReadPointer(address: number) -> number?
Reads an 8-byte pointer value at the given address; nil on failed read.
local ptr = memory.ReadPointer(addr)memory.ReadString
Section titled “memory.ReadString”memory.ReadString(address: number, isCxxString: boolean, maxLen: number?, exact: boolean?) -> string?
Reads a string at the address, either as a C++ std::string (isCxxString true) or a raw buffer truncated at the first null unless exact is true.
local s = memory.ReadString(addr, false, 64)memory.ReadU8
Section titled “memory.ReadU8”memory.ReadU8(address: number) -> number?
Reads an unsigned 8-bit integer at the given address.
local v = memory.ReadU8(addr)memory.ReadI8
Section titled “memory.ReadI8”memory.ReadI8(address: number) -> number?
Reads a signed 8-bit integer at the given address.
local v = memory.ReadI8(addr)memory.ReadU16
Section titled “memory.ReadU16”memory.ReadU16(address: number) -> number?
Reads an unsigned 16-bit integer at the given address.
local v = memory.ReadU16(addr)memory.ReadI16
Section titled “memory.ReadI16”memory.ReadI16(address: number) -> number?
Reads a signed 16-bit integer at the given address.
local v = memory.ReadI16(addr)memory.ReadU32
Section titled “memory.ReadU32”memory.ReadU32(address: number) -> number?
Reads an unsigned 32-bit integer at the given address, returned as a Lua number (not coerced to int).
local v = memory.ReadU32(addr)memory.ReadI32
Section titled “memory.ReadI32”memory.ReadI32(address: number) -> number?
Reads a signed 32-bit integer at the given address.
local v = memory.ReadI32(addr)memory.ReadF32
Section titled “memory.ReadF32”memory.ReadF32(address: number) -> number?
Reads a 32-bit float at the given address.
local v = memory.ReadF32(addr)memory.ReadF64
Section titled “memory.ReadF64”memory.ReadF64(address: number) -> number?
Reads a 64-bit double at the given address.
local v = memory.ReadF64(addr)memory.ReadBool
Section titled “memory.ReadBool”memory.ReadBool(address: number) -> boolean?
Reads a single byte at the given address and returns it as a boolean; nil on failed read.
local flag = memory.ReadBool(addr)Writing
Section titled “Writing”memory.Write
Section titled “memory.Write”memory.Write(address: number, data: string) -> boolean
Writes a raw byte buffer (up to 1 MiB) to the given address.
memory.Write(addr, "\1\2\3")memory.WriteString
Section titled “memory.WriteString”memory.WriteString(address: number, data: string) -> boolean
Writes a raw byte buffer (up to 1 MiB) to the given address; identical behavior to memory.Write.
memory.WriteString(addr, "hello")memory.WriteU8
Section titled “memory.WriteU8”memory.WriteU8(address: number, value: number) -> boolean
Writes an unsigned 8-bit integer at the given address.
memory.WriteU8(addr, 1)memory.WriteI8
Section titled “memory.WriteI8”memory.WriteI8(address: number, value: number) -> boolean
Writes a signed 8-bit integer at the given address.
memory.WriteI8(addr, -1)memory.WriteU16
Section titled “memory.WriteU16”memory.WriteU16(address: number, value: number) -> boolean
Writes an unsigned 16-bit integer at the given address.
memory.WriteU16(addr, 1000)memory.WriteI16
Section titled “memory.WriteI16”memory.WriteI16(address: number, value: number) -> boolean
Writes a signed 16-bit integer at the given address.
memory.WriteI16(addr, -1000)memory.WriteU32
Section titled “memory.WriteU32”memory.WriteU32(address: number, value: number) -> boolean
Writes an unsigned 32-bit integer at the given address.
memory.WriteU32(addr, 100)memory.WriteI32
Section titled “memory.WriteI32”memory.WriteI32(address: number, value: number) -> boolean
Writes a signed 32-bit integer at the given address.
memory.WriteI32(addr, -100)memory.WriteF32
Section titled “memory.WriteF32”memory.WriteF32(address: number, value: number) -> boolean
Writes a 32-bit float at the given address.
memory.WriteF32(addr, 1.5)memory.WriteF64
Section titled “memory.WriteF64”memory.WriteF64(address: number, value: number) -> boolean
Writes a 64-bit double at the given address.
memory.WriteF64(addr, 1.5)memory.WriteBool
Section titled “memory.WriteBool”memory.WriteBool(address: number, value: boolean) -> boolean
Writes a single byte (0 or 1) representing a boolean at the given address.
memory.WriteBool(addr, true)Scanning
Section titled “Scanning”memory.ScanInstances
Section titled “memory.ScanInstances”memory.ScanInstances(vtableAddress: number) -> {number}
Scans the engine for live instances matching the given vtable address and returns their addresses.
local hits = memory.ScanInstances(vt)memory.ScanVtable
Section titled “memory.ScanVtable”memory.ScanVtable(vtableAddress: number) -> {number}
Alias for memory.ScanInstances.
local hits = memory.ScanVtable(vt)memory.Scan
Section titled “memory.Scan”memory.Scan(start: number, length: number, value: number, type: string?) -> {number}
Scans a memory region of up to 64 MiB for occurrences of a typed value (u8/i8/u16/i16/u32/i32/u64/i64/f32/f64, default u32) and returns matching addresses.
local hits = memory.Scan(base, 0x100000, 100, "i32")memory.AobScan
Section titled “memory.AobScan”memory.AobScan(start: number, length: number, pattern: string) -> {number}
Scans a memory region of up to 64 MiB for a byte pattern (hex tokens with ? or * wildcards) and returns matching addresses.
local hits = memory.AobScan(base, 0x100000, "48 8B ?? ?? 89")memory.ScanSignature
Section titled “memory.ScanSignature”memory.ScanSignature(start: number, length: number, pattern: string) -> {number}
Alias for memory.AobScan.
local hits = memory.ScanSignature(base, 0x100000, "48 8B ??")Watch & map
Section titled “Watch & map”memory.WatchAccess
Section titled “memory.WatchAccess”memory.WatchAccess(address: number, len: number?, rw: number?, timeout: number?) -> table?, string?
Arms a hardware watchpoint (requires root/kernel module) and blocks until the engine accesses the address, returning the faulting RIP and general-purpose registers, or nil plus an error string on timeout or arm failure.
local info = memory.WatchAccess(addr, 8, 3, 5)if info then print(info.rip) endmemory.MapRegion
Section titled “memory.MapRegion”memory.MapRegion(base: number, len: number, mode: string?) -> boolean
Maps a memory region of up to 256 MiB into the kernel-shared read path for fast repeated access; mode is “stable” (default) or “heap”.
memory.MapRegion(base, 0x1000, "stable")memory.MapZap
Section titled “memory.MapZap”memory.MapZap() -> ()
Clears the currently mapped region’s cached contents.
memory.MapZap()memory.UnmapRegion
Section titled “memory.UnmapRegion”memory.UnmapRegion() -> ()
Unmaps the currently mapped memory region.
memory.UnmapRegion()memory.IsMapped
Section titled “memory.IsMapped”memory.IsMapped(address: number) -> boolean
Returns true if the given address falls within the currently mapped region.
if memory.IsMapped(addr) then print("mapped") endmemory.Watch
Section titled “memory.Watch”memory.Watch(address: number, type: string?, callback: function, interval: number?) -> table
Polls a typed value at an address on an interval (default 0.1s) via a spawned task and invokes callback(newValue, oldValue) on change; returns a handle with a Stop method. Implemented in Lua on top of the typed Read functions, type is one of u8/i8/u16/i16/u32/i32/f32/f64/ptr/bool (default u32).
local w = memory.Watch(addr, "i32", function(new, old) print(new, old) end, 0.25)w:Stop()memory.CreateWriteLoop
Section titled “memory.CreateWriteLoop”memory.CreateWriteLoop(address: number, value: number | string, type: string?) -> WriteLoop
Registers a value to be written to the address every frame, holding it against the game. Returns a handle with Stop() and Set(value). type is one of u8/i8/u16/i16/u32/i32/u64/i64/f32/f64/bool/ptr/string (default u32).
local loop = memory.CreateWriteLoop(addr, 100, "f32")loop:Set(120)loop:Stop()memory.ImmediateWatch
Section titled “memory.ImmediateWatch”memory.ImmediateWatch(address: number, type: string?, callback: function) -> Watch
Watches an address on the per-frame loop and calls callback(new, old) whenever the value changes. Returns a handle with Stop(). type is one of u8/i8/u16/i16/u32/i32/u64/i64/f32/f64/bool/ptr (default u32).
local w = memory.ImmediateWatch(addr, "i32", function(new, old) print(new, old) end)w:Stop()