Sirius

https://docs.sirius.menu/
Admin
Official documentation for libraries and products developed by Sirius. It provides comprehensive...
Tokens:7,246
Snippets:39
Trust Score:5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rayfield Custom Theme Configuration Example (Lua)

Source: https://docs.sirius.menu/rayfield/configuration/themes

An example Lua table demonstrating how to define a custom theme in Rayfield. This table specifies `Color3.fromRGB` values for various UI components, allowing for granular control over the theme's appearance, including text, background, topbar, notifications, tabs, elements, sliders, toggles, dropdowns, and inputs.

```Lua
{
    TextColor = Color3.fromRGB(240, 240, 240),

    Background = Color3.fromRGB(25, 25, 25),
    Topbar = Color3.fromRGB(34, 34, 34),
    Shadow = Color3.fromRGB(20, 20, 20),

    NotificationBackground = Color3.fromRGB(20, 20, 20),
    NotificationActionsBackground = Color3.fromRGB(230, 230, 230),

    TabBackground = Color3.fromRGB(80, 80, 80),
    TabStroke = Color3.fromRGB(85, 85, 85),
    TabBackgroundSelected = Color3.fromRGB(210, 210, 210),
    TabTextColor = Color3.fromRGB(240, 240, 240),
    SelectedTabTextColor = Color3.fromRGB(50, 50, 50),

    ElementBackground = Color3.fromRGB(35, 35, 35),
    ElementBackgroundHover = Color3.fromRGB(40, 40, 40),
    SecondaryElementBackground = Color3.fromRGB(25, 25, 25),
    ElementStroke = Color3.fromRGB(50, 50, 50),
    SecondaryElementStroke = Color3.fromRGB(40, 40, 40),

    SliderBackground = Color3.fromRGB(50, 138, 220),
    SliderProgress = Color3.fromRGB(50, 138, 220),
    SliderStroke = Color3.fromRGB(58, 163, 255),

    ToggleBackground = Color3.fromRGB(30, 30, 30),
    ToggleEnabled = Color3.fromRGB(0, 146, 214),
    ToggleDisabled = Color3.fromRGB(100, 100, 100),
    ToggleEnabledStroke = Color3.fromRGB(0, 170, 255),
    ToggleDisabledStroke = Color3.fromRGB(125, 125, 125),
    ToggleEnabledOuterStroke = Color3.fromRGB(100, 100, 100),
    ToggleDisabledOuterStroke = Color3.fromRGB(65, 65, 65),

    DropdownSelected = Color3.fromRGB(40, 40, 40),
    DropdownUnselected = Color3.fromRGB(30, 30, 30),

    InputBackground = Color3.fromRGB(30, 30, 30),
    InputStroke = Color3.fromRGB(65, 65, 65),
    PlaceholderColor = Color3.fromRGB(178, 178, 178)
}
```

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

### Create Tab with Image Icon

Source: https://docs.sirius.menu/rayfield/configuration/windows

Shows how to create a new tab within an existing Rayfield window using `Window:CreateTab()`. This example uses a numeric image ID for the tab icon.

```Lua
local Tab = Window:CreateTab("Tab Example", 4483362458)
```

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

### Get Rayfield Interface Visibility Status

Source: https://docs.sirius.menu/rayfield/configuration/windows

Demonstrates how to retrieve the current visibility status of the Rayfield interface using `Rayfield:IsVisible()`. This method returns a boolean indicating if the interface is currently visible.

```Lua
Rayfield:IsVisible()
```

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

### Loading the Rayfield Library in Lua

Source: https://docs.sirius.menu/rayfield/configuration/booting-library

This Lua code snippet demonstrates the process of loading the Rayfield library. It uses `game:HttpGet` to fetch the library's script from a remote URL and `loadstring` to execute it, making the `Rayfield` object available for use. This is the fundamental step to initialize the library.

```Lua
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()
```

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

### Initialize and Configure Sense ESP Library in Lua

Source: https://docs.sirius.menu/sense/getting-started/booting-library

This snippet demonstrates the complete lifecycle of using the Sense ESP library in Lua. It covers loading the library from a URL, configuring specific team settings such as enabling enemy ESP and setting box colors, and then activating or deactivating the ESP functionality.

