> ## Documentation Index
> Fetch the complete documentation index at: https://docs.atlanta.gg/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory

> The low-level module for accessing and manipulating process memory. Provides specialized functions for reading and writing various data types (integers, floats, bytes) at specific memory addresses.

***

<Danger>Please ensure you have verified that both the **memory address** and the **value** you are reading or writing are correct. Improper use of these memory functions can lead to corrupted data, process crashes, or other unexpected and potentially unstable behavior within the targeted application. Use these functions only if you know exactly what you are doing.</Danger>

***

## Access

All memory C++ functions are exposed to your Lua script via a single global table named **`memory`**. You access individual values by using the dot (`.`) or bracket (`[]`) operator on this table.

```lua Memory Usage Example theme={null}
local memory_read_bytes = memory.read_bytes(0x7FF72D040000, (100 * 8)); -- Dot Operator
memory["write_uint64"](0x7FF72D040000, constants["uint64_max"]); -- Bracket Operator
```

***

## Functions

This section lists all available C++ functions exposed within the global **`memory`** table. These functions allow for low-level reading and writing of specific data types directly to and from process memory addresses.

***

### get\_base

Returns the game process' base address.

```lua theme={null}
get_base(): number
```

***

### read\_int8

Reads a signed 8-bit integer from the specified memory address.

