Minecraft Bedrock • DirectX 11 Target

Extreme Performance.
Modular. Scriptable. Glass.

Azyre Client is a native C++ DLL for Minecraft: Bedrock Edition (Windows). It pairs a DirectX 11 Present hook (MinHook) with an ImGui interface, an EnTT-based game-state ECS, a GPU glass/acrylic render pipeline, and a sandboxed Luau scripting runtime.

Azyre Client — In-Game Overlay
Azyre v1.1.0
W
A
S
D
AutoTool
FullBright
Trajectories
NameProtect
FPS: 240
CPS: 12
PING: 18 ms
30+
Feature Modules
Luau
Sandboxed Scripting
DX11
Native Render Hook
3
Supported Toolchains
Feature Catalog

Client Modules

Search and filter through Combat, Movement, Visuals, Misc and Scripting modules configurable directly from the Azyre ClickGUI.

Extend Without Rebuilding

Luau Scripting

Azyre embeds a sandboxed Luau runtime. Each script runs in its own VM, returns a module table, and gets first-class access to the game, drawing, input and friends APIs.

Overview

Scripts are plain .lua files (Luau syntax) placed in the client's Scripts/ folder. On boot, every script is compiled into its own isolated VM and, if it returns a valid module table, registered as a first-class client module.

  • One VM per script — scripts cannot interfere with each other.
  • Sandboxed: the debug library is removed and os is limited to read-only time functions.
  • Settings are declarative and persist through the config system (keyed by setting id).
  • Scripts appear in the Scripting tab of the ClickGUI and can be toggled like any module.
💡
The scripting runtime is exposed entirely through native bindings — no file I/O, no arbitrary memory access, no require of native modules.

Quick start

Drop a file such as Scripts/hello.lua and reload with .script reload in chat, or restart the client.

Scripts/hello.lua
-- Every script returns a module table.
local module = {
    name = "Hello",
    description = "A minimal Azyre script",
    keybind = "H", -- single character, or a VK code number
}

function module.onEnable()
    ui.notify("Hello from Azyre!")
end

function module.onTick()
    local me = game.localPlayer()
    if me and me.onGround then
        -- ...
    end
end

return module
chat commands
CommandDescription
.script reloadRecompiles all loaded scripts and loads any new .lua files. Preserves setting values by id.
.script listLists every loaded script; faulty scripts are flagged with (error).
.script remove <name>Unloads the module and deletes its .lua file from disk. Accepts the module name or the file name.

Module table

The chunk must return a table. Recognised fields:

FieldTypeNotes
namestringDisplay name (defaults to the file name).
descriptionstringShown as the module tooltip.
keybindstring | numberA single character (e.g. "H") or a raw VK code.
settingstableArray of setting declarations (see below).
category—Ignored: scripts always live in the Scripting category.

Settings

Declare settings as an array. Each entry renders a native widget and its value is saved/loaded by the config system.

KeyTypeNotes
idstringUnique key used in the settings table and in saved JSON.
labelstringWidget label.
typestring"slider" · "checkbox" / "bool" / "boolean" · "combo" / "list"
min / maxnumberRange for sliders. If max <= min it falls back to min + 1.
valuenumber | boolDefault value.
optionsstring[]Required for combo; the numeric value is the 1-based index.
settings declaration
settings = {
    { id = "speed",  label = "Speed",  type = "slider",   min = 1, max = 10, value = 5 },
    { id = "legit",  label = "Legit",  type = "checkbox", value = true },
    { id = "mode",   label = "Mode",   type = "combo",    options = { "Vanilla", "Legit" }, value = 1 },
}

-- Inside any callback, read the live values:
function module.onTick()
    if settings.legit then
        local s = settings.speed
        -- ...
    end
end

Lifecycle callbacks

Define any of the following functions on the module table. They are invoked exactly like native modules (main thread, once per frame / tick as appropriate).

CallbackWhen
onEnable()Module was turned on.
onDisable()Module was turned off.
onTick()Fixed game tick (≈20 Hz). Best place for movement / interactions.
onRender()Every rendered frame. Best place for draw.* calls.
onCommand(cmd)A chat command line starting with your prefix was sent (raw string).
onShutdown()Client is unloading.