```Lua
-- 1. Load the library
local Sense = loadstring(game:HttpGet('https://sirius.menu/sense'))()

-- 2. Change the configuration.
Sense.teamSettings.enemy.enabled = true
Sense.teamSettings.enemy.box = true
Sense.teamSettings.enemy.boxColor[1] = Color3.new(0, 0.25, 0.75)

-- 3. Load the esp. It doesn't really matter where you put this, but it's recommended you put it at the end of your script.
Sense.Load()

-- 4. Unload the esp. When you unload Sense, it will clean up every drawing object and instance it has made.
--Sense.Unload()
```

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

### Create Rayfield UI Window

Source: https://docs.sirius.menu/rayfield/configuration/windows

Demonstrates how to initialize a new UI window using `Rayfield:CreateWindow()`. This method accepts a table of configuration options including name, icon, loading texts, theme, UI toggle keybind, build warnings, configuration saving, Discord integration, and key system settings.

```Lua
local Window = Rayfield:CreateWindow({
   Name = "Rayfield Example Window",
   Icon = 0, -- Icon in Topbar. Can use Lucide Icons (string) or Roblox Image (number). 0 to use no icon (default).
   LoadingTitle = "Rayfield Interface Suite",
   LoadingSubtitle = "by Sirius",
   ShowText = "Rayfield", -- for mobile users to unhide rayfield, change if you'd like
   Theme = "Default", -- Check https://docs.sirius.menu/rayfield/configuration/themes

   ToggleUIKeybind = "K", -- The keybind to toggle the UI visibility (string like "K" or Enum.KeyCode)

   DisableRayfieldPrompts = false,
   DisableBuildWarnings = false, -- Prevents Rayfield from warning when the script has a version mismatch with the interface

   ConfigurationSaving = {
      Enabled = true,
      FolderName = nil, -- Create a custom folder for your hub/game
      FileName = "Big Hub"
   },

   Discord = {
      Enabled = false, -- Prompt the user to join your Discord server if their executor supports it
      Invite = "noinvitelink", -- The Discord invite code, do not include discord.gg/. E.g. discord.gg/ ABCD would be ABCD
      RememberJoins = true -- Set this to false to make them join the discord every time they load it up
   },

   KeySystem = false, -- Set this to true to use our key system
   KeySettings = {
      Title = "Untitled",
      Subtitle = "Key System",
      Note = "No method of obtaining the key is provided", -- Use this to tell the user how to get a key
      FileName = "Key", -- It is recommended to use something unique as other scripts using Rayfield may overwrite your key file
      SaveKey = true, -- The user's key will be saved, but if you change the key, they will be unable to use your script
      GrabKeyFromSite = false, -- If this is true, set Key below to the RAW site you would like Rayfield to get the key from
      Key = {"Hello"} -- List of keys that will be accepted by the system, can be RAW file links (pastebin, github etc) or simple strings ("hello","key22")
   }
})
```

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

### Create and Configure Sense Instance ESP Object (Lua)

Source: https://docs.sirius.menu/sense/esp

This snippet demonstrates how to create an Instance ESP object using `Sense.AddInstance` in Lua. It shows how to set initial display properties such as text content with placeholders, text color, outline, size, font, and distance limitations. It also illustrates how to modify an option, like enabling or disabling the object, after its creation.

```Lua
local object = Sense.AddInstance(workspace.Part, {
    --enabled = false,
    text = "{name}", -- Placeholders: {name}, {distance}, {position}
    textColor = { Color3.new(1,1,1), 1 },
    textOutline = true,
    textOutlineColor = Color3.new(),
    textSize = 13,
    textFont = 2,
    limitDistance = false,
    maxDistance = 150
})

object.options.enabled = false
```

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

### Create Tab with Lucide Icon

Source: https://docs.sirius.menu/rayfield/configuration/windows

Illustrates creating a new tab with a Lucide icon. Instead of a numeric image ID, a string representing the Lucide icon name is used for the tab's visual representation.

```Lua
local Tab = Window:CreateTab("Tab Example", "rewind")
```

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

### Create a new Keybind in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/keybinds

This snippet demonstrates how to create a new keybind using `Tab:CreateKeybind`. It allows defining the keybind's name, initial key, whether it requires holding to interact, a unique flag for configuration saving, and a callback function that executes when the keybind is pressed or held.

