```html Vaultra UI Documentation

VAULTRA UI v4.4.1

Build your interface.

Vaultra UI is a responsive Roblox interface library designed for desktop and mobile. Build tabs, sections, toggles, sliders, dropdowns, textboxes, keybinds, notifications, persistent settings, custom backgrounds and optional key systems from one library.

Get started Full example

OVERVIEW

What is Vaultra UI?

Vaultra UI gives Roblox scripts a complete interface without requiring you to manually build every ScreenGui, frame, control, animation and mobile layout.

The library automatically creates the main window, navigation, search system, Home tab, Settings tab, window controls, notifications and responsive scaling system.

Responsive

The complete interface automatically scales to fit the current viewport while keeping its proportions.

PC + Mobile

Mouse, keyboard and touch input are handled by the library with larger mobile-friendly controls where needed.

Persistent

Save developer flags, built-in appearance settings and key system data when file APIs are available.

Searchable

The built-in search bar can search tab names, control names and control descriptions.

Customizable

Change backgrounds, transparency, sizing, theme colors, icons, window information and other appearance options.

Key system

Protect scripts using an API, custom Lua validator, a list of static keys or a single static key.

START HERE

Installation

Load Vaultra UI once near the top of your script.

Lua 
local Vaultra = loadstring(game:HttpGet("https://vaultra.pages.dev/ui.lua"))()

The returned Vaultra table is then used to create your window.

WINDOW

Create a window

Call Vaultra:CreateWindow() to create the interface.

Unless disabled, the Home tab is automatically added. The Settings tab is also automatically created.

Lua 
local Window = Vaultra:CreateWindow({
    Title = "Vaultra Hub",
    Subtitle = "My Script",

    Background = "1020120447",
    BackgroundType = "auto",
    BackgroundTransparency = 0.08,
    TintTransparency = 0.66,

    ToggleKey = Enum.KeyCode.RightShift,
    ServerStatus = "Online",

    HomeDescription = "Welcome to my script.",

    HomeStatuses = {
        Version = "1.0.0",
        Module = "Universal",
        Status = "Ready"
    }
})

Window options

You do not need to provide every option. Vaultra UI includes defaults for the normal window configuration.

Title

Main name displayed in the top bar and Home page. 

Title = "Vaultra Hub"

Subtitle

Smaller text displayed underneath the window title. 

Subtitle = "Universal"

Name

Optional internal ScreenGui name and identifier used by some save paths. 

Name = "VaultraHub"

Username

Overrides the automatically displayed Roblox display name. 

Username = "Custom Name"

Width

Changes the design width before responsive scaling is applied. 

Width = 900

ToggleKey

Keyboard key used to show or hide the complete interface. 

ToggleKey = Enum.KeyCode.RightShift

DisplayOrder

Changes the Roblox ScreenGui display order. 

DisplayOrder = 999

Parent

Allows you to manually choose the ScreenGui parent. 

Parent = game.Players.LocalPlayer.PlayerGui

Home

Set to false if you do not want the automatic Home tab. 

Home = false

ServerStatus

Initial server status shown inside the automatic Home page. 

ServerStatus = "Online"

HomeDescription

Main information paragraph shown inside the Home tab. 

HomeDescription = "Welcome to Vaultra."

HomeStatuses

Adds custom entries to the Home status section. 

HomeStatuses = {
    Version = "1.0.0",
    Module = "MM2"
}

CUSTOMIZATION

Custom themes

A custom Theme table can override the default Vaultra colors.

Lua 
local Window = Vaultra:CreateWindow({
    Title = "Custom Theme",

    Theme = {
        Backdrop = Color3.fromRGB(7, 9, 18),
        Glass = Color3.fromRGB(22, 26, 43),
        GlassBright = Color3.fromRGB(41, 47, 72),

        Control = Color3.fromRGB(30, 35, 55),
        ControlHover = Color3.fromRGB(44, 51, 78),

        Text = Color3.fromRGB(246, 248, 255),
        Muted = Color3.fromRGB(167, 176, 202),

        Accent = Color3.fromRGB(124, 92, 255),
        Accent2 = Color3.fromRGB(174, 151, 255),

        Success = Color3.fromRGB(50, 221, 145),
        Danger = Color3.fromRGB(255, 91, 115),

        Stroke = Color3.fromRGB(255, 255, 255)
    }
})

You only need to include colors you want to replace. Missing theme values continue using Vaultra's defaults.

Window backgrounds

Vaultra UI can display Roblox image assets, thumbnails, decal/asset references and supported web images.

Example 
local Window = Vaultra:CreateWindow({
    Title = "Background Example",

    Background = "1020120447",
    BackgroundType = "auto",

    BackgroundTransparency = 0.08,
    TintTransparency = 0.66,

    BackgroundScaleType = Enum.ScaleType.Crop
})

Image asset

Background = "1020120447"

rbxassetid

Background = "rbxassetid://1020120447"

Decal

Background = "decal://1020120447"

Asset

Background = "asset://1020120447"

Thumbnail

Background = "rbxthumb://type=Asset&id=1020120447&w=768&h=432"

Web URL

Background = "https://example.com/image.png"

Direct https:// images require an environment that supports request functionality, writefile and getcustomasset or an equivalent custom asset function.

LAYOUT

Tabs

Tabs appear inside the navigation panel on the left side of the interface.

Lua 
local Main = Window:CreateTab({
    Name = "Main",
    Icon = "◆"
})

local Player = Window:CreateTab({
    Name = "Player",
    Icon = "★"
})

local Misc = Window:CreateTab({
    Name = "Misc",
    Icon = "⚙"
})

Roblox image icon

Lua 
local Main = Window:CreateTab({
    Name = "Main",
    Icon = "73063376060866",
    IconType = "image"
})

Tab names and registered controls can automatically be discovered by the window search bar.

Sections

Controls are placed inside sections. A tab can contain as many sections as you need.

Lua 
local Main = Window:CreateTab({
    Name = "Main",
    Icon = "◆"
})

local General = Main:AddSection("General")
local Automation = Main:AddSection("Automation")
local Other = Main:AddSection("Other")

You can also pass the section name inside a table. 

local General = Main:AddSection({
    Name = "General"
})

CONTROLS

Available controls

Vaultra UI v4.4.1 includes interactive controls and information elements that can be mixed inside any section.

Button

Runs an action when pressed.

Toggle

Stores an enabled or disabled state.

Slider

Selects a number between a minimum and maximum.

Dropdown

Selects an item from a list of options.

Textbox

Allows the user to enter text.

Keybind

Lets the user assign and activate a keyboard key.

Label

Displays simple information text.

Paragraph

Displays a title with a larger information block.

Divider

Separates groups of controls inside a section.

Button

Buttons execute their callback every time they are pressed.

Lua 
local RunButton = General:AddButton({
    Name = "Run Action",
    Description = "Runs the example action.",

    ButtonText = "Run",

    Callback = function()
        print("Button clicked")
    end
})

Change button text

RunButton:SetText("Completed")

Toggle

Toggles are useful for features that can remain enabled or disabled.

Lua 
local AutoFarmToggle = General:AddToggle({
    Name = "Auto Farm",
    Description = "Automatically farms while enabled.",

    Default = false,
    Flag = "AutoFarm",

    Callback = function(value)
        print("Auto Farm:", value)
    end
})

Set the toggle

AutoFarmToggle:Set(true)

Read the toggle

local Enabled = AutoFarmToggle:Get()
print(Enabled)

Slider

Sliders select a number between Min and Max. Use Step to control how values are rounded.

Lua 
local SpeedSlider = General:AddSlider({
    Name = "Speed",
    Description = "Controls movement speed.",

    Min = 1,
    Max = 100,
    Step = 1,

    Default = 20,
    Suffix = " studs",

    Flag = "Speed",

    Callback = function(value)
        print("Speed:", value)
    end
})

Set a value

SpeedSlider:Set(50)

Read the current value

local Speed = SpeedSlider:Get()

Textbox

Textboxes collect user-entered text. The callback runs when the textbox loses focus.

Lua 
local MessageBox = General:AddTextbox({
    Name = "Message",
    Description = "Enter a message below.",

    Placeholder = "Type here...",
    Default = "",

    Flag = "Message",

    Callback = function(value, enterPressed)
        print("Message:", value)
        print("Enter pressed:", enterPressed)
    end
})

Set text

MessageBox:Set("Hello")

Get text

local Message = MessageBox:Get()

Keybind

A keybind can run a callback when its assigned keyboard key is pressed. Users can also change the key directly from the UI.

Lua 
local ActionKey = General:AddKeybind({
    Name = "Action Key",
    Description = "Press this key to run the action.",

    Default = Enum.KeyCode.F,
    Flag = "ActionKey",

    Changed = function(newKey)
        print("New key:", newKey.Name)
    end,

    Callback = function(key)
        print("Pressed:", key.Name)
    end
})

Change the key

ActionKey:Set(Enum.KeyCode.G)

Get the key

local Key = ActionKey:Get()

Labels, paragraphs and dividers

Label

Labels display a simple piece of text and can be updated later.

Lua 
local StatusLabel = General:AddLabel("Status: Ready")

StatusLabel:Set("Status: Running")

Paragraph

Paragraphs are useful for descriptions, instructions and larger information areas.

Lua 
General:AddParagraph({
    Title = "Information",
    Content = "This is a longer description shown inside the interface."
})

Divider

Lua 
General:AddDivider()

General:AddDivider("Advanced")

Control return methods

Many controls return an object that lets you modify or read the control after it has been created.

Button

Button:SetText("New text")

Toggle

Toggle:Set(true)
Toggle:Get()

Slider

Slider:Set(50)
Slider:Get()

Dropdown

Dropdown:Set("Option")
Dropdown:Get()
Dropdown:Refresh({...})
Dropdown:Close()

Textbox

Textbox:Set("Hello")
Textbox:Get()

Keybind

Keybind:Set(Enum.KeyCode.F)
Keybind:Get()

Label

Label:Set("New text")

FEEDBACK

Notifications

Use the window notification system for messages, actions, errors, warnings or confirmations.

Lua 
Window:Notify({
    Title = "Vaultra",
    Content = "Your action completed.",
    Duration = 4
})

Custom notification color

Lua 
Window:Notify({
    Title = "Success",
    Content = "Everything is ready.",
    Duration = 4,

    Color = Color3.fromRGB(50, 221, 145)
})

Automatic Home tab

By default, Vaultra UI creates a Home tab containing a welcome section and a live status section.

The status area automatically includes the server status, current input type and network ping. You can add your own entries with HomeStatuses.

Lua 
local Window = Vaultra:CreateWindow({
    Title = "Vaultra Hub",

    HomeDescription = "Universal utilities powered by Vaultra UI.",

    ServerStatus = "Online",

    HomeStatuses = {
        Version = "1.7.2",
        Module = "Universal",
        UI = tostring(Vaultra.Version)
    }
})

Custom Home icon

HomeIcon = "⌂"

Custom status section name

StatusSectionName = "Information"

Disable Home

Home = false

Update a Home status

Lua 
Window:SetHomeStatus("Status", "Running")

local CurrentStatus = Window:GetHomeStatus("Status")

print(CurrentStatus)

Create a new status

local CoinsStatus = Window:AddHomeStatus("Coins", 0)

CoinsStatus:Set(40)

Built-in Settings tab

Vaultra UI automatically creates a permanent Settings tab. Your scripts can add more sections to it using Window.SettingsTab.

The built-in Settings page contains background and window controls including:

Background source

Change the image, asset, decal or URL used by the window.

Source type

Switch between normal image and asset/thumbnail handling.

Image transparency

Controls how visible the background image is.

Glass tint

Controls the dark glass overlay.

Background fit

Supports Crop, Fit and Stretch.

Show / hide key

Lets the user change the UI toggle key.

Fit to device

Recalculates responsive scaling for the current viewport.

Center window

Moves the interface back to the middle of the screen.

Add your own Settings section

Lua 
local ExtraSettings = Window.SettingsTab:AddSection("Script settings")

ExtraSettings:AddToggle({
    Name = "Notifications",
    Default = true,

    Callback = function(value)
        print("Notifications:", value)
    end
})

PERSISTENCE

Saving control values

Vaultra UI has two separate persistence systems.

Developer flags

Values assigned to Flag can be saved when SaveSettings = true.

Built-in settings

Vaultra appearance settings use their own save file when the required file APIs are available.

Enable flag saving

Lua 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    SaveSettings = true,

    SaveFolder = "VaultraHub",
    SaveName = "Settings"
})

Give controls flags

Lua 
General:AddToggle({
    Name = "Auto Farm",
    Default = false,

    Flag = "AutoFarm",

    Callback = function(value)
        print(value)
    end
})

General:AddSlider({
    Name = "Speed",
    Min = 1,
    Max = 100,
    Default = 20,

    Flag = "Speed",

    Callback = function(value)
        print(value)
    end
})

On the next execution, controls using the same flags can restore their previously saved values.

Default developer save location

VaultraUI/Saves

Built-in appearance save folder

BuiltInSaveFolder = "VaultraUI/BuiltInSettings"

Force-save current flags

Window:SaveSettings()

Delete saved flag settings

Window:ClearSavedSettings()

Force-save built-in appearance settings

Window:SaveBuiltInSettings()

Reset built-in saved settings

Window:ResetBuiltInSettings()

Saving requires file functions such as writefile and readfile. Folder creation and deletion also depend on the corresponding file APIs being available.

API

Window methods

You can change several parts of an existing window without creating it again.

Toggle

Window:Toggle()

Shows or hides the entire interface.

Destroy

Window:Destroy()

Saves available settings and destroys the ScreenGui.

Center

Window:Center()

Moves the window back to the screen center.

Refit

Window:Refit()

Recalculates scaling for the current viewport.

Scale

Window:SetScale(0.8)

Changes the UIScale while respecting screen limits.

Transparency

Window:SetTransparency(0.5)

Changes the overall window/glass transparency.

Toggle key

Window:SetToggleKey(
    Enum.KeyCode.RightShift
)

Get flags

local Flags = Window:GetFlags()

Returns the current developer flag table.

Change background at runtime

Lua 
Window:SetBackground("1020120447", "auto")

Window:SetBackgroundTransparency(0.08)

Window:SetTintTransparency(0.66)

Window:SetBackgroundScaleType(
    Enum.ScaleType.Crop
)

KEY SYSTEM

Optional key system

Set Key = true to prevent the main interface from opening until the user enters a valid key.

The key interface automatically adapts to smaller mobile displays and supports saving accepted keys where file APIs are available.

Vaultra API example 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    Key = true,

    KeyTitle = "Vaultra Key System",
    KeyDescription = "Enter your key below to continue.",
    KeyPlaceholder = "Enter key...",

    KeyLink = "https://vaultra.pages.dev/getkey",

    KeyAPI = "https://vaultra.pages.dev/api/check?key={key}&user={userId}",

    SaveKey = true,

    KeySaveFolder = "VaultraUI",
    KeySaveName = "MyHubKey"
})

The {key} placeholder is replaced with the entered key and {userId} is replaced with the current Roblox user ID.

If the API URL does not contain a {key} placeholder, Vaultra automatically appends the key and user ID as query parameters.

Key interface options

Key

Key = true

Enables the key gate.

KeyTitle

KeyTitle = "Key System"

KeyDescription

KeyDescription =
    "Enter a valid key."

KeyPlaceholder

KeyPlaceholder = "Enter key..."

KeyLink

KeyLink =
    "https://vaultra.pages.dev/getkey"

SaveKey

SaveKey = true

Controls whether accepted keys can be remembered.

KeySaveFolder

KeySaveFolder = "VaultraUI"

KeySaveName

KeySaveName = "MyHubKey"

Saved keys are validated again when they are loaded. This means an expired API-generated key cannot simply bypass validation because it exists in the saved file.

Key validation methods

Vaultra checks validation methods in priority order. The first configured method is used.

1. Custom validator

KeyCheck has the highest priority and gives your script full control over key validation.

Lua 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    Key = true,

    KeyCheck = function(key)
        if key == "VAULTRA-123" then
            return true, "Key accepted."
        end

        return false, "Invalid key."
    end
})

2. API validation

Lua 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    Key = true,

    KeyAPI = "https://example.com/api/check?key={key}&user={userId}"
})

API responses can be accepted when they indicate success using supported values such as a successful boolean or a JSON response containing a valid success field.

3. Static key list

Lua 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    Key = true,

    Keys = {
        "VAULTRA-ONE",
        "VAULTRA-TWO",
        "VAULTRA-THREE"
    }
})

4. Single static key

Lua 
local Window = Vaultra:CreateWindow({
    Title = "My Hub",

    Key = true,

    KeyValue = "VAULTRA-ACCESS"
})

Validation priority

1. KeyCheck
2. KeyAPI
3. Keys
4. KeyValue
Open Vaultra key generator

ASSETS

Supported image formats

The same image resolver is used by several Vaultra UI elements, including window backgrounds and image-based icons.

Raw Roblox ID

"123456789"

Treated as a normal image asset unless another type is requested.

Image asset

"rbxassetid://123456789"

Roblox asset

"rbxasset://..."

Decal

"decal://123456789"

Automatically resolved through an asset thumbnail.

Asset

"asset://123456789"

Thumbnail

"thumbnail://123456789"

rbxthumb

"rbxthumb://type=Asset&id=123456789&w=768&h=432"

Direct URL

"https://example.com/image.png"

When a normal ID does not display

Some Roblox IDs refer to decals or other asset types rather than a directly renderable image. Try the asset form: 

Background = "asset://123456789"

or:

Background = "decal://123456789"

RESPONSIVE DESIGN

Mobile support

Vaultra UI is designed to work with both keyboard/mouse and touch input.

Responsive scaling

The full interface uses uniform scaling to preserve its layout and proportions on smaller displays.

Larger touch controls

Several interactive surfaces use larger dimensions when touch input is detected.

Readable mobile text

Normal UI text receives a mobile readability adjustment on touch devices.

Touch dragging

Window movement includes touch thresholds to reduce accidental movement while controlling the Roblox camera.

Touch sliders

Sliders use an enlarged invisible interaction area so they are easier to control on phones.

Responsive key UI

The key-system card automatically scales down on very small phone displays.

Automatic refitting

Vaultra recalculates its size when the viewport changes. You can also force this manually: 

Window:Refit()

FULL SCRIPT

Complete example

This example demonstrates a normal Vaultra UI window with saving, tabs, sections and every major control type.

Lua 
local Vaultra = loadstring(
    game:HttpGet("https://vaultra.pages.dev/ui.lua")
)()

local Window = Vaultra:CreateWindow({
    Title = "Vaultra Hub",
    Subtitle = "Example Script",

    Background = "1020120447",
    BackgroundType = "auto",
    BackgroundTransparency = 0.08,
    TintTransparency = 0.66,

    ToggleKey = Enum.KeyCode.RightShift,
    ServerStatus = "Online",

    HomeDescription = "Example interface made with Vaultra UI.",

    HomeStatuses = {
        Version = "1.0.0",
        Module = "Example",
        UI = tostring(Vaultra.Version)
    },

    SaveSettings = true,
    SaveFolder = "VaultraExample",
    SaveName = "Settings"
})


-- Main tab

local Main = Window:CreateTab({
    Name = "Main",
    Icon = "◆"
})


-- General section

local General = Main:AddSection("General")


-- Paragraph

General:AddParagraph({
    Title = "Welcome",
    Content = "This page demonstrates the main Vaultra UI controls."
})


-- Divider

General:AddDivider("Controls")


-- Toggle

local EnabledToggle = General:AddToggle({
    Name = "Enabled",
    Description = "Turns the example feature on or off.",

    Default = false,
    Flag = "Enabled",

    Callback = function(value)
        print("Enabled:", value)
    end
})


-- Slider

local SpeedSlider = General:AddSlider({
    Name = "Speed",
    Description = "Changes the example speed.",

    Min = 1,
    Max = 100,
    Step = 1,

    Default = 20,
    Suffix = "",

    Flag = "Speed",

    Callback = function(value)
        print("Speed:", value)
    end
})


-- Dropdown

local ModeDropdown = General:AddDropdown({
    Name = "Mode",
    Description = "Select an example mode.",

    Options = {
        "Normal",
        "Fast",
        "Safe"
    },

    Default = "Normal",
    AllowNone = false,

    Flag = "Mode",

    Callback = function(value)
        print("Mode:", value)
    end
})


-- Textbox

local MessageBox = General:AddTextbox({
    Name = "Message",
    Description = "Enter a custom message.",

    Placeholder = "Type here...",
    Default = "",

    Flag = "Message",

    Callback = function(value, enterPressed)
        print("Message:", value)
    end
})


-- Keybind

local ActionKey = General:AddKeybind({
    Name = "Action Key",
    Description = "Press the selected key to run an action.",

    Default = Enum.KeyCode.F,
    Flag = "ActionKey",

    Changed = function(key)
        print("Key changed to:", key.Name)
    end,

    Callback = function(key)
        Window:Notify({
            Title = "Keybind",
            Content = key.Name .. " was pressed.",
            Duration = 3
        })
    end
})


-- Label

local StatusLabel = General:AddLabel("Status: Ready")


-- Button

local NotifyButton = General:AddButton({
    Name = "Test Notification",
    Description = "Displays a Vaultra notification.",

    ButtonText = "Notify",

    Callback = function()

        StatusLabel:Set("Status: Button pressed")

        Window:Notify({
            Title = "Vaultra",
            Content = "The test button was pressed.",
            Duration = 4
        })

    end
})


-- Extra tab

local Player = Window:CreateTab({
    Name = "Player",
    Icon = "★"
})

local PlayerSection = Player:AddSection("Player")

PlayerSection:AddParagraph({
    Title = "Player",
    Content = "Put player-related features here."
})


-- Add custom settings

local ScriptSettings =
    Window.SettingsTab:AddSection("Script settings")

ScriptSettings:AddToggle({
    Name = "Show Notifications",
    Default = true,
    Flag = "ShowNotifications",

    Callback = function(value)
        print("Notifications:", value)
    end
})


-- Example Home status update

Window:SetHomeStatus("Status", "Ready")

Full key-system example

Lua 
local Vaultra = loadstring(
    game:HttpGet("https://vaultra.pages.dev/ui.lua")
)()

local Window = Vaultra:CreateWindow({
    Title = "Vaultra Hub",
    Subtitle = "Protected Script",

    Background = "1020120447",
    BackgroundType = "auto",
    BackgroundTransparency = 0.08,
    TintTransparency = 0.66,

    ToggleKey = Enum.KeyCode.RightShift,

    Key = true,

    KeyTitle = "Vaultra Key System",
    KeyDescription = "Enter your Vaultra key to continue.",
    KeyPlaceholder = "Enter key...",

    KeyLink = "https://vaultra.pages.dev/getkey",

    KeyAPI = "https://vaultra.pages.dev/api/check?key={key}&user={userId}",

    SaveKey = true,
    KeySaveFolder = "VaultraUI",
    KeySaveName = "ExampleKey",

    HomeDescription = "Protected Vaultra UI example.",

    HomeStatuses = {
        Version = "1.0.0",
        UI = tostring(Vaultra.Version)
    }
})

local Main = Window:CreateTab({
    Name = "Main",
    Icon = "◆"
})

local General = Main:AddSection("General")

General:AddButton({
    Name = "Test",
    ButtonText = "Run",

    Callback = function()

        Window:Notify({
            Title = "Vaultra",
            Content = "The script is unlocked and working.",
            Duration = 4
        })

    end
})

GOOD PRACTICE

Tips

Use unique flags

Give each saved control a unique flag so two controls do not overwrite the same saved value.

Keep callbacks small

For large systems, call separate functions from UI callbacks instead of putting all feature code inside the control.

Store control objects

Save returned controls into variables when you need to change their values or text later.

Use descriptions

Descriptions make complicated controls easier to understand and are also included in Vaultra's built-in search.

Use sections

Split large tabs into logical sections instead of putting every control into one large group.

Use Refit

If an executor reports an incorrect viewport after loading, Window:Refit() can recalculate the layout.

REFERENCE

Quick reference

Vaultra UI API 
-- Load
local Vaultra = loadstring(game:HttpGet("https://vaultra.pages.dev/ui.lua"))()

-- Window
local Window = Vaultra:CreateWindow({...})

-- Tabs
local Tab = Window:CreateTab({...})

-- Sections
local Section = Tab:AddSection("Name")

-- Controls
Section:AddButton({...})
Section:AddToggle({...})
Section:AddSlider({...})
Section:AddDropdown({...})
Section:AddTextbox({...})
Section:AddKeybind({...})
Section:AddLabel("Text")
Section:AddParagraph({...})
Section:AddDivider("Text")

-- Window
Window:Notify({...})
Window:Toggle()
Window:Center()
Window:Refit()
Window:Destroy()

Window:SetBackground(source, kind)
Window:SetBackgroundTransparency(value)
Window:SetTintTransparency(value)
Window:SetBackgroundScaleType(Enum.ScaleType.Crop)
Window:SetToggleKey(Enum.KeyCode.RightShift)
Window:SetTransparency(value)
Window:SetScale(value)

-- Flags
Window:GetFlags()
Window:SaveSettings()
Window:ClearSavedSettings()

-- Built-in settings
Window:SaveBuiltInSettings()
Window:ResetBuiltInSettings()

-- Home information
Window:AddHomeStatus(name, value)
Window:SetHomeStatus(name, value)
Window:GetHomeStatus(name)

-- Built-in Settings tab
Window.SettingsTab:AddSection("Custom Settings")
```