API · game

Read and write local player state. All setters no-op safely when no world is loaded.

FunctionReturnsDescription
game.localPlayer()table | nilname, x, y, z, vx, vy, vz, yaw, pitch, health, height, onGround, slot, leftClick, usingItem, hurtTime, isHurt, eyeX, eyeY, eyeZ
game.players()table[]Remote players: name, x, y, z, yaw, pitch, health, height, onGround.
game.setVelocity(x, y, z)—Sets the local player's velocity vector.
game.setVelocityXZ(x, z)—Sets horizontal velocity only.
game.setPos(x, y, z)—Teleports the local player.
game.setOnGround(bool)—Forces the ground flag.
game.setYaw(deg)—Sets yaw (degrees).
game.setPitch(deg)—Sets pitch, clamped to −90…90.
game.hotbar()table | nil9 entries of { valid, count, block } plus .selected.
game.setHotbarSlot(slot)—Selects hotbar slot, clamped to 0…8.
game.click([fast])—Simulates an attack/use click (fast skips cooldown where possible).
game.camera()table | nilx, y, z, yaw, pitch of the active camera.
game.worldToScreen(x, y, z)number, number | nilProjects a world position to screen coordinates.

API · modules

FunctionReturnsDescription
modules.toggle(name, bool)—Enables or disables a module by name.
modules.enabled(name)bool | nilCurrent state, or nil if unknown.
modules.list()table[]{ name, enabled, category } for every registered module.

API · input

FunctionReturnsDescription
input.isDown(key)boolKey may be a VK number or a name: A–Z, 0–9, F1–F24, SPACE, SHIFT, CTRL, ALT, TAB, ENTER, ESC, LMB, RMB, MBUTTON, XBUTTON1/2.
input.mouseDown([btn])bool0 = left (default), 1 = right, 2 = middle.
input.mouseX() / input.mouseY()numberCursor position in screen pixels.

API · draw

All drawing happens on the foreground overlay; call from onRender. Colors are r, g, b[, a] in 0…255 (defaults to white).

FunctionReturnsDescription
draw.text(x, y, text[, r,g,b[,a]])—Draws a text string.
draw.rect(x1, y1, x2, y2[, filled[, r,g,b[,a]]])—Rectangle (filled by default).
draw.line(x1, y1, x2, y2[, r,g,b[,a]])—A line.
draw.circle(x, y, r[, r,g,b[,a]])—Outlined circle.
draw.filledCircle(x, y, r[, r,g,b[,a]])—Filled circle.
draw.textSize(text)number, numberMeasured width and height of text.
draw.width() / draw.height()numberScreen dimensions in pixels.

API · ui, chat, friends

ui
FunctionReturnsDescription
ui.notify(text)—Shows a toast notification on screen.
chat
FunctionReturnsDescription
chat.display(text)boolPrints a local message to the in-game chat.
friends
FunctionReturnsDescription
friends.isFriend(name)boolWhether the name is on the friends list.
friends.toggle(name)bool | nilAdds/removes and returns the new state.
friends.list()string[]All friend names.

Examples

1 · Sprint-boost with a toggle

bhop.lua
local module = {
    name = "AutoJump",
    description = "Jumps while holding the space bar",
    keybind = "J",
    settings = {
        { id = "power", label = "Jump power", type = "slider", min = 0.3, max = 0.6, value = 0.42 },
    },
}

function module.onTick()
    if input.isDown("SPACE") then
        local me = game.localPlayer()
        if me and me.onGround then
            game.setVelocity(me.vx, settings.power, me.vz)
        end
    end
end

return module

2 · On-screen info via the draw API

info.lua
local module = { name = "Info", description = "Draws your coordinates" }

function module.onRender()
    local me = game.localPlayer()
    if not me then return end
    local label = string.format("%.1f  %.1f  %.1f", me.x, me.y, me.z)
    draw.rect(10, 10, 10 + draw.textSize(label) + 16, 34, true, 12, 14, 22, 190)
    draw.text(18, 17, label, 210, 225, 255, 255)
end

return module

3 · Highlight players through the draw API

tracers.lua
local module = { name = "Tracer", description = "Line to every non-friend player" }