```Lua
local Keybind = Tab:CreateKeybind({
   Name = "Keybind Example",
   CurrentKeybind = "Q",
   HoldToInteract = false,
   Flag = "Keybind1", -- A flag is the identifier for the configuration file, make sure every element has a different flag if you're using configuration saving to ensure no overlaps
   Callback = function(Keybind)
   -- The function that takes place when the keybind is pressed
   -- The variable (Keybind) is a boolean for whether the keybind is being held or not (HoldToInteract needs to be true)
   end,
})
```

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

### Create UI Section within Tab

Source: https://docs.sirius.menu/rayfield/configuration/windows

Demonstrates how to create a new section within a previously defined tab using `Tab:CreateSection()`. Sections help organize UI elements within a tab.

```Lua
local Section = Tab:CreateSection("Section Example")
```

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

### Create a Label in Rayfield

Source: https://docs.sirius.menu/rayfield/ui-components/text

Demonstrates how to create a new UI label using the `Tab:CreateLabel` method. It accepts parameters for the label's title, an image ID for an icon, its color, and a boolean to ignore the theme.

```Lua
local Label = Tab:CreateLabel("Label Example", 4483362458, Color3.fromRGB(255, 255, 255), false) -- Title, Icon, Color, IgnoreTheme
```

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

### Create a text input (TextBox) element in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Illustrates how to create an adaptive text input field, specifying its name, initial value, placeholder text, and behavior upon focus loss. It includes a unique flag for configuration and a callback function that provides the current text content when the input changes.

```Lua
local Input = Tab:CreateInput({
   Name = "Input Example",
   CurrentValue = "",
   PlaceholderText = "Input Placeholder",
   RemoveTextAfterFocusLost = false,
   Flag = "Input1",
   Callback = function(Text)
   -- The function that takes place when the input is changed
   -- The variable (Text) is a string for the value in the text box
   end,
})
```

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

### Default Sense ESP Configuration

Source: https://docs.sirius.menu/sense/configuration/configuring

This Lua table defines the default configuration for the Sense ESP system. It includes global settings like text size and render distance, as well as detailed visual settings for both enemy and friendly players, such as box ESP, health bars, name displays, weapon displays, distance indicators, tracers, off-screen arrows, and chams. Most features are disabled by default, allowing users to enable and customize specific visual elements.

```Lua
Sense = {
  whitelist = {}, -- When this table contains at least 1 user id, it will only show esp for those players.
  sharedSettings = {
      textSize = 13,
      textFont = 2,
      limitDistance = false, -- Set a maximum render distance
      maxDistance = 150,
      useTeamColor = false -- Change all colors to the players team color
  },
  teamSettings = {
      enemy = {
          enabled = false,
          box = false,
          boxColor = { Color3.new(1,0,0), 1 },
          --boxColor = { "Team Color", 1 }, -- Do this to change a single color to the team color
          boxOutline = true,
          boxOutlineColor = { Color3.new(), 1 },
          boxFill = false,
          boxFillColor = { Color3.new(1,0,0), 0.5 },
          healthBar = false,
          healthyColor = Color3.new(0,1,0),
          dyingColor = Color3.new(1,0,0),
          healthBarOutline = true,
          healthBarOutlineColor = { Color3.new(), 0.5 },
          healthText = false,
          healthTextColor = { Color3.new(1,1,1), 1 },
          healthTextOutline = true,
          healthTextOutlineColor = Color3.new(),
          box3d = false,
          box3dColor = { Color3.new(1,0,0), 1 },
          name = false,
          nameColor = { Color3.new(1,1,1), 1 },
          nameOutline = true,
          nameOutlineColor = Color3.new(),
          weapon = false,
          weaponColor = { Color3.new(1,1,1), 1 },
          weaponOutline = true,
          weaponOutlineColor = Color3.new(),
          distance = false,
          distanceColor = { Color3.new(1,1,1), 1 },
          distanceOutline = true,
          distanceOutlineColor = Color3.new(),
          tracer = false,
          tracerOrigin = "Bottom",
          tracerColor = { Color3.new(1,0,0), 1 },
          tracerOutline = true,
          tracerOutlineColor = { Color3.new(), 1 },
          offScreenArrow = false,
          offScreenArrowColor = { Color3.new(1,1,1), 1 },
          offScreenArrowSize = 15,
          offScreenArrowRadius = 150,
          offScreenArrowOutline = true,
          offScreenArrowOutlineColor = { Color3.new(), 1 },
          chams = false,
          chamsVisibleOnly = false,
          chamsFillColor = { Color3.new(0.2, 0.2, 0.2), 0.5 },
          chamsOutlineColor = { Color3.new(1,0,0), 0 }
      },
      friendly = {
          enabled = false,
          box = false,
          boxColor = { Color3.new(0,1,0), 1 },
          boxOutline = true,
          boxOutlineColor = { Color3.new(), 1 },
          boxFill = false,
          boxFillColor = { Color3.new(0,1,0), 0.5 },
          healthBar = false,
          healthyColor = Color3.new(0,1,0),
          dyingColor = Color3.new(1,0,0),
          healthBarOutline = true,
          healthBarOutlineColor = { Color3.new(), 0.5 },
          healthText = false,
          healthTextColor = { Color3.new(1,1,1), 1 },
          healthTextOutline = true,
          healthTextOutlineColor = Color3.new(),
          box3d = false,
          box3dColor = { Color3.new(0,1,0), 1 },
          name = false,
          nameColor = { Color3.new(1,1,1), 1 },
          nameOutline = true,
          nameOutlineColor = Color3.new(),
          weapon = false,
          weaponColor = { Color3.new(1,1,1), 1 },
          weaponOutline = true,
          weaponOutlineColor = Color3.new(),
          distance = false,
          distanceColor = { Color3.new(1,1,1), 1 },
          distanceOutline = true,
          distanceOutlineColor = Color3.new(),
          tracer = false,
          tracerOrigin = "Bottom",
          tracerColor = { Color3.new(0,1,0), 1 },
          tracerOutline = true,
          tracerOutlineColor = { Color3.new(), 1 },
          offScreenArrow = false,
          offScreenArrowColor = { Color3.new(1,1,1), 1 },
          offScreenArrowSize = 15,
          offScreenArrowRadius = 150,
          offScreenArrowOutline = true,
          offScreenArrowOutlineColor = { Color3.new(), 1 },
          chams = false,
          chamsVisibleOnly = false,
          chamsFillColor = { Color3.new(0.2, 0.2, 0.2), 0.5 },
          chamsOutlineColor = { Color3.new(0,1,0), 0 }
      }
  }
}
```

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

