Skip to main content
RbxGenie uses a dot-separated path notation to reference instances in the Roblox game tree. Paths always start with a service name and descend through child instances.

​
Format

<ServiceName>.<Child>.<Grandchild>...

​
Examples

Workspace.BasePlate
ServerScriptService.GameManager
StarterGui.MyGui.Frame.Button
ReplicatedStorage.Modules.DataStore

​
Supported Root Services

The following services can be used as path roots:
  • Workspace
  • Players
  • Lighting
  • ReplicatedStorage
  • ReplicatedFirst
  • ServerScriptService
  • ServerStorage
  • StarterGui
  • StarterPack
  • StarterPlayer
  • Teams
  • SoundService
  • TextChatService
  • CollectionService
  • Chat
  • LocalizationService
Implementation from PathResolver.lua:5-27: 
local ROOTS: { [string]: Instance } = {
  Workspace       = game:GetService("Workspace"),
  Players         = game:GetService("Players"),
  Lighting        = game:GetService("Lighting"),
  ReplicatedStorage = game:GetService("ReplicatedStorage"),
  ReplicatedFirst = game:GetService("ReplicatedFirst"),
  ServerScriptService = game:GetService("ServerScriptService"),
  ServerStorage   = game:GetService("ServerStorage"),
  StarterGui      = game:GetService("StarterGui"),
  StarterPack     = game:GetService("StarterPack"),
  StarterPlayer   = game:GetService("StarterPlayer"),
  Teams           = game:GetService("Teams"),
  SoundService    = game:GetService("SoundService"),
  TextChatService = game:GetService("TextChatService"),
  UserInputService = game:GetService("UserInputService"),
  RunService      = game:GetService("RunService"),
  TweenService    = game:GetService("TweenService"),
  CollectionService = game:GetService("CollectionService"),
  HttpService     = game:GetService("HttpService"),
  CoreGui         = game:GetService("CoreGui"),
  Chat            = game:GetService("Chat"),
  LocalizationService = game:GetService("LocalizationService"),
}

​
Path Resolution

Paths are resolved by traversing the instance tree from the service root: Implementation from PathResolver.lua:29-57: 
function PathResolver.resolve(path: string): (Instance?, string?)
  if not path or path == "" then
    return nil, "Empty path"
  end

  local parts = path:split(".")
  local root = ROOTS[parts[1]]

  if not root then
    -- Try game:GetService fallback
    local ok, svc = pcall(function() return game:GetService(parts[1]) end)
    if ok and svc then
      root = svc
    else
      return nil, "Unknown root service: " .. parts[1]
    end
  end

  local current: Instance = root
  for i = 2, #parts do
    local child = current:FindFirstChild(parts[i])
    if not child then
      return nil, ("Path not found at segment [%d] '%s' in '%s'"):format(i, parts[i], path)
    end
    current = child
  end

  return current, nil
end

​
Error Handling

If a path segment cannot be found, the resolver returns an error indicating the exact segment that failed: 
"Path not found at segment [3] 'Button' in 'StarterGui.MyGui.Button'"

​
Building Paths from Instances

You can also convert an instance back to a path string: Implementation from PathResolver.lua:59-67: 
function PathResolver.resolvePath(instance: Instance): string
  local parts: { string } = {}
  local current: Instance? = instance
  while current and current ~= game do
    table.insert(parts, 1, current.Name)
    current = current.Parent
  end
  return table.concat(parts, ".")
end

​
Usage in Tools

All RbxGenie tools use path notation to reference instances:

​
Single Instance Operations

{
  "path": "Workspace.Part",
  "property": "Anchored",
  "value": true
}

​
Multiple Instance Operations

{
  "paths": [
    "Workspace.Part1",
    "Workspace.Part2",
    "Workspace.Model.Part3"
  ],
  "property": "Transparency",
  "value": 0.5
}

​
Creating Objects

The path parameter specifies the parent: 
{
  "path": "Workspace",
  "className": "Part"
}
This creates a new Part inside Workspace.

​
Scoped Operations

Many search and query tools accept a path parameter to limit scope: 
{
  "query": "Button",
  "path": "StarterGui.MyGui"
}
This searches only within StarterGui.MyGui and its descendants.

​
Best Practices

​
Always Scope Searches

Never use broad paths without depth limits: 
// BAD: Searches entire game
{ "path": "game" }

// GOOD: Scoped to specific service
{ "path": "StarterGui", "depth": 2 }

​
Use Specific Paths

The more specific your path, the faster the operation: 
// SLOW: Broad search
{ "query": "Part", "path": "Workspace" }

// FAST: Direct path
{ "path": "Workspace.Model.Part" }

​
Handle Path Errors

Always check for path resolution errors in tool responses: 
{
  "ok": false,
  "error": "Path not found at segment [2] 'NonExistent' in 'Workspace.NonExistent'"
}

Build docs developers (and LLMs) love

Get started for freeTalk to us