function module.onRender()
    local w, h = draw.width(), draw.height()
    for _, p in ipairs(game.players()) do
        if not friends.isFriend(p.name) then
            local sx, sy = game.worldToScreen(p.x, p.y + p.height, p.z)
            if sx then
                draw.line(w / 2, h, sx, sy, 160, 200, 255, 170)
            end
        end
    end
end

return module

Error handling & notes

  • A runtime error in any callback is logged, a toast is shown, and the script module is automatically disabled until reloaded.
  • reload preserves setting values by matching their id.
  • Scripts run on the client's main thread — keep onTick/onRender lightweight.
  • There is no CPU/time quota: an infinite loop in a callback will stall the client.
⚠
.script remove deletes the file. Keep backups of scripts you care about.
C++ Engineering

Internal Architecture

Built from the ground up prioritizing memory efficiency, low-latency hooks, and an extensible modular design.

⚡

DirectX 11 Present Hook

Swap-chain hooking into IDXGISwapChain::Present via MinHook to render the ImGui overlay without disrupting the game pipeline.

🧩

EnTT Game-State ECS

Players and world blocks are synchronized into an EnTT registry with events (join/leave/hurt), so modules consume clean data instead of raw offsets.

🎨

Glass / Acrylic Pipeline

A GPU capture → separable Gaussian → rounded-SDF glass composite with refraction and edge lighting, applied to the menu and HUD panels.

📜

Sandboxed Luau Runtime

Per-script VM with declarative settings and native game/draw/input bindings — extend the client without recompiling.

⚙️

Config Manager (JSON)

nlohmann/json persistence for module states, keybinds, presets, HUD layout and script settings.

🛡️

Fault-Isolated Modules

SEH + C++ exception guards around every module callback: a faulty module is disabled instead of crashing the process.

Build Prerequisites

Development Requirements

Ensure your workstation has a supported toolchain, CMake and the Windows SDK before building.

💻

Visual Studio 2026 (MSVC)

Primary toolchain. Install the Desktop development with C++ workload (x64) — includes the MSVC compiler and CMake integration.

🛠️

Clang-CL & MinGW (optional)

The build is compiler-aware: it also validates with the Clang-CL toolset and MinGW-w64 GCC (via MSYS2).

📦

CMake 3.25+

All third-party dependencies (ImGui, MinHook, Luau, SoLoud, EnTT, nlohmann/json) are fetched automatically via FetchContent.

🪟

Windows SDK (10/11)

Provides the DirectX 11 headers (d3d11, dxgi), d3dcompiler and the C++/WinRT headers used by the WinRT integrations.

Open Source Codebase

GitHub Repository

Explore the live repository codebase, directory structure, and latest commits fetched directly from GitHub.

AnarchDevelopment / AzyreDll public
View on GitHub
branch: main
Latest Commit: Loading… —
Recent Repository Commits
⟳ Fetching latest commits from GitHub API…
Development & Build

Compilation & Injection

Build AzyreSDK.dll with CMake using MSVC, Clang-CL or MinGW-w64, then inject it into Minecraft.Win10.DX11.exe.

1

Clone Repository

Clone the source: git clone https://github.com/AnarchDevelopment/AzyreDll.git

2

Configure & Build

Use CMake with a supported toolchain. Dependencies download automatically during the configure step.

3

Locate the Binary

The DLL is produced at build/Release/AzyreSDK.dll (MSVC/Clang-CL) or build/AzyreSDK.dll (MinGW).

4

Inject

Inject AzyreSDK.dll into Minecraft.Win10.DX11.exe, then press INSERT to open the Azyre ClickGUI.

MSVC — Visual Studio generator (recommended)
git clone https://github.com/AnarchDevelopment/AzyreDll.git
cd AzyreDll

cmake -B build -G "Visual Studio 18 2026" -A x64
cmake --build build --config Release --parallel

# Output: build/Release/AzyreSDK.dll
Clang-CL & MinGW-w64 (GCC)
# Clang-CL (VS toolset)
cmake -B build -G "Visual Studio 18 2026" -A x64 -T ClangCL
cmake --build build --config Release --parallel

# MinGW-w64 / GCC (Ninja, single-config)
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release ^
      -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++
cmake --build build --parallel