### Set Rayfield Interface Visibility

Source: https://docs.sirius.menu/rayfield/configuration/windows

Shows how to control the overall visibility of the Rayfield interface using `Rayfield:SetVisibility()`. A boolean argument determines whether the interface is shown or hidden.

```Lua
Rayfield:SetVisibility(false)
```

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

### Create a Paragraph in Rayfield

Source: https://docs.sirius.menu/rayfield/ui-components/text

Demonstrates how to create a new UI paragraph element using the `Tab:CreateParagraph` method. It takes a table as an argument, which should contain 'Title' and 'Content' properties for the paragraph.

```Lua
local Paragraph = Tab:CreateParagraph({Title = "Paragraph Example", Content = "Paragraph Example"})
```

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

### Create a Dropdown Menu in Lua

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Initializes a new dropdown UI element with specified options, a default selection, and a callback function. The 'Flag' property is crucial for configuration saving, ensuring unique identification for each element.

```Lua
local Dropdown = Tab:CreateDropdown({
   Name = "Dropdown Example",
   Options = {"Option 1","Option 2"},
   CurrentOption = {"Option 1"},
   MultipleOptions = false,
   Flag = "Dropdown1", -- A flag is the identifier for the configuration file, make sure every element has a different flag if you're using configuration saving to ensure no overlaps
   Callback = function(Options)
   -- The function that takes place when the selected option is changed
   -- The variable (Options) is a table of strings for the current selected options
   end,
})
```

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

### Create a numerical slider UI element in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Demonstrates how to create a slider with a name, a defined numerical range, an increment step, an optional suffix for the displayed value, an initial value, and a unique flag for configuration. It also includes a callback function that provides the slider's current numerical value when it changes.

```Lua
local Slider = Tab:CreateSlider({
   Name = "Slider Example",
   Range = {0, 100},
   Increment = 10,
   Suffix = "Bananas",
   CurrentValue = 10,
   Flag = "Slider1", -- A flag is the identifier for the configuration file, make sure every element has a different flag if you're using configuration saving to ensure no overlaps
   Callback = function(Value)
   -- The function that takes place when the slider changes
   -- The variable (Value) is a number which correlates to the value the slider is currently at
   end,
})
```

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

### Update an existing Label in Rayfield

Source: https://docs.sirius.menu/rayfield/ui-components/text