```lua theme={null}
read_int8(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the 8-bit value.</ParamField>

### read\_int16

Reads a signed 16-bit integer from the specified memory address.

```lua theme={null}
read_int16(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the 16-bit value.</ParamField>

### read\_int32

Reads a signed 32-bit integer from the specified memory address.

```lua theme={null}
read_int32(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the 32-bit value.</ParamField>

### read\_int64

Reads a signed 64-bit integer from the specified memory address.

```lua theme={null}
read_int64(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the 64-bit value.</ParamField>

### read\_uint8

Reads an unsigned 8-bit integer from the specified memory address.

```lua theme={null}
read_uint8(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the unsigned 8-bit value.</ParamField>

### read\_uint16

Reads an unsigned 16-bit integer from the specified memory address.

```lua theme={null}
read_uint16(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the unsigned 16-bit value.</ParamField>

### read\_uint32

Reads an unsigned 32-bit integer from the specified memory address.

```lua theme={null}
read_uint32(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the unsigned 32-bit value.</ParamField>

### read\_uint64

Reads an unsigned 64-bit integer from the specified memory address.

```lua theme={null}
read_uint64(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the unsigned 64-bit value.</ParamField>

### read\_bool

Reads a boolean value from the specified memory address.

```lua theme={null}
read_bool(number: address): boolean
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the boolean value.</ParamField>

### read\_float

Reads a 32-bit floating-point number from the specified memory address.

```lua theme={null}
read_float(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the float value.</ParamField>

### read\_double

Reads a 64-bit floating-point number from the specified memory address.

```lua theme={null}
read_double(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the double value.</ParamField>

### read\_vector2

Reads a Vector2 from the specified memory address.

```lua theme={null}
read_vector2(number: address): Vector2
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Vector2 value.</ParamField>

### read\_vector3

Reads a Vector3 from the specified memory address.

```lua theme={null}
read_vector3(number: address): Vector3
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Vector3 value.</ParamField>

### read\_vector4

Reads a Vector4 from the specified memory address.

```lua theme={null}
read_vector4(number: address): Vector4
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Vector4 value.</ParamField>

### read\_matrix3

Reads a Matrix3 from the specified memory address.

```lua theme={null}
read_matrix3(number: address): Matrix3
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Matrix3 value.</ParamField>

### read\_matrix4

Reads a Matrix4 from the specified memory address.

```lua theme={null}
read_matrix4(number: address): Matrix4
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Matrix4 value.</ParamField>

### read\_cframe

Reads a CFrame (CoordinateFrame) from the specified memory address.

```lua theme={null}
read_cframe(number: address): CFrame
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the CFrame value.</ParamField>

### read\_rect

Reads a Rect from the specified memory address.

```lua theme={null}
read_rect(number: address): Rect
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Rect value.</ParamField>

### read\_udim

Reads a UDim from the specified memory address.

```lua theme={null}
read_udim(number: address): UDim
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the UDim value.</ParamField>

### read\_udim2

Reads a UDim2 from the specified memory address.

```lua theme={null}
read_udim2(number: address): UDim2
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the UDim2 value.</ParamField>

### read\_color3

Reads a Color3 from the specified memory address.

```lua theme={null}
read_color3(number: address): Color3
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Color3 value.</ParamField>

### read\_color4

Reads a Color4 from the specified memory address.

```lua theme={null}
read_color4(number: address): Color4
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the Color4 value.</ParamField>

### read\_string

Reads a string from the specified memory address with a given size.

```lua theme={null}
read_string(number: address, number: size): string
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the string.</ParamField>
<ParamField path="size" type="number" required>The size of the string to read in bytes.</ParamField>

### read\_byte

Reads a single byte (unsigned 8-bit integer) from the specified memory address.

```lua theme={null}
read_byte(number: address): number
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the byte value.</ParamField>

### read\_bytes

Reads multiple bytes from the specified memory address and returns them as a table.

```lua theme={null}
read_bytes(number: address, number: size): table
```

<ParamField path="address" type="number" required>The memory address (a number) from which to read the bytes.</ParamField>
<ParamField path="size" type="number" required>The number of bytes to read.</ParamField>

### write\_int8

Writes a signed 8-bit integer to the specified memory address.

```lua theme={null}
write_int8(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The signed 8-bit integer value to write.</ParamField>

### write\_int16

Writes a signed 16-bit integer to the specified memory address.

```lua theme={null}
write_int16(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The signed 16-bit integer value to write.</ParamField>

### write\_int32

Writes a signed 32-bit integer to the specified memory address.

```lua theme={null}
write_int32(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The signed 32-bit integer value to write.</ParamField>

### write\_int64

Writes a signed 64-bit integer to the specified memory address.

```lua theme={null}
write_int64(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The signed 64-bit integer value to write.</ParamField>

### write\_uint8

Writes an unsigned 8-bit integer to the specified memory address.

```lua theme={null}
write_uint8(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The unsigned 8-bit integer value to write.</ParamField>

### write\_uint16

Writes an unsigned 16-bit integer to the specified memory address.

```lua theme={null}
write_uint16(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The unsigned 16-bit integer value to write.</ParamField>

### write\_uint32

Writes an unsigned 32-bit integer to the specified memory address.

```lua theme={null}
write_uint32(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" types="number" required>The unsigned 32-bit integer value to write.</ParamField>

### write\_uint64

Writes an unsigned 64-bit integer to the specified memory address.

```lua theme={null}
write_uint64(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The unsigned 64-bit integer value to write.</ParamField>

### write\_bool

Writes a boolean value to the specified memory address.

```lua theme={null}
write_bool(number: address, boolean: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="boolean" required>The boolean value to write.</ParamField>

### write\_float

Writes a 32-bit floating-point number to the specified memory address.

```lua theme={null}
write_float(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The float value to write.</ParamField>

### write\_double

Writes a 64-bit floating-point number to the specified memory address.

```lua theme={null}
write_double(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The double value to write.</ParamField>

### write\_vector2

Writes a Vector2 to the specified memory address.

```lua theme={null}
write_vector2(number: address, Vector2: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Vector2" required>The Vector2 value to write.</ParamField>

### write\_vector3

Writes a Vector3 to the specified memory address.

```lua theme={null}
write_vector3(number: address, Vector3: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Vector3" required>The Vector3 value to write.</ParamField>

### write\_vector4

Writes a Vector4 to the specified memory address.

```lua theme={null}
write_vector4(number: address, Vector4: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Vector4" required>The Vector4 value to write.</ParamField>

### write\_matrix3

Writes a Matrix3 to the specified memory address.

```lua theme={null}
write_matrix3(number: address, Matrix3: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Matrix3" required>The Matrix3 value to write.</ParamField>

### write\_matrix4

Writes a Matrix4 to the specified memory address.

```lua theme={null}
write_matrix4(number: address, Matrix4: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Matrix4" required>The Matrix4 value to write.</ParamField>

### write\_cframe

Writes a CFrame (CoordinateFrame) to the specified memory address.

```lua theme={null}
write_cframe(number: address, CFrame: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="CFrame" required>The CFrame value to write.</ParamField>

### write\_rect

Writes a Rect to the specified memory address.

```lua theme={null}
write_rect(number: address, Rect: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Rect" required>The Rect value to write.</ParamField>

### write\_udim

Writes a UDim to the specified memory address.

```lua theme={null}
write_udim(number: address, UDim: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="UDim" required>The UDim value to write.</ParamField>

### write\_udim2

Writes a UDim2 to the specified memory address.

```lua theme={null}
write_udim2(number: address, UDim2: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="UDim2" required>The UDim2 value to write.</ParamField>

### write\_color3

Writes a Color3 to the specified memory address.

```lua theme={null}
write_color3(number: address, Color3: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Color3" required>The Color3 value to write.</ParamField>

### write\_color4

Writes a Color4 to the specified memory address.

```lua theme={null}
write_color4(number: address, Color4: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="Color4" required>The Color4 value to write.</ParamField>

### write\_string

Writes a string to the specified memory address.

```lua theme={null}
write_string(number: address, string: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the string.</ParamField>
<ParamField path="value" type="string" required>The string value to write.</ParamField>

### write\_byte

Writes a single byte (unsigned 8-bit integer) to the specified memory address.

```lua theme={null}
write_byte(number: address, number: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the value.</ParamField>
<ParamField path="value" type="number" required>The byte value to write.</ParamField>

### write\_bytes

Writes multiple bytes to the specified memory address from a table.

```lua theme={null}
write_bytes(number: address, table: value): void
```

<ParamField path="address" type="number" required>The memory address (a number) to which to write the bytes.</ParamField>
<ParamField path="value" type="table" required>A table containing the byte values to write.</ParamField>
