# Table of Contents

- [Getting Started](#getting-started)
- [Local Development](#local-development)
- [Overview](#overview)
- [Contributing](#contributing)
- [API Reference](#api-reference)

---

# Getting Started

Getting Started
===============

Getting Started with Cobalt

* * *

![Cobalt](https://github.com/user-attachments/assets/d88e0da7-0f48-46d0-86c2-5e721fa350c9)

* * *

[Introduction](https://docs.mspaint.cc/cobalt#introduction)

------------------------------------------------------------

Welcome to the official documentation for Cobalt, a runtime developer tool for the Roblox Game Engine to monitor and intercept incoming and outgoing network traffic.

[Why Cobalt?](https://docs.mspaint.cc/cobalt#why-cobalt)

---------------------------------------------------------

*   Beautiful and opinionated UI
*   Incoming & Outgoing remote **monitoring** and **interception**
*   Full Actor support
*   Pagination to prevent lag
*   Smart code generation
*   File logging
*   Plugin support

[Usage](https://docs.mspaint.cc/cobalt#usage)

----------------------------------------------

Run the following loadstring to start using cobalt:

    -- https://discord.gg/FJcJMuze7S
    loadstring(game:HttpGet("https://github.com/notpoiu/cobalt/releases/latest/download/Cobalt.luau"))()

[Next\
\
Local Development](https://docs.mspaint.cc/cobalt/development)

### On this page

[Introduction](https://docs.mspaint.cc/cobalt#introduction)
[Why Cobalt?](https://docs.mspaint.cc/cobalt#why-cobalt)
[Usage](https://docs.mspaint.cc/cobalt#usage)

---

# Local Development

Local Development
=================

Local Development for Cobalt

Cobalt uses the [wax](https://github.com/latte-soft/wax)
 [bundler](https://en.wikipedia.org/wiki/Module_bundler)
 to bundle the script. If wax is not setup, you must use the following instructions to build the script:

[Setup](https://docs.mspaint.cc/cobalt/development#setup)

----------------------------------------------------------

### [1\. Installing Rokit](https://docs.mspaint.cc/cobalt/development#1-installing-rokit)

[Rokit](https://github.com/rojo-rbx/rokit)
 is a toolchain manager for Roblox projects. Open a terminal and run the install command for your operating system:

macOS / LinuxWindows

Open **Terminal** and run the following command:

    curl -sSf https://raw.githubusercontent.com/rojo-rbx/rokit/main/scripts/install.sh | bash

### [2\. Clone the Repository](https://docs.mspaint.cc/cobalt/development#2-clone-the-repository)

    git clone https://github.com/notpoiu/cobalt.git
    cd cobalt

### [3\. Install Toolchain](https://docs.mspaint.cc/cobalt/development#3-install-toolchain)

Once inside the Cobalt directory, install the required tools with Rokit:

    rokit install

If prompted to trust any tools, select **yes** to allow them to be installed.

### [4\. Building Cobalt](https://docs.mspaint.cc/cobalt/development#4-building-cobalt)

You can build Cobalt using the **VSCode build task** or the **command line**.

VSCode Build TaskCommand Line

Press Ctrl + Shift + B (or ⌘ + Shift + B on macOS) to run the default build task.

### [5\. Testing Your Changes](https://docs.mspaint.cc/cobalt/development#5-testing-your-changes)

We recommend using the [Live Server](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer)
 extension for VSCode to serve the built script locally.

1.  Install the [Live Server](https://marketplace.visualstudio.com/items?itemName=ritwickdey.LiveServer)
     extension in VSCode.
2.  Open the Cobalt project folder in VSCode.
3.  Click the **"Go Live"** button in the bottom-right corner of VSCode's status bar.
4.  Make sure the port matches the one in your loadstring below (default is `5500`).
5.  Use the loadstring below in your executor to load the locally served script.

[Playground](https://docs.mspaint.cc/cobalt/development#playground)

--------------------------------------------------------------------

Use the playground below to generate a loadstring with a custom base URL. This is useful when testing local builds or hosting the script yourself.

[Previous\
\
Getting Started](https://docs.mspaint.cc/cobalt)
[Next\
\
Contributing](https://docs.mspaint.cc/cobalt/contributing)

### On this page

[Setup](https://docs.mspaint.cc/cobalt/development#setup)
[1\. Installing Rokit](https://docs.mspaint.cc/cobalt/development#1-installing-rokit)
[2\. Clone the Repository](https://docs.mspaint.cc/cobalt/development#2-clone-the-repository)
[3\. Install Toolchain](https://docs.mspaint.cc/cobalt/development#3-install-toolchain)
[4\. Building Cobalt](https://docs.mspaint.cc/cobalt/development#4-building-cobalt)
[5\. Testing Your Changes](https://docs.mspaint.cc/cobalt/development#5-testing-your-changes)
[Playground](https://docs.mspaint.cc/cobalt/development#playground)

---

# Overview

Overview
========

An overview of how to create plugins for Cobalt

[What are plugins?](https://docs.mspaint.cc/cobalt/plugins/overview#what-are-plugins)

--------------------------------------------------------------------------------------

Plugins are scripts that extend the functionality of Cobalt. The plugin API gives you access to the spy, UI, code generation, and settings systems — allowing you to intercept remote calls, add custom UI, modify generated code, and more.

[Getting Started](https://docs.mspaint.cc/cobalt/plugins/overview#getting-started)

-----------------------------------------------------------------------------------

On load, Cobalt creates the folder `Cobalt/Plugins` in your executor's workspace directory. To create a plugin, add a `.luau` or `.lua` file to that folder and set `Cobalt.PluginData` at the top of the file.

    Cobalt.PluginData = {
        Name = "My Plugin",
        Description = "A short description of what this plugin does.",
        Author = "YourName",
        Version = "1.0.0",
        Game = "*",
    }

[What can plugins do?](https://docs.mspaint.cc/cobalt/plugins/overview#what-can-plugins-do)

--------------------------------------------------------------------------------------------

*   **Intercept remote calls** — Hook into incoming and outgoing remote events/functions, suppress or modify log entries
*   **Append virtual logs** — Inject decoded protocol traffic (e.g. ByteNet packets) as custom log entries
*   **Customize code generation** — Override the generated code when copying calls, hooks, or instance paths
*   **Create settings UI** — Add checkboxes, buttons, text inputs, and dropdowns that persist automatically
*   **Build custom modals** — Create resizable, tabbed modal dialogs with footer buttons
*   **Extend remote info** — Add custom tabs and footer buttons to the remote info panel
*   **Add context menu options** — Add right-click options to the remote list and call list
*   **Show notifications** — Display toast messages via `Cobalt.Sonner`
*   **Lifecycle management** — Clean up resources when the plugin is unloaded

For the full API reference, see the [API Reference](https://docs.mspaint.cc/cobalt/plugins/api)
 page.

[Previous\
\
Contributing](https://docs.mspaint.cc/cobalt/contributing)
[Next\
\
API Reference](https://docs.mspaint.cc/cobalt/plugins/api)

### On this page

[What are plugins?](https://docs.mspaint.cc/cobalt/plugins/overview#what-are-plugins)
[Getting Started](https://docs.mspaint.cc/cobalt/plugins/overview#getting-started)
[What can plugins do?](https://docs.mspaint.cc/cobalt/plugins/overview#what-can-plugins-do)

---

# Contributing

Contributing
============

Contributing to Cobalt

Our official repository can be found on [GitHub](https://github.com/notpoiu/cobalt)
. Any other forks of the repository may not be fully compatible with our documentation.

[GitHubnotpoiu/cobalt\
\
94](https://github.com/notpoiu/cobalt)

[Contributing to Cobalt](https://docs.mspaint.cc/cobalt/contributing#contributing-to-cobalt)

---------------------------------------------------------------------------------------------

1.  Use the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/)
     format when contributing to Cobalt.
2.  Please make sure to have used spaces instead of tabs for indentation.
3.  When creating a pull request, please describe the changes you made and why you made them.

[Previous\
\
Local Development](https://docs.mspaint.cc/cobalt/development)
[Next\
\
Overview](https://docs.mspaint.cc/cobalt/plugins/overview)

### On this page

[Contributing to Cobalt](https://docs.mspaint.cc/cobalt/contributing#contributing-to-cobalt)

---

# API Reference

API Reference
=============

API Reference for Cobalt Plugins

[Cobalt](https://docs.mspaint.cc/cobalt/plugins/api#cobalt)

------------------------------------------------------------

This is the global table available in every plugin's environment. It provides access to all plugin APIs.

### [PluginData](https://docs.mspaint.cc/cobalt/plugins/api#plugindata)

This is the table that contains the information about the plugin. It is **required** to be set and should be the first thing that executes in the file.

| Prop | Type | Default |
| --- | --- | --- |
| `Name` | `string` | \-  |
| `Description` | `string` | `"No description provided."` |
| `Author` | `string` | `"N/A"` |
| `Version` | `string` | `"0.0.0"` |
| `Game` | `string \| number \| table` | `"*"` |

**Example**

    Cobalt.PluginData = {
        Name = "ByteNet",
        Description = "Decodes ByteNet packets in Cobalt.",
        Author = "upio",
        Version = "1.0.0",
        Game = "*",
    }

If the current game does not match the `Game` field, the plugin thread is automatically cancelled and will not run.

* * *

### [Settings](https://docs.mspaint.cc/cobalt/plugins/api#settings)

A proxy table that reads and writes persistent settings to `Cobalt/Settings.json`. This includes both built-in Cobalt settings and plugin settings.

**Example**

    -- Read a built-in setting
    local showWatermark = Cobalt.Settings["ShowWatermark"]
     
    -- Read a plugin setting (uses the full prefixed key)
    local suppress = Cobalt.Settings["PluginSettings-MyPlugin-SuppressRaw"]
     
    -- Write a setting
    Cobalt.Settings["MyCustomKey"] = true

* * *

### [Sonner](https://docs.mspaint.cc/cobalt/plugins/api#sonner)

The toast notification system. Exposes `success`, `error`, and other methods.

**Example**

    Cobalt.Sonner.success("Operation complete!")
    Cobalt.Sonner.error("Something went wrong.")

* * *

### [ExecutorSupport](https://docs.mspaint.cc/cobalt/plugins/api#executorsupport)

A table containing the results of executor capability checks. Use this to gate features based on what the executor supports.

**Example**

    if Cobalt.ExecutorSupport["run_on_actor"].IsWorking then
        print("Actor support available!")
    end

* * *

### [BindToUnload](https://docs.mspaint.cc/cobalt/plugins/api#bindtounload)

Binds a cleanup callback that runs when the plugin is unloaded (e.g. on rescan or Cobalt exit).

    Cobalt:BindToUnload(Callback: () -> ())

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The function to call on unload | `() -> ()` |

**Example**

    Cobalt:BindToUnload(function()
        myFolder:Destroy()
        print("Plugin unloaded!")
    end)

Always clean up Instances, connections, and state in your unload callback to prevent memory leaks.

* * *

### [GetLog](https://docs.mspaint.cc/cobalt/plugins/api#getlog)

Gets the tracked log for a specific instance and direction.

    Cobalt:GetLog(instance: Instance, type: "Incoming" | "Outgoing")

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The remote instance | `Instance` |
| 2   | The direction | `"Incoming" \| "Outgoing"` |

**Example**

    local log = Cobalt:GetLog(someRemote, "Outgoing")
    if log then
        print("Total calls:", #log.Calls)
    end

* * *

[Cobalt.Spy](https://docs.mspaint.cc/cobalt/plugins/api#cobaltspy)

-------------------------------------------------------------------

Functions for intercepting, appending, and clearing remote call logs.

### [InterceptExecutedCalls](https://docs.mspaint.cc/cobalt/plugins/api#interceptexecutedcalls)

Hooks into the spy pipeline to intercept remote calls as they happen.

    Cobalt.Spy:InterceptExecutedCalls(
        Type: "Incoming" | "Outgoing" | "All",
        Data: InterceptorFunction | { Callback: InterceptorFunction, Instance: Instance? }
    ) -> () -> ()

The callback receives `(info, instance, callType)` where:

*   `info` contains `Arguments`, `Origin`, `Function`, `Line`, `IsExecutor`, etc.
*   `instance` is the `RemoteEvent` / `RemoteFunction` / etc.
*   `callType` is `"Incoming"` or `"Outgoing"`

**Return values from the callback:**

*   Return nothing — allow the call through normally
*   Return `false` — suppress the log entry from appearing

**Returns** a cleanup function that removes the interceptor when called.

**Example — Global interceptor**

    local cleanup = Cobalt.Spy:InterceptExecutedCalls("All", function(info, instance, callType)
        if instance.Name == "ByteNetReliable" then
            return false -- suppress from the log
        end
    end)
     
    -- Later: cleanup()

**Example — Instance-specific interceptor**

    local remote = game.ReplicatedStorage.MyRemote
     
    Cobalt.Spy:InterceptExecutedCalls("Outgoing", {
        Instance = remote,
        Callback = function(info, instance, callType)
            print("Caught call:", info.Arguments)
        end,
    })

* * *

### [AppendLog](https://docs.mspaint.cc/cobalt/plugins/api#appendlog)

Injects a custom log entry for a remote instance. Commonly used with virtual `BindableEvent` instances to display decoded protocol traffic.

    Cobalt.Spy:AppendLog(
        Instance: Instance,
        Type: "Incoming" | "Outgoing",
        Data: table
    )

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The remote instance (can be a virtual BindableEvent) | `Instance` |
| 2   | The direction | `"Incoming" \| "Outgoing"` |
| 3   | The call data table | `table` |

| Prop | Type | Default |
| --- | --- | --- |
| `Arguments` | `table` | \-  |
| `Origin` | `string?` | \-  |
| `Function` | `string?` | \-  |
| `Line` | `number?` | \-  |
| `IsExecutor` | `boolean?` | \-  |

**Example**

    local virtualRemote = Instance.new("BindableEvent")
    virtualRemote.Name = "MyProtocol::Packet"
     
    Cobalt.Spy:AppendLog(virtualRemote, "Incoming", {
        Arguments = table.pack({ Health = 100, Position = Vector3.new(0, 5, 0) }),
        Origin = "MyPlugin",
    })

* * *

### [ClearLogs](https://docs.mspaint.cc/cobalt/plugins/api#clearlogs)

Clears tracked logs, optionally filtering by instance and/or direction.

    Cobalt.Spy:ClearLogs(Instance: Instance?, Type: ("Incoming" | "Outgoing" | "All")?)

| Arg | Description | Type |
| --- | --- | --- |
| 1   | Optional instance to clear logs for | `Instance?` |
| 2   | Optional direction filter | `"Incoming" \| "Outgoing" \| "All"?` |

**Example**

    -- Clear all logs
    Cobalt.Spy:ClearLogs()
     
    -- Clear logs for a specific remote
    Cobalt.Spy:ClearLogs(someRemote, "Outgoing")

* * *

[Cobalt.CodeGen](https://docs.mspaint.cc/cobalt/plugins/api#cobaltcodegen)

---------------------------------------------------------------------------

Functions for intercepting and customizing code generation.

### [InterceptGeneration](https://docs.mspaint.cc/cobalt/plugins/api#interceptgeneration)

Intercepts Cobalt's code generation pipeline. If the callback returns a string, it replaces the default generated code. If it returns `nil`, the default code is used.

    Cobalt.CodeGen:InterceptGeneration(
        Type: "Call" | "Hook" | "InstancePath",
        Callback: (Info: any, ...any) -> string?
    ) -> () -> ()

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The type of code generation to intercept | `"Call" \| "Hook" \| "InstancePath"` |
| 2   | The interceptor callback | `function` |

**Returns** a cleanup function.

**Example — Custom call code**

    Cobalt.CodeGen:InterceptGeneration("Call", function(callInfo)
        if callInfo.Instance.Name == "MyRemote" then
            return "-- Custom call code\nprint('Hello!')"
        end
        return nil -- fall through to default
    end)

**Example — Custom instance path for virtual instances**

    Cobalt.CodeGen:InterceptGeneration("InstancePath", function(object, options)
        if object.Name:find("ByteNet::") then
            return "Net." .. object.Name:gsub("ByteNet::", "")
        end
        return nil
    end)

* * *

### [Serialize](https://docs.mspaint.cc/cobalt/plugins/api#serialize)

Serializes a value to Luau code.

    Cobalt.CodeGen.Serialize(data: any, options: table?) -> string

**Example**

    local code = Cobalt.CodeGen.Serialize({ key = "value", num = 42 }, { Prettify = true })

* * *

### [Indent](https://docs.mspaint.cc/cobalt/plugins/api#indent)

Indents a code string by a given number of levels (4 spaces per level).

    Cobalt.CodeGen.Indent(str: string, indent: number) -> string

**Example**

    local indented = Cobalt.CodeGen.Indent("print('hello')", 2)
    -- Returns: "        print('hello')"

* * *

[Cobalt.UI](https://docs.mspaint.cc/cobalt/plugins/api#cobaltui)

-----------------------------------------------------------------

Functions for creating UI elements, modals, and extending Cobalt's interface.

### [New](https://docs.mspaint.cc/cobalt/plugins/api#new)

Creates a new Roblox GUI instance with sensible defaults applied (e.g. transparent backgrounds on labels, default font, `BorderSizePixel = 0`). Supports nested instance creation by passing tables as property values — the table key becomes the child's `ClassName` and the table value becomes its properties.

    Cobalt.UI.New(ClassName: string, Properties: { [string | number]: any }) -> Instance

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The Roblox class name to create | `string` |
| 2   | Properties to apply. Table values create child instances, numeric keys clone Instance values as children. | `table` |

**Example**

    local Button = Cobalt.UI.New("TextButton", {
        Text = "Click Me",
        Size = UDim2.new(1, 0, 0, 32),
        BackgroundColor3 = Color3.fromRGB(25, 25, 25),
        Parent = someFrame,
     
        -- Nested children: key = ClassName, value = properties
        ["UICorner"] = {
            CornerRadius = UDim.new(0, 6),
        },
        ["UIStroke"] = {
            Color = Color3.fromRGB(50, 50, 50),
            Thickness = 1,
        },
        ["TextLabel"] = {
            Text = "Subtitle",
            TextSize = 12,
            Size = UDim2.fromScale(1, 0.5),
        },
    })

Default properties are applied per class (e.g. `TextLabel` gets white text, the default font, `RichText = true`, and transparent background). You can override any default by specifying it in the properties table.

* * *

### [NewIcon](https://docs.mspaint.cc/cobalt/plugins/api#newicon)

Creates an `ImageLabel` with a [Lucide](https://lucide.dev/)
 icon applied. Accepts the same properties table as `New`.

    Cobalt.UI.NewIcon(IconName: string, Properties: { [string]: any }) -> ImageLabel

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The Lucide icon name (e.g. `"search"`, `"settings"`, `"x"`) | `string` |
| 2   | Properties to apply to the ImageLabel | `table` |

**Example**

    local icon = Cobalt.UI.NewIcon("search", {
        Size = UDim2.fromOffset(16, 16),
        Position = UDim2.fromOffset(8, 8),
        Parent = someFrame,
    })

* * *

### [HideCorner](https://docs.mspaint.cc/cobalt/plugins/api#hidecorner)

Creates an opaque `Frame` that visually hides a rounded corner of a parent frame. Useful for making tab-style interfaces where some corners should appear square.

    Cobalt.UI.HideCorner(Frame: GuiObject, Size: UDim2, Offset: Vector2) -> Frame

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The parent frame whose corner to hide | `GuiObject` |
| 2   | The size of the hiding frame | `UDim2` |
| 3   | The anchor/position offset (e.g. `Vector2.new(0, 1)` for bottom-left) | `Vector2` |

* * *

### [CreatePluginSettings](https://docs.mspaint.cc/cobalt/plugins/api#createpluginsettings)

Creates a settings section for your plugin, visible when clicking the plugin in the Plugins list. Returns a `SectionBuilder` that you can use to add UI elements. All settings created through this section are **automatically persisted** to disk.

    Cobalt.UI:CreatePluginSettings() -> SectionBuilder

The returned `SectionBuilder` has the following methods:

#### [AddLabel](https://docs.mspaint.cc/cobalt/plugins/api#addlabel)

    SectionBuilder:AddLabel(Text: string, TextSize: number?) -> TextLabel

#### [CreateButton](https://docs.mspaint.cc/cobalt/plugins/api#createbutton)

    SectionBuilder:CreateButton(Text: string, Callback: () -> (), TextSize: number?) -> TextButton

#### [CreateCheckbox](https://docs.mspaint.cc/cobalt/plugins/api#createcheckbox)

    SectionBuilder:CreateCheckbox(Idx: string, Options: table) -> Checkbox

| Prop | Type | Default |
| --- | --- | --- |
| `Text` | `string` | \-  |
| `Default` | `boolean` | `false` |
| `Callback` | `(boolean) -> ()` | \-  |

#### [CreateTextBox](https://docs.mspaint.cc/cobalt/plugins/api#createtextbox)

    SectionBuilder:CreateTextBox(Idx: string, Options: table) -> TextSetting

| Prop | Type | Default |
| --- | --- | --- |
| `Text` | `string` | \-  |
| `Default` | `string` | `""` |
| `Placeholder` | `string` | \-  |
| `ClearTextOnFocus` | `boolean` | `false` |
| `Width` | `number` | `160` |
| `NumericOnly` | `boolean` | `false` |
| `Callback` | `(string) -> ()` | \-  |

#### [CreateDropdown](https://docs.mspaint.cc/cobalt/plugins/api#createdropdown)

    SectionBuilder:CreateDropdown(Idx: string, Options: table) -> Dropdown

| Prop | Type | Default |
| --- | --- | --- |
| `Text` | `string` | \-  |
| `Values` | `table` | \-  |
| `Default` | `any` | \-  |
| `Multi` | `boolean` | `false` |
| `AllowNull` | `boolean` | `false` |
| `Callback` | `(any) -> ()` | \-  |

#### [CreateRow](https://docs.mspaint.cc/cobalt/plugins/api#createrow)

Creates a horizontal sub-row for placing multiple elements side-by-side. Returns a new `SectionBuilder`.

    SectionBuilder:CreateRow(Padding: UDim?) -> SectionBuilder

**Full Example**

    local Settings = Cobalt.UI:CreatePluginSettings()
     
    local status = Settings:AddLabel("Status: Ready", 15)
     
    Settings:CreateCheckbox("SuppressRaw", {
        Text = "Suppress raw logs",
        Default = false,
    })
     
    Settings:CreateButton("Rescan", function()
        Cobalt.Sonner.success("Rescan complete!")
    end)
     
    Settings:CreateTextBox("ApiKey", {
        Text = "API Key",
        Placeholder = "Enter key...",
    })
     
    Settings:CreateDropdown("Mode", {
        Text = "Mode",
        Values = { "Simple", "Advanced" },
        Default = "Simple",
    })

* * *

### [CreateModal](https://docs.mspaint.cc/cobalt/plugins/api#createmodal)

Creates a resizable, blank modal dialog.

    Cobalt.UI:CreateModal(Title: string, Icon: string) -> ModalInterface

| Arg | Description | Type |
| --- | --- | --- |
| 1   | The title of the modal | `string` |
| 2   | A Lucide icon name | `string` |

The returned `ModalInterface` has the following properties/methods:

| Property/Method | Description |
| --- | --- |
| `Container` | The content `ScrollingFrame` |
| `Open()` | Opens the modal |
| `Close()` | Closes the modal |
| `OnClose` | Signal that fires when the modal is closed |
| `AddTab(name, icon)` | Adds a tab, returns tab content frame |
| `SelectTab(name)` | Switches to a specific tab |
| `AddFooterButton(icon, title, options)` | Adds a dropdown button to the footer |

**Example**

    local modal = Cobalt.UI:CreateModal("My Modal", "search")
     
    local tab1 = modal:AddTab("General", "settings")
    local tab2 = modal:AddTab("Advanced", "sliders-horizontal")
     
    modal:AddFooterButton("export", "Export", {
        { Text = "As JSON", Callback = function() end },
        { Text = "As Lua", Callback = function() end },
    })
     
    modal:Open()

* * *

### [GetSelectedRemote](https://docs.mspaint.cc/cobalt/plugins/api#getselectedremote)

Gets the currently selected remote instance in the UI.

    Cobalt.UI:GetSelectedRemote() -> (Instance?, string?)

**Returns** the selected remote instance and its type, or `nil` if nothing is selected.

* * *

### [ColorizeLuauCode](https://docs.mspaint.cc/cobalt/plugins/api#colorizeluaucode)

Colorizes Luau code using Cobalt's built-in syntax highlighter. Returns a RichText-compatible string.

    Cobalt.UI.ColorizeLuauCode(code: string) -> string

* * *

[Cobalt.UI.RemoteInfo](https://docs.mspaint.cc/cobalt/plugins/api#cobaltuiremoteinfo)

--------------------------------------------------------------------------------------

Functions for extending the remote info panel that opens when you click a remote.

### [CreateTab](https://docs.mspaint.cc/cobalt/plugins/api#createtab)

Adds a custom tab to the remote info modal.

    Cobalt.UI.RemoteInfo:CreateTab(TabName: string, Icon: string) -> (Frame, Frame)

**Returns** `(TabContent, TabUI)` — the content frame you can parent elements to, and the tab UI frame.

* * *

### [BindToModalOpen](https://docs.mspaint.cc/cobalt/plugins/api#bindtomodalopen)

Binds a callback that fires whenever the remote info modal is opened.

    Cobalt.UI.RemoteInfo:BindToModalOpen(
        Callback: (CallInfo) -> ()
    ) -> () -> ()

**Returns** a cleanup function.

* * *

### [InterceptModalOpen](https://docs.mspaint.cc/cobalt/plugins/api#interceptmodalopen)

Adds an interceptor that can block the remote info modal from opening. Return `false` to block.

    Cobalt.UI.RemoteInfo:InterceptModalOpen(
        Callback: (CallInfo) -> boolean?
    ) -> () -> ()

**Returns** a cleanup function.

* * *

### [AddFooterButton](https://docs.mspaint.cc/cobalt/plugins/api#addfooterbutton)

Adds a custom footer button to a specific Remote Info tab.

    Cobalt.UI.RemoteInfo:AddFooterButton(
        TabName: string,
        Icon: string,
        Title: string,
        Options: table
    ) -> () -> ()

**Returns** a cleanup function that removes the button.

* * *

### [DisableDefaultButtons](https://docs.mspaint.cc/cobalt/plugins/api#disabledefaultbuttons)

Disables the default footer buttons for a specific Remote Info tab.

    Cobalt.UI.RemoteInfo:DisableDefaultButtons(TabName: string)

* * *

[Cobalt.UI.ContextMenu](https://docs.mspaint.cc/cobalt/plugins/api#cobaltuicontextmenu)

----------------------------------------------------------------------------------------

Functions for adding custom right-click context menu options.

### [AddOption](https://docs.mspaint.cc/cobalt/plugins/api#addoption)

Adds a custom option to a context menu.

    Cobalt.UI.ContextMenu:AddOption(
        MenuType: "RemoteList" | "CallList",
        Icon: string,
        Title: string,
        Callback: (InteractionData) -> ()
    ) -> () -> ()

| Arg | Description | Type |
| --- | --- | --- |
| 1   | Which context menu to add to | `"RemoteList" \| "CallList"` |
| 2   | A Lucide icon name | `string` |
| 3   | The option text | `string` |
| 4   | Callback receiving the relevant log or call data | `function` |

**Returns** a cleanup function.

**Example**

    Cobalt.UI.ContextMenu:AddOption("RemoteList", "trash", "Clear Logs", function(log)
        Cobalt.Spy:ClearLogs(log.Instance)
    end)
     
    Cobalt.UI.ContextMenu:AddOption("CallList", "copy", "Copy Raw Args", function(callInfo)
        -- callInfo contains the call data
    end)

[Previous\
\
Overview](https://docs.mspaint.cc/cobalt/plugins/overview)

### On this page

[Cobalt](https://docs.mspaint.cc/cobalt/plugins/api#cobalt)
[PluginData](https://docs.mspaint.cc/cobalt/plugins/api#plugindata)
[Settings](https://docs.mspaint.cc/cobalt/plugins/api#settings)
[Sonner](https://docs.mspaint.cc/cobalt/plugins/api#sonner)
[ExecutorSupport](https://docs.mspaint.cc/cobalt/plugins/api#executorsupport)
[BindToUnload](https://docs.mspaint.cc/cobalt/plugins/api#bindtounload)
[GetLog](https://docs.mspaint.cc/cobalt/plugins/api#getlog)
[Cobalt.Spy](https://docs.mspaint.cc/cobalt/plugins/api#cobaltspy)
[InterceptExecutedCalls](https://docs.mspaint.cc/cobalt/plugins/api#interceptexecutedcalls)
[AppendLog](https://docs.mspaint.cc/cobalt/plugins/api#appendlog)
[ClearLogs](https://docs.mspaint.cc/cobalt/plugins/api#clearlogs)
[Cobalt.CodeGen](https://docs.mspaint.cc/cobalt/plugins/api#cobaltcodegen)
[InterceptGeneration](https://docs.mspaint.cc/cobalt/plugins/api#interceptgeneration)
[Serialize](https://docs.mspaint.cc/cobalt/plugins/api#serialize)
[Indent](https://docs.mspaint.cc/cobalt/plugins/api#indent)
[Cobalt.UI](https://docs.mspaint.cc/cobalt/plugins/api#cobaltui)
[New](https://docs.mspaint.cc/cobalt/plugins/api#new)
[NewIcon](https://docs.mspaint.cc/cobalt/plugins/api#newicon)
[HideCorner](https://docs.mspaint.cc/cobalt/plugins/api#hidecorner)
[CreatePluginSettings](https://docs.mspaint.cc/cobalt/plugins/api#createpluginsettings)
[AddLabel](https://docs.mspaint.cc/cobalt/plugins/api#addlabel)
[CreateButton](https://docs.mspaint.cc/cobalt/plugins/api#createbutton)
[CreateCheckbox](https://docs.mspaint.cc/cobalt/plugins/api#createcheckbox)
[CreateTextBox](https://docs.mspaint.cc/cobalt/plugins/api#createtextbox)
[CreateDropdown](https://docs.mspaint.cc/cobalt/plugins/api#createdropdown)
[CreateRow](https://docs.mspaint.cc/cobalt/plugins/api#createrow)
[CreateModal](https://docs.mspaint.cc/cobalt/plugins/api#createmodal)
[GetSelectedRemote](https://docs.mspaint.cc/cobalt/plugins/api#getselectedremote)
[ColorizeLuauCode](https://docs.mspaint.cc/cobalt/plugins/api#colorizeluaucode)
[Cobalt.UI.RemoteInfo](https://docs.mspaint.cc/cobalt/plugins/api#cobaltuiremoteinfo)
[CreateTab](https://docs.mspaint.cc/cobalt/plugins/api#createtab)
[BindToModalOpen](https://docs.mspaint.cc/cobalt/plugins/api#bindtomodalopen)
[InterceptModalOpen](https://docs.mspaint.cc/cobalt/plugins/api#interceptmodalopen)
[AddFooterButton](https://docs.mspaint.cc/cobalt/plugins/api#addfooterbutton)
[DisableDefaultButtons](https://docs.mspaint.cc/cobalt/plugins/api#disabledefaultbuttons)
[Cobalt.UI.ContextMenu](https://docs.mspaint.cc/cobalt/plugins/api#cobaltuicontextmenu)
[AddOption](https://docs.mspaint.cc/cobalt/plugins/api#addoption)

---