Shows how to modify the properties of an already created UI label using the `Label:Set` method. This allows changing the title, icon, color, and theme-ignoring setting dynamically.

```Lua
Label:Set("Label Example", 4483362458, Color3.fromRGB(255, 255, 255), false) -- Title, Icon, Color, IgnoreTheme
```

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

### Rayfield Available Themes and Identifiers

Source: https://docs.sirius.menu/rayfield/configuration/themes

A list of predefined theme names and their corresponding identifiers that can be used with Rayfield's theme application functions, such as `Window.ModifyTheme('ThemeIdentifier')` or by setting the 'Theme' argument in `CreateWindow`.

```Text
Theme Name - ThemeIdentifier

Default - Default
Amber Glow - AmberGlow
Amethyst - Amethyst
Bloom - Bloom
Dark Blue - DarkBlue
Green - Green
Light - Light
Ocean - Ocean
Serenity - Serenity
```

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

### Create a color picker UI element in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Illustrates how to create a color picker, specifying its name, initial Color3 value, and a unique flag for configuration saving. It includes a callback function that provides the selected Color3 value every time the picker is moved or changed.

```Lua
local ColorPicker = Tab:CreateColorPicker({
    Name = "Color Picker",
    Color = Color3.fromRGB(255,255,255),
    Flag = "ColorPicker1", -- A flag is the identifier for the configuration file, make sure every element has a different flag if you're using configuration saving to ensure no overlaps
    Callback = function(Value)
        -- The function that takes place every time the color picker is moved/changed
        -- The variable (Value) is a Color3fromRGB value based on which color is selected
    end
})
```

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

### Create an interactive button in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Illustrates how to create a new button element within a Tab, specifying its display name and a callback function that executes when the button is pressed. This function defines the button's core behavior.

```Lua
local Button = Tab:CreateButton({
   Name = "Button Example",
   Callback = function()
   -- The function that takes place when the button is pressed
   end,
})
```

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

### Create a boolean toggle switch in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Demonstrates how to create a toggle element with a name, initial boolean value, and a unique flag for configuration saving. It also includes a callback function that receives the toggle's current state (true/false) when it changes.

```Lua
local Toggle = Tab:CreateToggle({
   Name = "Toggle Example",
   CurrentValue = false,
   Flag = "Toggle1", -- A flag is the identifier for the configuration file, make sure every element has a different flag if you're using configuration saving to ensure no overlaps
   Callback = function(Value)
   -- The function that takes place when the toggle is pressed
   -- The variable (Value) is a boolean on whether the toggle is true or false
   end,
})
```

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

### Create UI Divider within Tab

Source: https://docs.sirius.menu/rayfield/configuration/windows

Illustrates how to add a visual divider within a tab using `Tab:CreateDivider()`. Dividers are used to visually separate content within a tab.

```Lua
local Divider = Tab:CreateDivider()
```

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

### Display notifications with Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Demonstrates how to display various types of notifications using the `Rayfield:Notify` function. It covers basic notifications with a numeric image ID and advanced notifications integrating Lucide Icons by providing the icon name as a string.

```Lua
Rayfield:Notify({
   Title = "Notification Title",
   Content = "Notification Content",
   Duration = 6.5,
   Image = 4483362458,
})
```

```Lua
Rayfield:Notify({
   Title = "Notification Title",
   Content = "Notification Content",
   Duration = 6.5,
   Image = "rewind",
})
```

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

### Create a Label with Lucide Icon in Rayfield

Source: https://docs.sirius.menu/rayfield/ui-components/text

Illustrates how to create a UI label that uses a Lucide icon. Instead of an image ID, the icon is specified by its string name, enabling integration with the Lucide Icons library.

```Lua
local Label = Tab:CreateLabel("Label Example", "rewind")
```

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

### Update Section Title

Source: https://docs.sirius.menu/rayfield/configuration/windows

Shows how to dynamically update the title of an existing section using the `Section:Set()` method. This allows for changing the displayed text of a section.

```Lua
Section:Set("Section Example")
```

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

### Destroy a Rayfield User Interface Instance

Source: https://docs.sirius.menu/rayfield/configuration/windows

This code snippet illustrates the method call required to completely destroy and remove an active Rayfield user interface instance. Calling `Rayfield:Destroy()` cleans up all associated UI elements, windows, tabs, and sections, freeing up system resources.

```Lua
Rayfield:Destroy()
```

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

### Update an existing Keybind in Rayfield

