Skip to main content

Dex Explorer Guide

Dex is an in-game instance explorer — think of it as Roblox Studio's Explorer + Properties panels, but running live inside the game. It lets you browse every object, read and sometimes write properties, and understand how the game is built.

Getting Dex​

Dex is available in most executor script hubs. Search for "Dex Explorer" or "Dex V3". Inject it before or after joining a game — it works either way.

The Interface​

After injecting, a window opens with two main panels:

  • Left panel (tree): The game hierarchy. Click arrows to expand nodes.
  • Right panel (properties): The selected instance's properties — ClassName, Name, Parent, and all class-specific properties.

At the top there's usually a search bar and a refresh button.

Click any item in the tree to select it. Expand with the arrow/triangle. Common places to start:

  1. game.ReplicatedStorage — find remotes
  2. game.Workspace → your character name — inspect your character
  3. game.Workspace → look for enemy/NPC folders
  4. game.Players.LocalPlayer.PlayerScripts — find game logic scripts
  5. game.Players.LocalPlayer.PlayerGui — find UI scripts

Reading Properties​

Click any instance in the tree. The right panel shows all its properties. Important ones:

  • ClassName — what type it is (RemoteEvent, Model, Humanoid, NumberValue)
  • Name — the instance name (what you use in FindFirstChild)
  • Parent — where it sits in the tree
  • Value (for Value instances) — the actual data
  • For Parts: Position, Size, CFrame, Anchored, CanCollide, Transparency
  • For Humanoids: Health, MaxHealth, WalkSpeed, JumpPower

Finding Remotes​

  1. Navigate to ReplicatedStorage in Dex
  2. Expand folders until you see instances with ClassName RemoteEvent or RemoteFunction
  3. Note their exact names — you'll use these in WaitForChild
  4. Right-click or copy the full path

If you can't find remotes in ReplicatedStorage, try:

  • workspace (some games put them on parts)
  • Players.LocalPlayer (rare but happens)
  • Use rSpy instead — it captures fired remotes regardless of location

Copying Instance Paths​

When you find something useful, you need its full path to reference it in code. Dex usually shows the path in the properties panel. If not, you can read it:

-- Once you know the name, get the path
print(someInstance:GetFullName())
-- Output: "ReplicatedStorage.Remotes.AttackRemote"

Then in your script:

local remote = game.ReplicatedStorage.Remotes:WaitForChild("AttackRemote")
-- or broken down:
local Remotes = game.ReplicatedStorage:WaitForChild("Remotes")
local attackRemote = Remotes:WaitForChild("AttackRemote")

Reading Script Source​

LocalScripts and ModuleScripts have a .Source property in Dex (and you can read it in code):

local script = Players.LocalPlayer.PlayerScripts:FindFirstChild("GameClient")
if script then
    print(script.Source)  -- prints the Lua source code
end

This lets you read the game's own client code — finding function names, remote calls, event patterns, and sometimes credentials or keys embedded in the source.

note

In newer Roblox versions, .Source may be empty for loaded scripts. In that case use a decompiler tool (byfron bypass decompilers) or read via getscriptbytecode + decompile.

Finding Hidden Values on Characters​

Characters often have custom values attached that aren't obvious. In Dex, expand a player's character model and look for:

  • StringValue instances (team name, class, role)
  • NumberValue or IntValue (custom stats, level, coins)
  • BoolValue (flags like "isRaging", "isDead", "hasShield")
  • Folder (grouping related values)
  • Configuration (grouped settings)

These values tell you the game's state. Subscribe to them:

local rageValue = char:WaitForChild("IsRaging", 5)
if rageValue then
    rageValue.Changed:Connect(function(newVal)
        print("rage state changed:", newVal)
    end)
end

Tracing What Scripts Do​

If you find a LocalScript, read its source to understand what events it connects to and which remotes it fires. Search for:

  • RemoteEvent or RemoteFunction — to find remote references
  • :FireServer( — to see what arguments are sent
  • :Connect( — to see what events are handled
  • CollectionService — to find the tagging system used for entities

Dex as a Debugging Tool​

You can use Dex while your own script is running to verify:

  • Did my Highlight appear in CoreGui?
  • Is my BillboardGui parented correctly?
  • Is the Value I'm reading actually changing?

This is much faster than adding print statements everywhere.

Writing Properties in Dex​

Some properties in the right panel are editable — click on the value and type a new one. This is useful for quick experiments:

  • Change WalkSpeed directly and see if it works
  • Toggle Anchored on a part
  • Change FillTransparency on a Highlight

If writing doesn't work, the property might be protected or server-authoritative.