Path Notation

Understanding RbxGenie’s dot-separated path format for addressing instances

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'"
}