Source: https://docs.sirius.menu/rayfield/interaction/keybinds

This snippet shows how to programmatically change the assigned key for an existing keybind object using the `Set` method. The method takes a string representing the new key as its argument.

```Lua
Keybind:Set("RightCtrl") -- Keybind (string)
```

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

### Update Divider Visibility

Source: https://docs.sirius.menu/rayfield/configuration/windows

Demonstrates how to change the visibility of an existing divider using `Divider:Set()`. The method accepts a boolean value to show or hide the divider.

```Lua
Divider:Set(false)
```

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

### Lua EspInterface Functions for Player Data Retrieval

Source: https://docs.sirius.menu/sense/functions

This code snippet provides a set of Lua functions within the `EspInterface` designed to retrieve various player-specific attributes in a game context. These functions include `getWeapon`, `isFriendly`, `getTeamColor`, `getCharacter`, and `getHealth`. They are essential for game-specific logic, particularly for systems like ESP (Extra Sensory Perception), and might need to be adapted or extended based on the game's unique replication and data structures.

```Lua
function EspInterface.getWeapon(player)
    return "Unknown";
end

function EspInterface.isFriendly(player)
    return player.Team and player.Team == localPlayer.Team;
end

function EspInterface.getTeamColor(player)
    return player.Team and player.Team.TeamColor and player.Team.TeamColor.Color;
end

function EspInterface.getCharacter(player)
    return player.Character;
end

function EspInterface.getHealth(player)
    local character = player and EspInterface.getCharacter(player);
    local humanoid = character and findFirstChildOfClass(character, "Humanoid");
    if humanoid then
        return humanoid.Health, humanoid.MaxHealth;
    end
    return 100, 100;
end
```

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

### Update an existing Paragraph in Rayfield

Source: https://docs.sirius.menu/rayfield/ui-components/text

Illustrates how to modify the title and content of an existing UI paragraph using the `Paragraph:Set` method. Similar to creation, it accepts a table with 'Title' and 'Content' properties.

```Lua
Paragraph:Set({Title = "Paragraph Example", Content = "Paragraph Example"})
```

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

### Update the text of a Rayfield input (TextBox)

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Shows how to programmatically set the text content of an existing input (TextBox) element. This enables dynamic modification of the text field's displayed value.

```Lua
Input:Set("New Text") -- The new input text value
```

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

### Update the state of a Rayfield toggle

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Shows how to programmatically set the boolean state (true or false) of an existing toggle element. This allows for external control over the toggle's visual and functional state.

```Lua
Toggle:Set(false)
```

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

### Set Selected Dropdown Option(s) in Lua

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Programmatically sets the currently selected option(s) for a dropdown menu. If 'MultipleOptions' was enabled during creation, the input table can contain multiple strings. Note that this action triggers the dropdown's callback function.

```Lua
Dropdown:Set({"Option 2"}) -- "Option 2" will now be selected
```

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

### Update the color of a Rayfield color picker

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Shows how to programmatically set the Color3 value of an existing color picker element. This enables dynamic adjustment of the color picker's displayed color.

```Lua
ColorPicker:Set(Color3.fromRGB(255,255,255)
```

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

### Update the text of a Rayfield button

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Shows how to programmatically change the displayed text of an existing button element. This allows for dynamic updates to the button's label after its initial creation.

```Lua
Button:Set("Button Example")
```

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

### Refresh Dropdown Options in Lua

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Updates the list of available options for an existing dropdown menu. This method replaces the current options with a new set provided as a table.

```Lua
Dropdown:Refresh({"New Option 1","New Option 2"}) -- The new list of options
```

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

### Access Current Value of UI Elements

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Describes how to retrieve the current value of various UI elements. For general elements, use `ElementName.CurrentValue`. For specific types like keybinds or dropdowns, use `KeybindName.CurrentKeybind` or `DropdownName.CurrentOption` respectively. Values can also be accessed via `Rayfield.Flags`.

```APIDOC
ElementName.CurrentValue
KeybindName.CurrentKeybind
DropdownName.CurrentOption
Rayfield.Flags.YourFlagName
```

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

### Update the value of a Rayfield slider

Source: https://docs.sirius.menu/rayfield/interaction/interactive-elements

Shows how to programmatically set the numerical value of an existing slider element. This allows for external control over the slider's position and associated value.

```Lua
Slider:Set(10) -- The new slider integer value
```
Tokens:
Raw