Check out the [Installation](https://baxoplenty.gitbook.io/quebec-docs/installation) page, to install Quebec into your game. We will go through two main points in this guide which will help you understand the Quebec architecture.

Project Structure

Quebec is pretty relaxed with your file structure, but singletons must be parented to one specific folder, which you pass to Quebec as described in [Running Quebec](https://baxoplenty.gitbook.io/quebec-docs/guides/getting-started#running-quebec)

An example project structure looks like this:

Copy

    - server/
      - services/ -- Contain all server-singletons (also called services)
      - init.server.luau -- Runs Quebec on the server
    - client/
      - controllers/ -- Contains all client-singletons (also called controllers)
      - init.client.luau -- Runs Quebec on the client

The `init.*.luau` files are running Quebec.

Running Quebec

Running Quebec is extremely simple. You just have to **require the Quebec main module** and call `run` on it with the singleton folder as the first argument. Like this:

Copy

    -- "services" is a folder that contains the singletons
    require(PathToQuebecModule).run(script.Parent.services --[[, optional options table]])

There are a few rules that apply:

  1. Two instances should **NEVER use the same singletons folder**

  2. The **first argument MUST be a folder**

  3. The script that runs Quebec must be **a normal script, not a ModuleScript**

Available Options

Signature

Description

`instances: { string }?`

A table of instance names to wait for, before running any singleton. Check out [Multiple Instances](https://baxoplenty.gitbook.io/quebec-docs/guides/multiple-instances) for more information

`info: boolean?`

Defaults to `true` . Enabling this will enable info-level prints from the logger.

`debug: boolean?`

Defaults to `false` in production, but `true` when in studio. Enabling this will enable debug-level prints.

[PreviousTroubleshooting](https://baxoplenty.gitbook.io/quebec-docs/troubleshooting)[NextCreating Singletons](https://baxoplenty.gitbook.io/quebec-docs/guides/creating-singletons)

Last updated 8 months ago


Quebec offers some utility functions that aim to make your developer experience easier. These functions are NOT mandatory to be used. They are exported by the main Quebec module within the `util` table (`Quebec.util.x`).

[Class](https://baxoplenty.gitbook.io/quebec-docs/core/utility-functions/class)

[PreviousChannel](https://baxoplenty.gitbook.io/quebec-docs/core/modules/channel)[NextClass](https://baxoplenty.gitbook.io/quebec-docs/core/utility-functions/class)

Last updated 8 months ago


* Added the [Signal](https://baxoplenty.gitbook.io/quebec-docs/core/modules/signal) module

  * Added the [Channel](https://baxoplenty.gitbook.io/quebec-docs/core/modules/channel) module

  * Added a version string inside the module

  * Other small additions

[Previousv4.0.0](https://baxoplenty.gitbook.io/quebec-docs/changelog/v4.0.0)[Nextv4.2.0](https://baxoplenty.gitbook.io/quebec-docs/changelog/v4.2.0)

Last updated 8 months ago


* Added [Modding](https://baxoplenty.gitbook.io/quebec-docs/guides/modding)

Sorry for the delay! 🙏

[Previousv4.1.0](https://baxoplenty.gitbook.io/quebec-docs/changelog/v4.1.0)[NextMigration](https://baxoplenty.gitbook.io/quebec-docs/migration)

Last updated 7 months ago


* Complete Overhaul

  * New dependency injection pattern: Roblox's vanilla `require`

  * Class utility

[PreviousChangelog](https://baxoplenty.gitbook.io/quebec-docs/changelog)[Nextv4.1.0](https://baxoplenty.gitbook.io/quebec-docs/changelog/v4.1.0)

Last updated 8 months ago


Channels can only have one consumer (callback), but multiple producers.

A channel is a wrapper for a `BindableFunction` . It's used to invoke an event and get return values from it. They can be used to communicate with another service without having to require it.

Defining Channels

We recommend defining channels in a single ModuleScript, usually parented to the parent of the singletons folder.

Copy

    local Channel = require(Quebec.modules.Channel)

    return {
        IsPlayerBanned = Channel.new((string, number), (boolean, boolean)),

You can then invoke it by calling `:invoke(...args)` on it, or set a callback using `:set(cb)` :

Copy

    Channels.IsPlayerBanned:set(function (username: string, userId: number): boolean
        return false, false
    end)

Good Practice

It is recommended that you set callbacks during the initialization phase:

Copy

    local Service = Quebec.singleton({})

    function Service.init(self: typeof(Service))
        Channels.IsPlayerBanned:set(function (username: string, userId: number)
            -- ...
        end)
    end

    return Service

[PreviousSignal](https://baxoplenty.gitbook.io/quebec-docs/core/modules/signal)[NextUtility Functions](https://baxoplenty.gitbook.io/quebec-docs/core/utility-functions)

Last updated 8 months ago


Important Note

While the networking module allows you to have typed events, it **DOES NOT CHECK THE INPUT**! We recommend using a library like [Roblox's t](https://github.com/Roblox/t) to insert runtime checks!

Networking in Roblox can be an annoying process, especially if you have to wire it all together yourself. That's why Quebec has a feature-rich networking library.

Events

The networking library supports **two kinds of events**: typed and untyped events. Untyped events essentially accept every argument while typed events have strict types for the arguments. Here's an example:

Copy

    local Networking = require(script.Parent.Quebec.modules.Networking)

    -- calling :client() on the event will return the client-sided executor.
    -- it was added to improve autocompletions and a way to share events without declaring
    --    them multiple times. refer to "Organizing"

    local Untyped = Networking.event("Equipitem"):client()

    Untyped:fire("Sword", 1, 2, 3) -- this works, as it accepts every argument

    Untyped:connect(function (...: any)
        print(...) -- prints args
    end)

    -- note: the parenthesis around the "string, number" are cosmetic in this case
    --       but are good practice to group type packs.
    local Typed: Networking.Event<(string, number)> = Networking.event("DropItem")
    local TypedExecutor = Typed:client()

    TypedExecutor:connect(function (item: string, amount: number)
        print("dropping", tostring(amount), "x", item)
    end)

    TypedExecutor:fire("Sword", 1) -- works
    TypedExecutor:fire("Sword", false) -- this would show a warning due to type mismatch

Please remember that Quebec does **NOT** perform runtime type checks.

Functions

The library also supports RemoteFunctions. Just like the events, there are typed and untyped ones. However, this time the parentheses aren't optional. Let me show you:

Organizing

We recommend to create an `Events` ModuleScript somewhere in `ReplicatedStorage` where you save all your events so both the server and client can access the same events:

You can then access any executor like this:

Executor Methods

All executor methods are called using a colon. So: `executor:fire()` instead of `executor.fire()` !

Access a client-side executor by calling `:client()` on the selected event or function. To access the server-sided executor, call `:server()` on the selected event or function.

Events

`Args...` is a type placeholder for the arguments type pack. If you use an untyped event, then this will always be `...any` .

Server-Sided

Client-Sided

Signature

Description

`fire(player: Player | { Player }, Args...): ()`

Fires the event with the given arguments to the selected player or players

`broadcast(Args...): ()`

Fires the event with the given arguments to all players

`except(player: Player | { Player }, Args...): ()`

Fires the event with the given arguments to all players except the given ones

`connect(callback: (player: Player, Args...) -> ()): RBXScriptConnection`

Connects the callback to the event's `OnServerEvent`

Signature

Description

`fire(Args...): ()`

Fires the event with the given arguments

`connect(callback: (Args...) -> ()): RBXScriptConnection`

Connects the callback to the event's `OnClientEvent`

Functions

`Args...` and `Returns...` are type placeholders for the arguments and returns type packs. If you use an untyped function, this will always be `...any` for both.

Functions also don't support broadcasting due to the fact that RemoteFunctions return values. However, we may add functionality like this in a later update in which you can query the return result of a player.

Server-Sided

Client-Sided

Signature

Description

`invoke(player: Player, ...Args): ...Returns`

Invokes the function on the specified players with the given arguments and returns the defined returns

`connect(callback: (player: Player, ...Args) -> ...Returns): ()`

Connects the callback to the event's `OnServerInvoke`

Signature

Description

`invoke(...Args): ...Returns`

Invokes the function with the given arguments and returns the specified returns

`connect(callback: (...Args) -> ...Returns): ()`

Connects the callback to the event's `OnClientInvoke`

[PreviousModules](https://baxoplenty.gitbook.io/quebec-docs/core/modules)[NextSignal](https://baxoplenty.gitbook.io/quebec-docs/core/modules/signal)

Last updated 8 months ago


A signal is essentially a wrapper for a `BindableEvent` . You can fire and connect to signals. These can be used to circumvent problems with circular dependencies by just firing the signal.

Defining Signals

We recommend defining signals in a single ModuleScript that will be required by a Quebec instance. Usually, this ModuleScript should be parented to the parent of the singletons folder. However, that is not a requirement.

Copy

    local Signal = require(PathToQuebec.modules.Signal)

    return {
        BanUser = Signal.new("BanUser") :: Signal.Signal<(string, number)>,
        UnbanUser = Signal.new("UnbanUser") :: Signal.Signal<(string)>,

Now you can connect to these signals using `Signals.BanUser:connect(cb)` and fire them using `Signals.BanUser:fire(...args)`

Good Practice

It is recommended that you connect to signals during the `init` phase:

Copy

    local Service = Quebec.singleton({})

    function Service.init(self: typeof(Service))
        Signals.UnbanUser:connect(function (username: string)
            -- ...
        end)
    end

    return Service

The connect method is not performance intense so it is fine to use during initialization.

[PreviousNetworking](https://baxoplenty.gitbook.io/quebec-docs/core/modules/networking)[NextChannel](https://baxoplenty.gitbook.io/quebec-docs/core/modules/channel)

Last updated 8 months ago


Copy

    -- ! Please note that this is just an example. This Signal class SHOULD NOT be used

    local Quebec = require(QuebecMainModule)

    -- We are creating a class called "Signal" now, to emit and receive events

    type Signal = {
        name: string,
        callback: ((...any) -> unknown)?,

    local Signal = Quebec.util.class(
        -- This is the constructor. It sets the class fields
        function(self: Signal, name: string)
            self.name = name
        end,
        -- This is the prototype. The methods that a Signal class has
            fire = function(self: Signal, ...)
                if self.callback then
                    local args = { ... }

                    task.spawn(function()
                        self.callback(table.unpack(args))
                    end)
                end
            end,
            connect = function(self: Signal, cb: (...any) -> unknown)
                self.callback = cb
            end
    )

    -- Now you can use it like this:

    local finishedSignal = Signal.new("finished")

    finishedSignal:connect(function()
        print("called")
    end)

    finishedSignal:fire()

Function Signature

`Quebec.util.class(constructor, prototype)`

`constructor` is a function that is tied to the `class.new` function later on. It is used to set fields in the class.

`prototype` is a table of methods that the class has.

[PreviousUtility Functions](https://baxoplenty.gitbook.io/quebec-docs/core/utility-functions)[NextImproving Autocompletions](https://baxoplenty.gitbook.io/quebec-docs/best-practices/improving-autocompletions)

Last updated 8 months ago


# NetRay

> High-Performance Roblox Networking Library

NetRay aims to simplify and streamline client-server communication in Roblox using RemoteEvents and RemoteFunctions, providing a structured, efficient, and easier-to-manage approach compared to manual remote instance handling.

## 🤔 Why NetRay?

Managing dozens of individual `RemoteEvent` and `RemoteFunction` instances can quickly become messy and error-prone. NetRay offers:

⚡
Optimized Performance
Automatic event batching, efficient binary serialization, and intelligent compression reduce network load and improve responsiveness.

🔒
Enhanced Reliability
Built-in Circuit Breakers prevent cascading failures, while robust error handling and timeouts make your networking more resilient.

🛡
Type Safety & Validation
Define data structures for your events and requests. NetRay automatically validates payloads, catching errors early in development.

⚙
Flexible Middleware
Intercept, modify, or block network traffic using a powerful middleware system. Implement logging, rate limiting, or custom validation with ease.

🚀
Modern Developer Experience
Clean API using Promises for asynchronous requests, clear event handling patterns, and priority queues simplify complex networking code.

📊
Built-in Monitoring
Debug signals provide visibility into internal events, errors, and potentially network traffic, aiding optimization and troubleshooting.

## ✨ Features

*   Define client->server and server->client communication easily.
*   Abstraction over `RemoteEvent` and `RemoteFunction`.
*   Middleware support
*   Automatic Server and Client Rate Limiting
*   Dynamic Sender - Automatically selects the best method of sending your data
*   And Many More!

## 🚀 Getting Started

### Installation

1.  **Download:** Grab the latest `.rbxmx` model file from the [Releases page](https://github.com/AstaWasTaken/NetRay/releases).
2.  **Import:** Insert the downloaded model into Roblox Studio, placing it in ReplicatedStorage.

### Quick Start Example

```lua
--[[ Server Script (e.g., in ServerScriptService) ]]

-- Server: Register and handle an event
local myEvent = NetRay:RegisterEvent("SimpleGreeting", {
  typeDefinition = { message = "string" }
})

myEvent:OnEvent(function(player, data)
  print(player.Name, "sent:", data.message)

  -- Reply back to just that player
  myEvent:FireClient(player, { message = "Server received: ".. data.message })
end)

print("NetRay Server event handler ready.")

```lua
--[[ Local Script (e.g., in StarterPlayerScripts) ]]

-- Client: Get event reference and interact
local myEvent = NetRay:GetEvent("SimpleGreeting")

-- Listen for server's reply
myEvent:OnEvent(function(data)
  print("Server replied:", data.message)
end)

-- Fire event to server after a delay
task.delay(3, function()
  local playerName = game:GetService("Players").LocalPlayer.Name
  print("Client sending greeting...")
  myEvent:FireServer({ message = "Hello from ".. playerName })
end)

📚 Documentation
For detailed information, API reference, and advanced usage guides, please visit our documentation website:

[NetRay Documentation](https://astawastaken.github.io/NetRay/)

🤝 Contributing
Contributions are welcome! Please feel free to submit Pull Requests or open Issues for bugs, feature requests, or questions.

📜 License
NetRay is licensed under the MIT License. See the LICENSE file for details.


NetRay streamlines Roblox networking with enhanced performance, reliability features like circuit breakers, and a developer-friendly API including type safety and middleware support. Build robust and efficient networked experiences with less boilerplate.

⚡

### Optimized Performance

Automatic event batching, efficient binary serialization, and intelligent compression reduce network load and improve responsiveness.

🔒

### Enhanced Reliability

Built-in Circuit Breakers prevent cascading failures, while robust error handling and timeouts make your networking more resilient.

🛡

### Type Safety & Validation

Define data structures for your events and requests. NetRay automatically validates payloads, catching errors early in development.

⚙

### Flexible Middleware

Intercept, modify, or block network traffic using a powerful middleware system. Implement logging, rate limiting, or custom validation with ease.

🚀

### Modern Developer Experience

Clean API using Promises for asynchronous requests, clear event handling patterns, and priority queues simplify complex networking code.

📊

### Built-in Monitoring

Debug signals provide visibility into internal events, errors, and potentially network traffic, aiding optimization and troubleshooting.

## Simple & Powerful API

  * Server-Side
  * Client-Side

    -- Server: Register and handle an event
    local myEvent = NetRay:RegisterEvent("SimpleGreeting", {
      typeDefinition = { message = "string" }
    })

    myEvent:OnEvent(function(player, data)
      print(player.Name, "sent:", data.message)

      -- Reply back to just that player
      myEvent:FireClient(player, { message = "Server received: ".. data.message })
    end)

    print("NetRay Server event handler ready.")

    -- Client: Get event reference and interact
    local myEvent = NetRay:GetEvent("SimpleGreeting")

    -- Listen for server's reply
    myEvent:OnEvent(function(data)
      print("Server replied:", data.message)
    end)

    -- Fire event to server after a delay
    task.delay(3, function()
      local playerName = game:GetService("Players").LocalPlayer.Name
      print("Client sending greeting...")
      myEvent:FireServer({ message = "Hello from ".. playerName })
    end)


This section provides detailed documentation for the primary classes, methods, and options available in the NetRay library.

Choose a specific component from the sidebar to view its detailed API:

  * **[NetRay](https://astawastaken.github.io/NetRay/docs/api-reference/netray):** The main entry point module required in scripts. Provides functions for registering events, requests, middleware, and accessing debug features.
  * **[ServerEvent](https://astawastaken.github.io/NetRay/docs/api-reference/serverevent):** Handles server-side logic for unidirectional events.
  * **[ClientEvent](https://astawastaken.github.io/NetRay/docs/api-reference/clientevent):** Handles client-side logic for unidirectional events.
  * **[RequestServer](https://astawastaken.github.io/NetRay/docs/api-reference/requestserver):** Handles server-side logic for request/response patterns.
  * **[RequestClient](https://astawastaken.github.io/NetRay/docs/api-reference/requestclient):** Handles client-side logic for request/response patterns using Promises.
  * **[CircuitBreaker](https://astawastaken.github.io/NetRay/docs/api-reference/circuitbreaker):** Provides fault tolerance for network operations.
  * **Shared Modules:** Learn more about internal components like Type Checking, Priorities, etc., in the [Advanced Features](https://astawastaken.github.io/NetRay/docs/advanced-features/) section.


# [Tutorial](https://youtu.be/dJjZ7ml9bSo?si=dOwrWtZQjJvYBVvN)
# [Wally](https://wally.run/package/crusherfire/module-loader)


#  Illusion's InputActionSystem

![IIASLogo|256x256, 75%](./IIASLogo.png)

Hey developers! I'm excited to share the latest version of my **InputActionSystem** library - a complete rewrite of my [previous keybind system](https://devforum.roblox.com/t/illusions-inputactionsystem-an-easy-way-of-adding-keybinds-and-other/4061839) that's now fully modular and can be integrated anywhere in your LocalScripts.

If you're working with Roblox's new InputActionSystem or just need robust keybind management, this library will save you hours of development time.

## Key Features

- **Flexible Input Types**: Define actions as Hold or Toggle buttons
- **Multi-Key Support**: Assign multiple keys per action for full gamepad compatibility
- **Key Combinations**: Create complex actions using modifier keys (e.g., Shift + F)
- **UI Integration**: Connect keybinds to GuiButtons for seamless mobile support
- **Cooldown System**: Prevent action spam with customizable cooldowns
- **Input Buffering**: Capture inputs even during busy frames
- **Tap Detection**: Trigger actions with double-tap or multi-tap sequences
- **Priority & Sinking**: Fine control over input processing order
- **(NEW) Choose between five different InputActionType**: respecting original usage of IAS

## Installation
### Non Server Authority version:

**Option 1:** [Download from Creator Store](https://create.roblox.com/store/asset/92059655869452/Illusions-InputActionSystem-Module)

**Option 2:** [Clone from GitHub](https://github.com/IllusionAC/Illusion-InputActionSystem)

Place the module in `ReplicatedStorage` and require it in any LocalScript:

```lua
local IAS = require(game.ReplicatedStorage.IllusionIAS)

### Server Authority version:

Do the same steps as for normal version, but require the module from a Server Script.

Future updates will allow the developer to send proper data to client so he can edit their binds properly.

> **Note:** When updates are released, re-download from the Creator Store or pull from GitHub.

##  API Reference

### Create, Manage and give contexts to Binds

```lua
IIAS.new(name: string, InputType: Enum.InputActionType?) -- Create a new keybind, set a InputActionType (default to Bool)
IIAS.Get(name: string?)                                  -- Retrieve a specific bind
IIAS.GetAll()                                            -- Get all registered binds

-- IMPORTANT: Context here doesn't stand for InputContext
-- but rather a way to organize your binds.

IIAS.addContext(name: string, ...Object)           -- add a Bind to a context
IIAS.getContext(name: string)                      -- returns a context
IIAS.newContext(name: string)                      -- create a new context
IIAS.enableContext(name: string, enabled: boolean) -- enable or disables all the binds from the context
IIAS.isContextEnabled(name: string)                -- returns the context's action state
IIAS.clearContexts()                               -- clear all contexts
IIAS.removeContext(name: string)                   -- remove a context
IIAS.removeFromContext(name: string, bind: Object) -- remove a bind from a context
IIAS.removeAllFromContext(name: string): empty a context without deleting it

### Configuration Methods

```lua
:SetHold(hold: boolean)                         -- true = hold to activate, false = toggle
:SetUIButton(button: GuiButton?)                -- Link a GUI button as alternate input
:SetCooldown(cooldown: number)                  -- Set cooldown in seconds (default: 0)
:ResetCooldown()                                -- Manually reset cooldown
:SetEnabled(enabled: boolean)                   -- Enable/disable the bind
:IsEnabled()                                    -- Check if bind is enabled
:SetTapActivation(taps: number, window: number) -- Require N taps within time window

### Input Context Control

```lua
:SetPriority(priority: number)           -- Set processing priority
:GetPriority()                           -- Get current priority
:SetSink(sink: boolean)                  -- Set if input should sink
:GetSink()                               -- Get sink state

### Input Buffering

```lua
:SetInputBufferEnabled(enabled: boolean) -- Enable input buffering (default: false)
:SetInputBufferTime(time: number)        -- Buffer window in seconds (default: 0.15)

### Keybind Management

```lua
:AddBind(mainKey: KeyCode, ...modifiers: KeyCode)        -- Add a keybind with optional modifiers
:SetBind(mainKey: KeyCode, ...modifiers: KeyCode)        -- Replace all binds with one
:GetBinds()                                              -- Get all current keybinds
:RemoveBind(mainKey: KeyCode, ...modifiers: KeyCode)     -- Remove specific bind
:EditBind(oldMain, oldMods, newMain, newMods)            -- Replace a bind
:ClearBinds()                                            -- Remove all keybinds
:Destroy()                                               -- Delete the bind entirely
:SetCompositeDirections(up, down, left, right, forward, backward) -- Sets composite directions for Directions

### InputActionType management

```lua
:Fire(active, pressed)           -- Fire the bind manually
:GetState()                      -- Returns active state
:SetScale(scale)                 -- Set Scale for Directions
:GetScale()                      -- Get Scale for Directions
:SetVectorScale(vector)          -- Set VectorScale for Directions
:GetVectorScale()                -- Get VectorScale for Directions
:SetResponseCurve(curve)         -- Set ReesponseCurve for Directions
:GetResponseCurve()              -- Get ResponseCurve for Directions
:SetPressedThreshold(threshold)  -- Set Pressed Threshold for Bool
:GetPressedThreshold()           -- Get Pressed Threshold for Bool
:SetReleasedThreshold(threshold) -- Set Released Threshold for Bool
:GetReleasedThreshold()          -- Get Released Threshold for Bool
:SetPointerIndex(Object, index) -> (),
:GetPointerIndex(Object) -> (number),
:SetClampMagnitudeToOne(Object, bool) -> (),
:GetClampMagnitudeToOne(Object) -> (boolean),

## Utilities / Introspection

```lua
:GetCooldownRemaining() -- number: seconds remaining on the current cooldown (0 if none).
:IsBuffered() -- boolean: whether an input is currently buffered.
:ResetBuffer() -- void: clears any buffered input.
:GetBufferedVariant() -- variant?: the buffered variant value (Vector/number/bool), if present.
:GetBufferedKey() -- `Enum.KeyCode?`: the buffered key code, if present.
:GetActiveBindCount() -- number: how many binds are currently active.
:GetToggleState() -- boolean: current toggle state for toggle-mode binds.
:GetActiveMainKey() -- `Enum.KeyCode?`: which main key is currently active, if any.

### Properties

```lua
Keybind.Name         -- The bind's name
Keybind.Active       -- Current activation state
Keybind.Enabled      -- Whether bind is enabled
Keybind.Priority     -- InputContext priority
Keybind.Sink         -- InputContext sinkability
Keybind.Hold         -- Hold mode state
Keybind.Cooldown     -- Cooldown duration
Keybind.Activated    -- IAScriptSignal event
Keybind.Started      -- IAScriptSignal event, equivalent to input began
Keybind.Ended        -- IAScriptSignal event, equivalent to input ended
Keybind.Scale        -- InputBinding Scale, for Directions
Keybind.VectorScale  -- InputBinding VectorScale, for Direction2D and 3D
Keybind.ResponseCurve -- InputBinding ResponseCurve, for Directions
Keybind.PressedThreshold -- InputBinding PressedThreshold, for Bool
Keybind.ReleasedThreshold -- InputBinding ReleasedThreshold, for Bool
Keybind.PointerIndex
Keybind.ClampMagnitudeToOne

The `Activated`, `Started`  and `Ended` events works like standard Roblox signals with `:Connect()`, `:Once()`, `:Wait()`, and `:Fire()` methods. This library uses [IllusionSignal](https://github.com/IllusionAC/IllusionSignal) module.

## Example: Sprint & Walk System

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local IIAS = require(ReplicatedStorage.IllusionIAS)

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")

-- Create binds
local sprint = IIAS.new("Sprint")
local walk = IIAS.new("Walk")

-- Configure as hold buttons
sprint:SetHold(true)
walk:SetHold(true)

-- Set keybinds
sprint:AddBind(Enum.KeyCode.LeftShift)
walk:AddBind(Enum.KeyCode.LeftControl)

-- Connect to humanoid
sprint.Activated:Connect(function(active, pressed)
    humanoid.WalkSpeed = active and 24 or 16
end)

walk.Activated:Connect(function(active, pressed)
    humanoid.WalkSpeed = active and 8 or 16
end)

## Example: Advanced Keybind with Cooldown

```lua
local IIAS = require(game.ReplicatedStorage.IllusionIAS)

local bind = IIAS.new("Bind")

-- Shift + F to activate
bind:AddBind(Enum.KeyCode.F, Enum.KeyCode.LeftShift)

-- Toggle mode
bind:SetHold(false)

-- 2 second cooldown
bind:SetCooldown(2)

-- Double-tap within 0.5s to activate
bind:SetTapActivation(2, 0.5)

bind.Activated:Connect(function(active, pressed)
    print("Bind state:", active, "| Key pressed:", pressed)
    -- The binds logic
end)

## Feedback & Support

I'd love to hear your thoughts! Please share:
- Feature requests
- Bug reports
- Use cases from your projects
- Suggestions for improvements

Thanks for checking out IllusionIAS - happy scripting!

*- Illusion* | discord: @illuusion


# Nanoai

    Minimal library for creating neural networks.

    npm package →

**Nanoai** is a fast, lightweight library for handling multi-layer perceptron (MLP) neural networks.

The addition of recurrent and convolutional layers is not planned at this time.

## 📦 Setup

### TypeScript

```sh
npm install @rbxts/nanoai
yarn add @rbxts/nanoai
pnpm add @rbxts/nanoai

### Wally

Add `littensy/nanoai` to your `wally.toml` file.

```toml
[dependencies]
Nanoai = "littensy/nanoai@VERSION"

## 📚 API Reference

#### `create(shape, activation)`

#### `predict(network, input)`

#### `backpropagate(network, input, expected, learningRate)`

#### `evolution(options)`

#### `init[type](network, ...)`

#### `initialize(network, initializer)`

#### `clone(network)`

## 🚀 Examples

### XOR problem

```lua
local model = Nanoai.create({ 2, 3, 1 }, Nanoai.Activation.TanH)

Nanoai.init.normal(model)

for _ = 1, 500 do
    Nanoai.backpropagate(model, { 0, 1 }, { 1 }, 0.3)
    Nanoai.backpropagate(model, { 1, 0 }, { 1 }, 0.3)
    Nanoai.backpropagate(model, { 0, 0 }, { 0 }, 0.3)
    Nanoai.backpropagate(model, { 1, 1 }, { 0 }, 0.3)
end

Nanoai.predict(model, { 0, 1 }) -- ~1

Nanoai is released under the MIT License.


High-performance, schematized buffer serialization for Roblox Luau, inspired by Sera and Squash.

## Features

- **Compact:** Provides space-efficient types like variable-length integers (`Z.int`, `Z.uint`), bit-packed booleans (`Z.bool(n)`), and lossy formats (`Z.Angle8`, `Z.CFrame15`).
- **Flexible:** Supports dictionaries, arrays (`Z.schema { Z.f64 }`), maps (`Z.schema { [Z.uint] = Z.u16 }`), migrating schemas, nested schemas, optionals (`Z.some`), and safe deserialization.
- **High-Performance:** Designed for speed with features like a pre-allocated scratch buffer to minimize memory allocations.
- **Schema-Based:** Enforces a strict data structure for reliable serialization.

## Installation

1.  Download [`init.luau`](src/init.luau) from the `src/` directory.
2.  Place the file into your project (e.g., `ReplicatedStorage/Modules/Z`).
3.  Require the module in your script:

```luau
local Z = require(game.ReplicatedStorage.Modules.Z)

## Basic Usage

```luau
local Z = require(game.ReplicatedStorage.Modules.Z)

-- 1. Define a schema (a "blueprint" for your data)
local PlayerDataSchema = Z.schema {
    Name = Z.str8, -- A string with a max length of 2^8-1
    Health = Z.u8, -- An unsigned 8-bit integer, 0 to 255
    IsAdmin = Z.some(Z.bool), -- An optional boolean
    Position = Z.Vector3i16, -- A vector with 16-bit integer components, -32768 to 32767
    -- Schemas can be nested in other schemas
    Inventory = Z.schema8 { [Z.u8] = Z.u8 }, -- Schema map of u8 item ids to a u8 stack count, with a limit of 2^8 - 1 key/value pairs using Z.schema8

-- 2. Create data that matches the schema
local data = {
    Name = "Kohl",
    Health = 100,
    IsAdmin = true,
    Position = Vector3.new(10, 5, -20),
    Inventory = { [101] = 255, [115] = 1, [127] = 12 },

-- 3. Serialize the data (table -> buffer)
local serializedBuffer, err = Z.ser(PlayerDataSchema, data)
assert(serializedBuffer, err)

print(`Z.ser size: {buffer.len(serializedBuffer)} bytes`) --> 21 bytes
print(`JSONEncode: {#game.HttpService:JSONEncode(data)} bytes`) --> 100 bytes

-- 4. Deserialize the data (buffer -> table)
local deserializedData, _bytesRead = Z.des(PlayerDataSchema, serializedBuffer)
print("Deserialized Data:", deserializedData)

## API Reference

```luau
Z.schema(definition)

Creates a new schema from a definition table.

- **Dictionary Schema:** `Z.schema { KeyA = Z.u8, KeyB = Z.f32 }`
  - Keys are sorted alphabetically for consistent serialization.
- **List Schema:** `Z.schema { Z.f64 }`
  - Defines a schema for a list of a single `ZType`.
- **Map Schema:** `Z.schema { [Z.uint] = Z.u16 }`
  - Defines a schema for a map of a `ZType` key to a `ZType` value.
- **Limit List/Map Schemas:** `Z.schema8/16/32 { [Z.uint] = Z.u16 }`
  - Sets the maximum number of items to `2^8-1`, `2^16-1`, or `2^32-1`. Defaults to `u32`.

```luau
Z.ser(schema: Schema | ZType, object: Data, b: buffer?, offset: number?)

Serializes a Luau `object` according to the provided `Schema` or `ZType`.

- If `buffer` is **omitted**, it returns a **new buffer** containing the serialized data.
- If `buffer` is **provided**, it writes into that buffer and returns the **new offset** (the position after the written data).
- **Returns:** `(buffer | number, nil)` on success, or `(nil, string)` on error.

```luau
Z.des(schema: Schema | ZType, b: buffer, offset: number?, safe: boolean?)

Deserializes binary data from a `buffer` into a new table.

- `offset` defaults to `0`.
- `safe` defaults to `false`. If `true`, it suppresses errors from incomplete data (e.g., if the buffer is truncated). This is useful for reading data from streams.
- **Returns:** `(deserializedObject, nextOffset)`.

```luau
Z.migrate(old: Schema, new: Schema, b: buffer, change: ((Data) -> Data)?)

Migrates binary data from a `buffer` to `newSchema`, if it matches `oldSchema`.

- `change` is an optional function that can modify the data before serializing to the new schema.
- **Returns:** `(number, nil)` on success, or `(nil, string)` on error.

```luau
Z.some(t: ZType)

Wraps any `ZType` (including other schemas) to make it optional. This adds a 1-byte overhead.

- If the value is `nil`, it writes a single `0` byte.
- If the value is present, it writes a `1` byte followed by the value's serialized data.

```luau
Z.TRIM_STRINGS: boolean

- If `true`, strings exceeding the max length for their type (`str8`, `str16`, `str32`) will be truncated when serialized instead of causing an error. (Default: `false`)

## Supported Data Types

| ZType                             | Description                                | Size (bytes)                |
| :-------------------------------- | :----------------------------------------- | :-------------------------- |
| **Primitives**                    |                                            |                             |
| `Z.bool`                          | Boolean                                    | 1                           |
| `Z.bools`                         | Bit-packed list of up to 8 booleans        | 1                           |
| `Z.u8` / `Z.i8`                   | (Un)signed 8-bit integer                   | 1                           |
| `Z.u16` / `Z.i16`                 | (Un)signed 16-bit integer                  | 2                           |
| `Z.u32` / `Z.i32`                 | (Un)signed 32-bit integer                  | 4                           |
| `Z.f32` / `Z.f64`                 | 32/64-bit float                            | 4 / 8                       |
| **Variable-Length**               |                                            |                             |
| `Z.uint`                          | Unsigned LEB128 integer                    | 1-8                         |
| `Z.int`                           | Signed LEB128 integer                      | 1-8                         |
| **Strings / Buffers**             |                                            |                             |
| `Z.byte`                          | Single byte (as 1-char string)             | 1                           |
| `Z.str8/16/32`                    | String (max length 2^8/16/32 - 1)          | 1/2/4 + N                   |
| `Z.buffer8/16/32`                 | Buffer (max length 2^8/16/32 - 1)          | 1/2/4 + N                   |
| **Tables**                        |                                            |                             |
| `Z.table`                         | Naive table (inefficient)                  | ?                           |
| `Z.schema8/16/32 {ZType}`         | List ZType (max items 2^8/16/32 - 1)       | 1/2/4 + N ZType             |
| `Z.schema8/16/32 {[ZType]=ZType}` | Map ZType (max items 2^8/16/32 - 1)        | 1/2/4 + N (ZTypeK + ZTypeV) |
| **Roblox Data Types**             |                                            |                             |
| `Z.Angle8`                        | Lossy rotation (maps `2*pi` to 255 values) | 1                           |
| `Z.Axes`                          | `Axes`                                     | 2                           |
| `Z.BrickColor`                    | `BrickColor`                               | 2                           |
| `Z.CFrame`                        | Full `CFrame` (12x `f32`)                  | 48                          |
| `Z.CFrame28`                      | Lossy `CFrame` (Pos + 4x `f32` Orient)     | 28                          |
| `Z.CFrame15`                      | Lossy `CFrame` (Pos + 3x `Angle8` Orient)  | 15                          |
| `Z.Color3`                        | `Color3` (3x `u8`)                         | 3                           |
| `Z.ColorSequence`                 | `ColorSequence`                            | 1 + 4N points               |
| `Z.ColorSequenceKeypoint`         | `ColorSequenceKeypoint`                    | 4                           |
| `Z.DateTime`                      | `DateTime`                                 | 8                           |
| `Z.EnumItem`                      | `EnumItem` (inefficient)                   | 2-5 + #EnumType             |
| `Z.EnumItem(enum)`                | `EnumItem` (optimized)                     | 1-4                         |
| `Z.Faces`                         | `Faces`                                    | 1                           |
| `Z.FloatCurveKey`                 | `FloatCurveKey`                            | 12-19                       |
| `Z.Font`                          | `Font`                                     | 2-257                       |
| `Z.NumberRange`                   | `NumberRange` (2x `f64`)                   | 16                          |
| `Z.NumberSequence`                | `NumberSequence`                           | 1 + 12N points              |
| `Z.NumberSequenceKeypoint`        | `NumberSequenceKeypoint`                   | 12                          |
| `Z.Path2DControlPoint`            | `Path2DControlPoint` (3x `some(UDim2)`)    | 3-51                        |
| `Z.PathWaypoint`                  | `PathWaypoint`                             | 14-269                      |
| `Z.PhysicalProperties`            | `PhysicalProperties` (5x `f32`)            | 20                          |
| `Z.Ray`                           | `Ray` (2x `Vector3`)                       | 24                          |
| `Z.Rect`                          | `Rect` (2x `Vector2`)                      | 16                          |
| `Z.Region3`                       | `Region3` (2x `Vector3`)                   | 24                          |
| `Z.Region3int16`                  | `Region3int16` (2x `Vector3i16`)           | 12                          |
| `Z.RotationCurveKey`              | `RotationCurveKey`                         | 55-63                       |
| `Z.TweenInfo`                     | `TweenInfo`                                | 13                          |
| `Z.UDim`                          | `UDim` (2x `f32`)                          | 8                           |
| `Z.UDim2`                         | `UDim2` (4x `f32`)                         | 16                          |
| `Z.Vector2`                       | `Vector2` (2x `f32`)                       | 8                           |
| `Z.Vector2i16`                    | `Vector2int16` (2x `i16`)                  | 4                           |
| `Z.Vector3`                       | `Vector3` (3x `f32`)                       | 12                          |
| `Z.Vector3i16`                    | `Vector3int16` (3x `i16`)                  | 6                           |

## License

This project is available under the [MIT License](LICENSE.md).


[codify-devforum]: https://devforum.roblox.com/t/473076
[codify-itch]: https://cxmeel.itch.io/codify

# CodifyLib

A decoupled implementation of the [Codify plugin][codify-devforum]'s internal "Instance-to-snippet" conversion module.

**Looking for the [Codify plugin][codify-devforum]?**

[![Purchase on Roblox](assets/roblox_dev-animated.svg)](https://create.roblox.com/store/asset/4749111907) [![Purchase on Itch.io](assets/itch.svg)][codify-itch]

[Codify][codify-devforum] converts Roblox Instances into code snippets in a flash. Whether you use vanilla Roblox Luau, [TypeScript JSX](https://roblox-ts.com/docs/guides/roact-jsx), or a framework like [React](https://github.com/jsdotlua/react-lua#readme)/[Roact](https://github.com/roblox/roact), [Fusion](https://github.com/dphfox/Fusion#readme), [Vide](https://github.com/centau/vide#readme) or [Rojo](https://rojo.space/docs/v7/sync-details/#json-models), Codify’s got you covered!

- [Learn more →][codify-devforum]

## Contributors

The following individuals have contributed to the development of CodifyLib:

- [@boatbomber](https://github.com/boatbomber) - Implemented original generators for Fusion and vanilla Roblox.
- [@PepeElToro41](https://github.com/PepeElToro41) - Implemented original JSX generator.

## Example Usage

```luau
local CodifyLib = require("path/to/CodifyLib")
local Generators = CodifyLib.Generators

-- Setup the React generator with a custom config
local react = Generators.React({
    indentation = "  ",
    createMethod = "e",
    names = "all",
})

-- Generate the snippet, targeting the Baseplate
-- with a custom config
local snippet = CodifyLib.codify(workspace.Baseplate, {
    generator = react,
    caseFormat = "camel", -- Render keys/variables in camelCase
    userFormats = {
        color3 = "hex", -- Render Color3 values as hex
    },
})

print("Snippet:", snippet)

## Generators

CodifyLib comes with a variety of generators to suit your needs:

### Roblox

> Generates vanilla Roblox Lua code (i.e. `Instance.new`).

```luau
type Config = {
    indentation: string?, -- default: "    "
    names: ("all" | "none" | "changed")?, -- default: "all"
}?

### Fusion

> Fusion is a reactive framework for Roblox Luau, created by [@dphfox](https://github.com/dphfox).\
> [Learn more →](https://github.com/dphfox/Fusion#readme)

```luau
type Config = {
    indentation: string?, -- default: "    "
    createMethod: string?, -- default: "scope:New"
    childrenKey: string?, -- default: "Children"
    names: ("all" | "none" | "changed")?, -- default: "all"

### React

> React for Roblox is a translation of React17 from JavaScript to Lua by [@roblox](https://github.com/roblox) and [@jsdotlua](https://github.com/jsdotlua).\
> [Learn more →](https://github.com/jsdotlua/react-lua)

```luau
type Config = {
    indentation: string?, -- default: "    "
    createMethod: string?, -- default: "React.createElement"
    names: ("all" | "none" | "changed")?,

### Jsx

> JSX allows HTML-like syntax to be used in TypeScript for Roblox. It is part of the roblox-ts project.\
> [Learn more →](https://roblox-ts.com/docs/guides/roact-jsx)

```luau
type Config = {
    indentation: string?, -- default: "    "
    names: ("all" | "none" | "changed")?, -- default: "all"
    lowercaseKeyProp: boolean?, -- default: false

## UserFormats

CodifyLib allows you to define the way datatypes are formatted in the resulting snippets. This can be useful for customizing the output to match your coding style.

The default for all values is `"full"`.

```luau
type UserFormats = {
    color3: "full" | "hex" | "hsv" | "rgb",
    udim2: "full",
    numberRange: "full",
    enum: "full" | "number" | "string",
    normalId: "full",
    brickColor: "full" | "number" | "rgb",
    physicalProperties: "full",
    udim: "full",
    cframe: "full",
    vector2: "full",
    vector3: "full",
    font: "full",
    colorSequence: "full",
    numberSequence: "full",

**Codify for Roblox Studio**\
[Purchase on Roblox](https://create.roblox.com/store/asset/4749111907) | [Purchase on Itch.io][codify-itch] | [Learn more][codify-devforum]


* [View all by cxmeelcxmeel](https://cxmeel.itch.io)
  * [Follow cxmeelFollowFollowing cxmeelFollowing](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=follow_user)
  * [Add To CollectionCollection](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=add_to_collection)
  * [Comments](https://cxmeel.itch.io/codify#comments)
  * [ More like thisRelated](https://itch.io/games-like/1401700/codify)

# Codify

A downloadable plugin

[Buy Now](https://cxmeel.itch.io/codify/purchase)$12.99 USD or more

[](https://create.roblox.com/marketplace/asset/4749111907) [](https://cxmeel.itch.io/codify/purchase)

Codify converts Instances into code in a flash! Whether you're converting UI or models, using a framework like React or Fusion, or even a completely different language, such as TypeScript or JSON, Codify's got you covered!

  * [Learn more on the DevForum â](https://devforum.roblox.com/t/codify-convert-anything-to-luau-typescript-fusion-react-vide-rojo/473076)

[More information](javascript:void\(0\))

Updated|  10 days ago
Status| [Released](https://itch.io/tools/released)
Category| [Tool](https://itch.io/tools)
Release date|  Feb 16, 2022
Rating| Rated 5.0 out of 5 stars(2 total ratings)
Author| [cxmeel](https://cxmeel.itch.io)
Tags| [codify](https://itch.io/tools/tag-codify), [fusion](https://itch.io/tools/tag-fusion), [javascript](https://itch.io/tools/tag-javascript), [roact](https://itch.io/tools/tag-roact), [roactify](https://itch.io/tools/tag-roactify), [roblox](https://itch.io/tools/tag-roblox), [roblox-plugin](https://itch.io/tools/tag-roblox-plugin), [roblox-studio](https://itch.io/tools/tag-roblox-studio), [roblox-studio-plugin](https://itch.io/tools/tag-roblox-studio-plugin), [typescript](https://itch.io/tools/tag-typescript)
Code license| [MIT License](https://itch.io/tools/code-mit)
Links| [Source code](https://github.com/csqrl/codify-plugin), [Twitter/X](https://twitter.com/csqrI), [DevForum](https://devforum.roblox.com/t/473076)

## Purchase

[Buy Now](https://cxmeel.itch.io/codify/purchase)$12.99 USD or more

In order to download this plugin you must purchase it at or above the minimum price of $12.99 USD. You will get access to the following files:

**codify.rbxm** 508 kB

## Download demo

[Download](javascript:void\(0\);)

**codify-demo.rbxm** 240 kB

## Comments

[Log in with itch.io](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify) to leave a comment.

[](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community "Vote up") [](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community "Vote down")

[](https://itch.io/profile/chillisko)

[chillisko](https://itch.io/profile/chillisko)[3 days ago](https://itch.io/post/15755131)(+1)

Goated

[Reply](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community)

[](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community "Vote up") [](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community "Vote down")

[](https://itch.io/profile/itzzmateo)

[ItzzMateo](https://itch.io/profile/itzzmateo)[202 days ago](https://itch.io/post/14052124)(+1)

**Cool! :D**

[Reply](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2Fcodify&intent=community)

[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk2NS5wbmc=/original/h5SkCS.png)[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk2OC5wbmc=/original/ADfN7m.png)[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk3MC5wbmc=/original/RWaZWU.png)[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk3Mi5wbmc=/original/ywlJwQ.png)[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk3My5wbmc=/original/MLkQJ6.png)[](https://img.itch.zone/aW1hZ2UvMTQwMTcwMC8yMDQzMTk3NS5wbmc=/original/xJCDpR.png)

[](https://itch.io/)[itch.io](https://itch.io/)Â·[View all by cxmeel](https://cxmeel.itch.io)Â·[Report](javascript:void\(0\);)Â·[Embed](javascript:void\(0\);)Â·

Updated  10 days ago
  *[ 10 days ago]: 16 March 2026 @ 13:35 UTC
  *[ Feb 16, 2022]: 16 February 2022 @ 14:04 UTC


# [Codify](https://cxmeel.itch.io/codify)

Convert Instances to code; just like magic!

by [cxmeel](https://cxmeel.itch.io)


* [Follow cxmeel](https://itch.io/login?return_to=https%3A%2F%2Fcxmeel.itch.io%2F&intent=follow_user)

# cxmeel

[@cxmeel](https://twitter.com/cxmeel)

[](https://cxmeel.itch.io/resurface)

[Resurface](https://cxmeel.itch.io/resurface)

Convert surfaces to studs and more

[cxmeel](https://cxmeel.itch.io)

[](https://cxmeel.itch.io/codify)

[Codify](https://cxmeel.itch.io/codify)

$12.99

Convert Instances to code; just like magic!

[cxmeel](https://cxmeel.itch.io)

## [Recommended](https://itch.io/c/5070885/recommended)

[](https://elttob.itch.io/vanilla-3-for-roblox-studio)

[Vanilla 3 for RobloxÂ® Studio](https://elttob.itch.io/vanilla-3-for-roblox-studio)

The pragmatic icon set

[Studio Elttob](https://elttob.itch.io)

[](https://boatbomber.itch.io/benchmarker)

[Benchmarker](https://boatbomber.itch.io/benchmarker)

Test and compare performance of functions with graphs, flame charts, percentiles, controlled inputs, and much more!

[boatbomber](https://boatbomber.itch.io)

[](https://elttob.itch.io/reclass)

[Elttob Reclass](https://elttob.itch.io/reclass)

Flow between instance types.

[Studio Elttob](https://elttob.itch.io)

[](https://sleitnick.itch.io/datastore-editor)

[DataStore Editor](https://sleitnick.itch.io/datastore-editor)

Roblox DataStore Editor Plugin

[sleitnick](https://sleitnick.itch.io)

[](https://elttob.itch.io/relight)

[Elttob Relight](https://elttob.itch.io/relight)

Laser-fast lighting design.

[Studio Elttob](https://elttob.itch.io)

[itch.io](https://itch.io/)


* [View all by cxmeelcxmeel](https://cxmeel.itch.io)
  * [Follow cxmeelFollowFollowing cxmeelFollowing](https://itch.io/login?intent=follow_user&return_to=https%3A%2F%2Fcxmeel.itch.io%2Fresurface)
  * [Add To CollectionCollection](https://itch.io/login?intent=add_to_collection&return_to=https%3A%2F%2Fcxmeel.itch.io%2Fresurface)
  * [ Related gamesRelated](https://itch.io/games-like/2854924/resurface)

# Resurface

A downloadable plugin

[Download Now](https://cxmeel.itch.io/resurface/purchase)Name your own price

Resurface is available via the Roblox Creator Store. If you'd like to leave an optional donation, you can do so through Itch.io.

You will not receive anything extra for purchasing the plugin, and will be redirected to the Creator Store after your purchase.

If you would like to inspect the source of Resurface, it's available over on the official GitHub project page:

<https://github.com/cxmeel/resurface-plugin>

[More information](javascript:void\(0\))

Status| [In development](https://itch.io/misc/in-development)
Category| [Other](https://itch.io/misc)
Rating| Rated 4.0 out of 5 stars(1 total ratings)
Author| [cxmeel](https://cxmeel.itch.io)
Tags| [roblox](https://itch.io/misc/tag-roblox), [roblox-plugin](https://itch.io/misc/tag-roblox-plugin), [roblox-studio](https://itch.io/misc/tag-roblox-studio), [roblox-studio-plugin](https://itch.io/misc/tag-roblox-studio-plugin)
Links| [Creator Store](https://create.roblox.com/store/asset/5070921519/Resurface-Convert-surfaces-to-studs-and-more), [DevForum](https://devforum.roblox.com/t/surface-tool-resurface-bring-back-studs/1226536)

## Download

[Download Now](https://cxmeel.itch.io/resurface/purchase)Name your own price

Click download now to get access to the following files:

**from Roblox Creator Store**

External

[](https://img.itch.zone/aW1hZ2UvMjg1NDkyNC8xNzgwOTc0My5wbmc=/original/YRBG2Q.png)[](https://img.itch.zone/aW1hZ2UvMjg1NDkyNC8xNzgwOTc0NC5wbmc=/original/V7GT9M.png)

[](https://itch.io/)[itch.io](https://itch.io/)Â·[View all by cxmeel](https://cxmeel.itch.io)Â·[Report](javascript:void\(0\);)Â·[Embed](javascript:void\(0\);)


# [Resurface](https://cxmeel.itch.io/resurface)

Convert surfaces to studs and more

by [cxmeel](https://cxmeel.itch.io)


# MInstance (Minifyinstance)

MInstance is an open-source, high-performance, and lightweight Instance Serialization Module for Roblox Instances written in pure Luau. It has pretty much everything that you would need. Not only does it beat every other module in terms of serialization speed, but also in serialized data compression ratio. This has only been in development for 2 days, but already has all of the features you need, while not letting a single CPU cycle go to waste.

Roblox DevForum: [https://devforum.roblox.com/t/new-update-an-ultra-optimized-instance-serializer-that-can-serialize-40000-instances-and-compress-it-into-a-100k-character-string-in-only-04s/3818154](https://devforum.roblox.com/t/new-update-an-ultra-optimized-instance-serializer-that-can-serialize-40000-instances-and-compress-it-into-a-100k-character-string-in-only-04s/3818154)

## Performance (v1.1)

### Test \#1: [Crossroads-Classic-Map.rbxm](https://devforum.roblox.com/uploads/short-url/5IGRBlugw4mO45y3UYkvwoH8Xjo.rbxm) (32.0 KB) — 1,736 Instances

| | MInstance | RBLXSerialize | SerializationService |
| :--- | :--- | :--- | :--- |
| **Serialization Time** | `0.0198 seconds` | `0.1836 seconds` | `0.0051 seconds` 😨 |
| **Compression Time** | `0.0018 seconds` |  | |
| **Serialized data character count** | `127,105` (uncompressed) | `58,779` | `32,791` |
| **Compressed data character count** | `31,914` | `58,779` | |

### Test \#2: [Havoc-Map.rbxm](https://devforum.roblox.com/uploads/short-url/weN8KgfBGaUUu0vIakVj7gk9qwE.rbxm) (2.2 MB) — 30,064 Instances

| | MInstance | RBLXSerialize | SerializationService |
| :--- | :--- | :--- | :--- |
| **Serialization Time** | `0.3673 seconds` | ERROR | `0.0671 seconds` 😨 |
| **Compression Time** | `0.0305 seconds` | ERROR | |
| **Serialized data character count** | `2,690,101` (uncompressed) | ERROR | `2,331,507` |
| **Compressed data character count** | `628,698` | ERROR | |

### Test \#3: `Instance.new("Part")`

| | MInstance | RBLXSerialize | SerializationService |
| :--- | :--- | :--- | :--- |
| **Serialization Time** | `0.00002 seconds` | `0.0005 seconds` | `0.006 seconds` |
| **Compression Time** | `0.000003 seconds` | | |
| **Serialized data character count** | `43` (uncompressed) 🤮 | | `2,550` |
| **Compressed data character count** | `39` 🤮 | `4` | |

## Why use this module?

Here are a few reasons:

  - Supports majority of Roblox data types and can serialize most properties with no issues.
  - Extremely fast performance!
  - Supports properties with its value being set to reference to another Instance, achieving this without setting UUIDs. This allows properties such as `SelectionBox.Adornee` to perfectly work as long as it is referencing an Instance that is a descendant of the main Instance being deserialized.
  - Supports MeshParts, which some other serializers fail to serialize properly. This is optional and you have to manually enable it in `DeserializationSettings`. (LOADS SLOW due to requiring to fetch the assets from Roblox's APIs)
  - Serializes attributes.
  - Instead of relying on an API dump to get properties like all other serializers do, the module will be updated to use `ReflectionService:GetPropertiesOfClass()` the moment that it is enabled, which is more futureproof than relying on the API dump.
  - You have the option to encode serialized data into Base94, which allows you to store serialized data into `DataStore`.
  - And many more\!

## Usage

  - `Minstance.SerializeInstance(TargetInstance: Instance, SerializationSettings: {})` - Serializes an Instance.

  - `Minstance.DeserializeInstance(DeserializedData: string, DeserializationSettings: {})` - Decompresses or deserializes data passed into it. Please note that you have to explicitly specify if your data is compressed, if it is encoded in Base94, etc.

Settings format:
You can simply pass the Instance you want to serialize/deserialize without passing a dictionary containing the settings, and it will use the default settings. However, if you need a specific setting enabled, you will have to fill ALL of the setting inside the settings dictionary.

### SerializationSettings Format:

```lua
    --> Setting: ValueType = DefaultValue
    IncludeDescendants: boolean = true
    CompressSerializedData: boolean = true
    CompressionLevel: number = 8
    EncodeInBase94: boolean = false
    AnnoyingConsolePrints: boolean = false
    UseLegacySlowCompressor: boolean = false
    IncludeAttributes: boolean = true
    DisallowedProperties: {[string]: {[string]: any} } = nil

  * **IncludeDescendants:** Determines if the descendants of the Instance you are serializing will also be serialized.
  * **CompressSerializedData:** Determines if the serialized data will be compressed with zstd.
  * **CompressionLevel:** Determines the level of compression that will be used. The higher the level, the better the compression ratio is, but the slower it takes to compress. Lowest level is 1, while the highest is 22. Defaults to 8 if nothing is passed.
  * **EncodeInBase94:** Determines if the serialized data will be encoded in Base94, which is useful when you want to save serialized data into `DataStore`.
  * **AnnoyingConsolePrints:** If this is set to `true`, it will print in the console how long it took to serialize or deserialize data every single time you call `SerializeInstance` or `DeserializeInstance`.
  * **UseLegacySlowCompressor:** Determines if the serialized data should be compressed with the old and slow compressor ([https://devforum.roblox.com/t/string-compression-zlibdeflate/755687](https://devforum.roblox.com/t/string-compression-zlibdeflate/755687)) or use Roblox's natively compiled zstd compressor. This is absolutely NOT recommended unless the zstd compression breaks.
  * **IncludeAttributes:** Determines if attributes of the Instance(s) should also be serialized
  * **DisallowedProperties:** A dictionary containing the properties that you do not want to include in serialization. If there isn't any property that you want to exclude, simply leave this `nil`. But for example, if you want to do something like exclude property "BrickColor" of class "Part" and "MeshPart", you can pass the table below:

```lua
    ["Part"] = {
        ["BrickColor"] = true
    },
    ["MeshPart"] = {
        ["BrickColor"] = true

### DeserializationSettings Format:

```lua
    --> Setting: ValueType = DefaultValue
    IsDataCompressed: boolean = true
    IsBase94Encoded: boolean = false
    AnnoyingConsolePrints: boolean = false
    IsCompressedWithLegacyCompressor: boolean = false
    ProperlyDeserializeMeshParts: boolean = false
    ParentInstanceWhileDeserializing: Instance? = nil

  * **IsDataCompressed:** Pass `true` if your serialized data is compressed, aka if `CompressSerializedData` was set to `true` when you serialized your Instance.
  * **IsBase94Encoded:** Pass `true` if your serialized data is encoded in Base94, aka if `CompressSerializedData` was set to `true` when you serialized your Instance.
  * **AnnoyingConsolePrints:** If this is set to `true`, it will print in the console how long it took to serialize or deserialize data every single time you call `SerializeInstance` or `DeserializeInstance`.
  * **IsCompressedWithLegacyCompressor:** Pass `true` if your serialized data was compressed with the old and slow zlib compression algorithm, aka if `UseLegacySlowCompressor` was set to `true` when you serialized your Instance.
  * **ProperlyDeserializeMeshParts:** If this is set to `true`, MeshParts will be properly deserialized and loaded. However, this takes VERY LONG, due to needing to fetch the mesh asset from Roblox's APIs. This is NOT recommended to be enabled unless you really want to properly deserialize MeshParts.
  * **ParentInstanceWhileDeserializing:** If an Instance is passed to this, it will parent the main Instance you are deserializing to the Instance passed as `ParentInstanceWhileDeserializing` BEFORE it deserializes any of its children. Leave this `nil` if you do not need that.

### Example code usage:

```lua
local MInstance = require(path.to.Minstance)
local TargetInstanceToSerialize = workspace.Part

local SerializationSettings = {
    IncludeDescendants = true,
    CompressSerializedData = true,
    EncodeInBase94 = false,
    AnnoyingConsolePrints = true,
    UseLegacySlowCompressor = false,
    IncludeAttributes = true,
    DisallowedProperties = nil

local DeserializationSettings = {
    IsDataCompressed = true,
    IsBase94Encoded = false,
    AnnoyingConsolePrints = false,
    IsCompressedWithLegacyCompressor = false,
    ProperlyDeserializeMeshParts = false,
    ParentInstanceWhileDeserializing = nil

local Serialized = MInstance.SerializeInstance(TargetInstanceToSerialize, SerializationSettings)
local Deserialized = MInstance.DeserializeInstance(Serialized, DeserializationSettings)

print(Deserialized)


# ExpressivePrompts
Customizable UI to replace Roblox's default for ProximityPrompt instances.

This is a fork of an older proximity prompt system previously written with Fusion 0.2. Some changes that were made to this version include:
* Swapping from Fusion 0.2 to Seam, which has faster performance, scopability, and more
* A configuration dictionary, allowing you to change basic properties for animation and appearance easily
* A myriad of bug fixes and stability improvements
* Portability, making it a module instead of a script
* And more!

As of right now it has a similar structure behind-the-scenes as the previous script, but this module will be the one that gets updates, including updates to configuration, backend, and more.

You can install this from [Wally](https://wally.run/package/miagobble/expressive-prompts) or [releases](https://github.com/MiaGobble/ExpressivePrompts/releases).

**This module is a part of Praxis, a larger library of utilities and more. [Check Praxis out here](https://praxis.igottic.com/).**


# gravity-camera
Modifications to the standard roblox player module to allow custom up vectors and spinning in sync with base parts.

Adds the following functions to the CameraModule:

```luau
-- returns what the camera currently considers to be the up vector at any given moment
CameraModule:GetUpVector(): Vector3

-- returns what the camera currently considers to be the up cframe at any given moment
CameraModule:GetUpCFrame(): CFrame

-- sets the up cframe and target up vector
CameraModule:SetUpCFrame(upCFrame: CFrame)

-- by default this is Vector3.new(0, 1, 0)
CameraModule:GetTargetUpVector(): Vector3

CameraModule:SetTargetUpVector(target: Vector3)

CameraModule:GetSpinPart(): BasePart

-- matches the camera to spin with this part
-- for example, your camera spins with a merry go round
-- by default this is workspace.Terrain
CameraModule:SetSpinPart(part: BasePart)

CameraModule:GetTransitionRate(): number

-- defines how the camera up vector should smoothly interpolate between it's current value and the target
-- for example, instantaneous jumps would be 1
-- by default this is 0.15
CameraModule:SetTransitionRate(rate: number)


# AutoComplete+
Luau Roblox studio plugin designed to vastly improve the speed of scripting by allowing instant imports of services, modules & instances.


# simpoll

A light-weight, simple bidirectional long-polling library for Roblox.

# Table of Contents
- [simpoll](#simpoll)
- [Table of Contents](#table-of-contents)
- [What is simpoll?](#what-is-simpoll)
- [Examples](#examples)
  - [Roblox](#roblox)
  - [NPM](#npm)
- [Luau Documentation](#luau-documentation)
    - [`simpoll.new`](#simpollnew)
    - [`simpoll:connect`](#simpollconnect)
    - [`simpoll:send`](#simpollsend)
    - [`simpoll:get`](#simpollget)
    - [`simpoll:onMessage`](#simpollonmessage)
    - [`simpoll:destroy`](#simpolldestroy)
- [TypeScript Documentation](#typescript-documentation)
  - [Server](#server)
    - [``Server.subscribe``](#serversubscribe)
    - [``Server.registerHandler``](#serverregisterhandler)
    - [``Server.broadcast``](#serverbroadcast)
    - [``Server.connections``](#serverconnections)
    - [``Server.onConnection``](#serveronconnection)
    - [``Server.onDisconnect``](#serverondisconnect)
    - [``Server.listen``](#serverlisten)
    - [``Server.app``](#serverapp)
  - [Connection](#connection)
    - [``Connection.id``](#connectionid)
    - [``Connection.token``](#connectiontoken)
    - [``Connection.lastUpdated``](#connectionlastupdated)
    - [``Connection.queue``](#connectionqueue)
- [Changelog](#changelog)
- [License](#license)

# What is simpoll?

Simpoll is exactly what it's name suggests; a simple polling library designed for effective communication between a Node backend and a Roblox server, designed to be lightweight, extensible, and easy to use.

It features 2 main components:

-   A server that can be used to listen for incoming connections and send and receive messages, through long-polling and plain HTTP requests.
-   A client that can be used to connect to a server and poll for messages, while also being able to send messages to the server.

# Examples

## Roblox

1. Add the latest version of the [library via Wally](https://wally.run/package/virtualbutfake/simpoll) to your `wally.toml` file and install it through `wally install` or a comparable command.
2. To get started, use the following code:

```lua
local simpoll = require(path.to.simpoll)
local poll = simpoll.new("https://your.simpoll.server", "your_very_safe_secret_here")

if poll:connect() then
    poll:onMessage("topicClient", function(data)
        print(data)
    end)

    poll:send("topicServer", "Hello, world!")
end

## NPM

1. Install the package using npm:

```bash
npm install simpoll

2. To get started, use the following code:

```typescript
import { Server } from "simpoll";

const server = new Server("your_very_safe_secret_here");

server.subscribe("topicClient", (connection, data) => {
    console.log(`Received data from ${connection.id}: ${data}`);
});

// Any arguments that express.listen accepts can be passed here.
server.listen(3000, () => {
    console.log(`Server listening!`);
});

setInterval(() => {
    server.broadcast("topicServer", "Hello, world!");
}, 1000);

3. (optional) In order to see debug logs, set the log level as follows:

```typescript
import { Logger } from "simpoll";
Logger.transports[0].level = "debug";

# Luau Documentation

### `simpoll.new`

```luau
simpoll.new(server: string, secret: string, id: string?): simpoll

Creates a new simpoll client. The server URL should start with `http://` or `https://` and should be running a simpoll server. The ID is optional and defaults to the game's Job ID. It will be used to identify the connection on the server and should be unique. The secret is a shared secret between the client and server, used to verify requests coming from the client.

Note that this function does not return an actual `simpoll` object, but instead returns a `subConnection`, a wrapper class allowing us to have multiple connections on the same ID work seamlessly. This ensures that multiple packages can use simpoll without interfering with each other. If you call `subConnection:destroy`, all events **created by this class** will be disconnected. If all subconnections are destroyed, the main connection will be destroyed as well.

### `simpoll:connect`

```luau
simpoll:connect(retry: (boolean | number)?, overwrite: boolean?): boolean

Connects to the simpoll server. Returns whether the connection was successful. If this function succeeds, the client immediately starts polling for messages. If retry is set to `true`, the client will automatically attempt to reconnect if the connection is not successful. If retry is set to a number, the client tries that many times to reconnect before giving up (retries every 5 seconds). If overwrite is set to `true`, the client will overwrite the existing connection with this ID if one exists, transferring over the current queue and request callback.

If polling fails, the server immediately tries to reconnect using `overwrite` set to true. This will refresh the connection and ensure that the client is always connected.

### `simpoll:send`

```luau
simpoll:send(topic: string, data: string | json, retry: boolean?): boolean

Sends a message to the simpoll server with the given topic. Returns whether the message was sent successfully. If `retry` is true, Simpoll keeps retrying every 5 seconds until a successful request occurs.

### `simpoll:get`

```luau
simpoll:get(topic: string, data: string | json, retry: boolean?): boolean

Tries to get data from a server route (goes into callbacks defined with `registerHandler`). Returns the value the server returned.. If `retry` is true, Simpoll keeps retrying every 5 seconds until a successful request occurs.

### `simpoll:onMessage`

```luau
simpoll:onMessage(topic: string, callback: (data: json | string) -> ()): signal.Connection

Sets a callback to be called when a message is received from the simpoll server with the given topic. The callback should take a single argument, which is the data received from the server.

### `simpoll:destroy`

```luau
simpoll:destroy()

Destroys the simpoll server. This function should be called when the entire poller is no longer needed. While it is technically reversible by calling `simpoll:connect` again, this is not recommended. Under the hood, this function disconnects all events and disconnects from the server.

# TypeScript Documentation

## Server

A server can be constructed using the `Server` class. The server can be used to listen for incoming connections and send and receive messages. The server can be constructed using the following code:

```typescript
import { Server } from "simpoll";

const server = new Server("your_very_safe_secret_here", "an_optional_api_path");

API path is optional and defaults to `/`.

### ``Server.subscribe``

```typescript
server.subscribe(topic: string, callback: (connection: Connection, data: any) => void)

Subscribes to a topic. The callback will be called when a message is received from the client. The callback should take two arguments: the connection ID and the data received from the client.

### ``Server.registerHandler``

```typescript
server.registerHandler(topic: string, (connection: Connection, data: any) => any)

Register a handler for `get` requests from the client. Sent data is converted to JSON and will be deserialized automatically on the client.

### ``Server.broadcast``

```typescript
server.broadcast(topic: string, data: any)

Broadcasts a message to all connected clients, with the given topic.

### ``Server.connections``

```typescript
server.connections(): Connection[]

Returns all currently connected clients.

### ``Server.onConnection``

```typescript
server.onConnection(callback: (connection: Connection, overwroteExisting: boolean) => void): void

Sets a callback to be called when a new connection is established. The callback should take two arguments: the connection object and a boolean indicating whether the connection overwrote an existing connection.

### ``Server.onDisconnect``

```typescript
server.onDisconnect(callback: (connection: Connection) => void): void

Sets a callback to be called when a connection is disconnected. The callback should take one argument: the connection object.

### ``Server.listen``

```typescript
server.listen(...args: any[]): void

Starts the server. Any arguments that `express.listen` accepts can be passed here. A list of possible arguments can be found [here](https://expressjs.com/en/4x/api.html#app.listen).

### ``Server.app``

This is the underlying Express app that the server is using. You can use this to add middleware.

## Connection

A connection object represents a connection to a client.

### ``Connection.id``

```typescript
connection.id: string

The ID of the connection.

### ``Connection.token``

```typescript
connection.token: string

The token used to validate the connection.

### ``Connection.lastUpdated``

```typescript
connection.lastUpdated: Date

The last time the connection was updated. This is internally used to determine if a connection has timed out and should be removed. This should not be modified.

### ``Connection.queue``

```typescript
connection.queue(topic: string, payload: string): void

Adds data to the connection's queue. This data will be sent to the client immediately if the client is currently polling, and will otherwise be sent when the client next polls.

# Changelog

The changelog can be found [here](CHANGELOG.md).

# License

This project is licensed under the MIT License - see the [LICENSE.md](https://github.com/virtualbutfake/fusion-autocomplete/blob/master/LICENSE.md) file for details.


# Packet+

An improved version of the Packet networking library.

# ✨ It’s just better!
This modified version of Packet offers simplified packet definitions and packet safety (early packets are still received). Additionally, it brings minor improvements regarding error messages and optimization.

# 🛠 Setup and use it!
First and foremost, [learn the original Packet library](https://www.youtube.com/watch?v=WoIElUdj64A&ab_channel=SuphiKaner).

Then, for Packet+, you need to setup a signal library.
Signal+ is recommended because it’s the best.
Make sure to tag the module `Signal`.

The API is mostly identical to the original library, but there is a key difference, seen below:

## ❌ Packet:
Use a shared module:
```lua
local Packet = require(path.to.Packet)

return {
    MyPacket = Packet("MyPacket", Packet.String),
    MyCoolPacket = Packet("MyCoolPacket", Packet.Number)
Or put definitions in every script that uses the packets:
```lua
local Packet = require(path.to.Packet)

local myPacket = Packet("MyPacket", Packet.String)
local myCoolPacket = Packet("MyCoolPacket", Packet.Number)

## ✅ Packet+:
Use a shared module:
```lua
local Packet = require(path.to.Packet)

return {
    MyPacket = Packet(Packet.String),
    MyCoolPacket = Packet(Packet.Number)
Packet+ removes the name parameter, requiring packets to be defined in a shared module. The packet name is inferred from the table key, reducing repetition and keeping definitions centralized and efficient.


Boba is a general-purpose runtime typechecking library for Luau.

- Zero `gt.build` or `:: any` with proper Luau type-safety
- Deduplicate code by building Luau types and runtime types together
- Significantly smaller LOCs compared to GreenTea, t, and ty
- Choose between standalone Luau and Roblox flavored Boba
- Great DX with helpful errors and rbxts typings included

## License

[Zlib License.](./LICENSE.md)

## Usage

### Installation

> [!WARNING]
> Work is in progress for automating package managers. For now, copy in whatever
> packages you need into your codebase.

```sh
# luau
pesde install @wthrblx/boba
wally install @wthrblx/boba
# rbxts
npm install @rbxts/boba
pnpm install @rbxts/boba
bun install @rbxts/boba

### Types

Define types with Boba's various constructors. These types can be tested against
unknown objects:

```luau
local DamageAmount = Boba.Or(
    Boba.Number,
    Boba.Or(
        Boba.Literal("Lethal" :: "Lethal"),
        Boba.Nil
    )
)

Boba constructors are also exposed as methods on types, so you can easily chain
them for greater clarity:

```luau
local DamageAmount = Boba.String
    :Or(Boba.Literal("Lethal" :: "Lethal"))
    :Or(Boba.Nil)

To infer a static type, call `typeof()` on the type's `inner` property:

```luau
-- inferred as `number | "Lethal" | nil`!
-- (note that types for literals may be widened, this is a limitation with Luau)
export type DamageAmount = typeof(DamageAmount.inner)

Optionally, finish types by giving it a nickname:

```luau
local DamageAmount = Boba.String
    :Or(Boba.Literal("Lethal" :: "Lethal"))
    :Or(Boba.Nil)
    :Nickname("DamageAmount")

Now, `DamageAmount` will be printed as `DamageAmount` and not
`number | "Lethal" | nil`.

At runtime, `inner` references itself. This enables building struct types
while resolving the correct types:

```luau
local Turret = Boba.ExhaustiveStruct {
    cooldown = Boba.Number.inner,
    amount = DamageAmount.inner,

-- inferred as { cooldown: number, amount: number | "Lethal" | nil }!
export type Turret = typeof(Turret.inner)

> [!TIP]
> For TypeScript users, you can omit `.inner` for structs:
> ```ts
> const Turret = Boba.ExhaustiveStruct({
>     cooldown: Boba.Number,
>     amount: DamageAmount,
> })
> export type Turret = typeof Turret.inner
> // alternatively
> export type Turret = Boba.Infer<typeof Turret>
> // still infers { cooldown: number, amount: number | "Lethal" | undefined }!

### Validation

Use `check` to see if an unknown value matches the type, receiving an error
message otherwise:

```luau
local unknownData = {
    cooldown = 2,
    amount = "Deadly"

local isTurret, turretError = Turret:check(unknownData)
print(isTurret, turretError)

Boba will return precise, helpful errors:

expected { cooldown: number, amount: DamageAmount }
> value at key "amount" (string)
  expected DamageAmount
  > did not match any of: number | Lethal, nil
    expected nil
    > only nil is accepted, but got "Deadly" (string)
    expected number | Lethal
    > did not match any of: number, Lethal
      expected Lethal
      > only Lethal is accepted, but got "Deadly" (string)
      expected number
      > got "Deadly" (string)

If you're in a rush, you can assert values:

```luau
-- this will error if the input doesn't match the type.
local validatedData = Turret:assert(unknownData)

-- zero type errors!
print(validatedData.cooldown)

Congrats! You've learned all of what Boba offers.

You can read the documentation (SOON) for all the other trinkets that
Boba exposes.

## Roblox

### Installation

```sh
# luau
pesde install @wthrblx/boba-roblox
# rbxts
npm install @rbxts/boba-roblox
pnpm install @rbxts/boba-roblox
bun install @rbxts/boba-roblox

### Data Types

### Instances

## Compatibility

Compatibility is a work in progress, though the plan is to support both
t and GreenTea.


# ⚠ This is discontinued, please use **ReGui** instead!
# https://github.com/depthso/Dear-ReGui

  An ImGui library for Roblox that doesn't require a RenderStep connection.

  Perfect for beginners and performance.

## Screenshots

## Notices❗
- This UI library is in beta, please report any bugs by opening an issue
- Any feedback or suggestions would be great
- Please mention me when integrating this library **- depso.**

## Usage and documentation
For **documentation** and usage examples, please read the [**Wiki**](https://github.com/depthso/Roblox-ImGUI/wiki)

    Type

    Roblox Studio

If you would like to use this in Studio:
- Create a module script and paste the [library source code](/ImGui.lua)
- Download the [Prefabs UI](https://create.roblox.com/store/asset/18364667141/Depso-ImGui) and insert the ScreenGui it under the module script

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ImGui = require(ReplicatedStorage.ImGui)

    Exploit/Executor

Reference detections have been mitigated using **cloneref** which compatibility is checked, \
if support is not found, for example using this in _studio_, you are still able to use it.

```lua
local ImGui = loadstring(game:HttpGet('https://github.com/depthso/Roblox-ImGUI/raw/main/ImGui.lua'))()

## Forking this
If you would like to create your own version for whatever reason,
- Prefabs: [Prefabs](https://create.roblox.com/store/asset/76246418997296)
- - Make sure you change UIAssetId under the `ImGui` configuration inside of the source code
- Library: [Source code](/ImGui.lua)

## Demos/Usage examples
- The **demonstration window** can be found [here](/Demo%20window.lua)
- More usage examples can be found on the [Wiki](https://github.com/depthso/Roblox-ImGUI/wiki)


This repository was archived by the owner on Feb 20, 2025. It is now read-only.

[ depthso ](https://github.com/depthso) / ** [Roblox-ImGUI](https://github.com/depthso/Roblox-ImGUI) ** Public archive

  * [ Notifications ](https://github.com/login?return_to=%2Fdepthso%2FRoblox-ImGUI) You must be signed in to change notification settings
  * [ Fork 8 ](https://github.com/login?return_to=%2Fdepthso%2FRoblox-ImGUI)
  * [ Star  7 ](https://github.com/login?return_to=%2Fdepthso%2FRoblox-ImGUI)

[](https://github.com/depthso/Roblox-ImGUI)

main

[Branches](https://github.com/depthso/Roblox-ImGUI/branches)[Tags](https://github.com/depthso/Roblox-ImGUI/tags)

[](https://github.com/depthso/Roblox-ImGUI/branches)[](https://github.com/depthso/Roblox-ImGUI/tags)

Go to file

Code

Open more actions menu

## Folders and files

Name| Name| Last commit message| Last commit date
---|---|---|---
## Latest commit ## History[6 Commits](https://github.com/depthso/Roblox-ImGUI/commits/main/)[](https://github.com/depthso/Roblox-ImGUI/commits/main/)6 Commits
[docs](https://github.com/depthso/Roblox-ImGUI/tree/main/docs "docs")| [docs](https://github.com/depthso/Roblox-ImGUI/tree/main/docs "docs")|  |
[.gitattributes](https://github.com/depthso/Roblox-ImGUI/blob/main/.gitattributes ".gitattributes")| [.gitattributes](https://github.com/depthso/Roblox-ImGUI/blob/main/.gitattributes ".gitattributes")|  |
[Demo window.lua](https://github.com/depthso/Roblox-ImGUI/blob/main/Demo%20window.lua "Demo window.lua")| [Demo window.lua](https://github.com/depthso/Roblox-ImGUI/blob/main/Demo%20window.lua "Demo window.lua")|  |
[ImGui.lua](https://github.com/depthso/Roblox-ImGUI/blob/main/ImGui.lua "ImGui.lua")| [ImGui.lua](https://github.com/depthso/Roblox-ImGUI/blob/main/ImGui.lua "ImGui.lua")|  |
[LICENSE](https://github.com/depthso/Roblox-ImGUI/blob/main/LICENSE "LICENSE")| [LICENSE](https://github.com/depthso/Roblox-ImGUI/blob/main/LICENSE "LICENSE")|  |
[Prefabs.rbxm](https://github.com/depthso/Roblox-ImGUI/blob/main/Prefabs.rbxm "Prefabs.rbxm")| [Prefabs.rbxm](https://github.com/depthso/Roblox-ImGUI/blob/main/Prefabs.rbxm "Prefabs.rbxm")|  |
View all files

## Repository files navigation

# ⚠ This is discontinued, please use **ReGui** instead!

# <https://github.com/depthso/Dear-ReGui>

[](https://github.com/user-attachments/assets/b220b562-519f-4914-afbf-f32ebf56dc5c)

**An ImGui library for Roblox that doesn't require a RenderStep connection.**
Perfect for beginners and performance.

## Screenshots

[](https://github.com/user-attachments/assets/c050f9ba-f090-4738-90b7-b791b94133ec) |  [](https://github.com/user-attachments/assets/f7ea9cca-7e14-445e-83b0-2820dda7f70e)

## Notices❗

  * This UI library is in beta, please report any bugs by opening an issue
  * Any feedback or suggestions would be great
  * Please mention me when integrating this library **- depso.**

## Usage and documentation

For **documentation** and usage examples, please read the [**Wiki**](https://github.com/depthso/Roblox-ImGUI/wiki)

Type
Roblox Studio |  If you would like to use this in Studio:

  * Create a module script and paste the [library source code](https://github.com/depthso/Roblox-ImGUI/blob/main/ImGui.lua)
  * Download the [Prefabs UI](https://create.roblox.com/store/asset/18364667141/Depso-ImGui) and insert the ScreenGui it under the module script

    local ReplicatedStorage = game:GetService("ReplicatedStorage")
    local ImGui = require(ReplicatedStorage.ImGui)

Exploit/Executor |  Reference detections have been mitigated using **cloneref** which compatibility is checked,
if support is not found, for example using this in _studio_ , you are still able to use it.

    local ImGui = loadstring(game:HttpGet('https://github.com/depthso/Roblox-ImGUI/raw/main/ImGui.lua'))()

## Forking this

If you would like to create your own version for whatever reason,

  * Prefabs: [Prefabs](https://create.roblox.com/store/asset/76246418997296)
  *     * Make sure you change UIAssetId under the `ImGui` configuration inside of the source code
  * Library: [Source code](https://github.com/depthso/Roblox-ImGUI/blob/main/ImGui.lua)

## Demos/Usage examples

  * The **demonstration window** can be found [here](https://github.com/depthso/Roblox-ImGUI/blob/main/Demo%20window.lua)
  * More usage examples can be found on the [Wiki](https://github.com/depthso/Roblox-ImGUI/wiki)

## About

This is a repo of the original Roblox-ImGUI to prevent scripts breaking. Please use ReGui instead

[github.com/depthso/Dear-ReGui](https://github.com/depthso/Dear-ReGui "https://github.com/depthso/Dear-ReGui")

### Topics

[ lua ](https://github.com/topics/lua "Topic: lua") [ roblox ](https://github.com/topics/roblox "Topic: roblox") [ imgui ](https://github.com/topics/imgui "Topic: imgui") [ luau ](https://github.com/topics/luau "Topic: luau") [ roblox-ui-lib ](https://github.com/topics/roblox-ui-lib "Topic: roblox-ui-lib") [ depso ](https://github.com/topics/depso "Topic: depso")

### Resources

Readme

### License

MIT license

### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/depthso/Roblox-ImGUI).

[ Activity](https://github.com/depthso/Roblox-ImGUI/activity)

### Stars

[ **7** stars](https://github.com/depthso/Roblox-ImGUI/stargazers)

### Watchers

[ **1** watching](https://github.com/depthso/Roblox-ImGUI/watchers)

### Forks

[ **8** forks](https://github.com/depthso/Roblox-ImGUI/forks)

[ Report repository ](https://github.com/contact/report-content?content_url=https%3A%2F%2Fgithub.com%2Fdepthso%2FRoblox-ImGUI&report=depthso+%28user%29)

## [Contributors 1](https://github.com/depthso/Roblox-ImGUI/graphs/contributors)

  * [ ](https://github.com/depthso) [ **depthso** Depso ](https://github.com/depthso)

## Languages

  * [ Luau 100.0% ](https://github.com/depthso/Roblox-ImGUI/search?l=luau)


# About

BinaryOctree is an optimized octree that is both memory effiecent and cpu effiecent.

**Note** The module has no update function for dynamic objects as the updating was slower than just recreating a new octree per frame.

# Performance

**All the benchmarks shown use 1000 objects**

Octree updating.
![image](https://github.com/user-attachments/assets/5696fb01-e564-4306-92fb-e120682807f4)

Octree querying.
![image](https://github.com/user-attachments/assets/35280f13-0c03-4f23-84f5-68528062539d)

**Note** The old octree module is a previous version of BinaryOctree before any optimizations.

Link to sleitnicks octree module:
https://github.com/Sleitnick/rbxts-octo-tree

# API

```lua
BinaryOctreeModule.new(Size : number, MaxDepth : number?,OffsetPosition : Vector3?) : BinaryOctree

Takes in a number for the size of the octree and an optional max subdivision depth (The top limit is 10 depth) and an optional OffsetPosition and returns the octree.

```lua
BinaryOctreeModule.InsertObjects(BinaryOctree : BinaryOctree,Objects : {Object})

Takes in a table of objects (anything with a Position value) and inserts them into the octree.

```lua
BinaryOctreeModule.RemoveObject(BinaryOctree : BinaryOctree,Object : Object)

Takes in an object and removes it from the octree.

```lua
BinaryOctreeModule.InsertObject(BinaryOctree : BinaryOctree,Object : Object)

Takes in an object and inserts it into the octree.

```lua
BinaryOctreeModule.QueryBox(BinaryOctree : BinaryOctree,Position : Vector3,Size : Vector3) : {Object}

Takes in the box's position and size and returns all the objects in the octree inside said box.

```lua
BinaryOctreeModule.QuerySphere(BinaryOctree : BinaryOctree,Position : Vector3,Radius : number) : {Object}

Takes in the sphere's position and radius and returns all the objects in the octree inside said sphere.

```lua
BinaryOctreeModule.VisualizeOctree(BinaryOctree : BinaryOctree)

Takes in an octree and visualizes it.


# roblox-ai-bypass-plugin
Very OP ai bypass plugin

in case theres any roblox staff reading this: FUCK YOU and your shitty ass marketplace that favorites hd admin, kohl and adonis any unpopular admin gets taken down hell even reuploading adonis gets your module banned fix your shitty marketplace and allow unpopular admins before you find me and sue me i don't like your favoritism towards popular admins thats why this plugin exists

info for linux users: do the same steps as below but first find your wine/proton/etc prefix directory and then search everything else yourself (it's not that hard)

info for mac users: do same steps but open studio press plugins and press on "plugins folder" then put [loader.lua](https://github.com/loadstring1/roblox-ai-bypass-plugin/raw/refs/heads/main/loader.lua) there

Steps to install:
1. Download [loader.lua](https://github.com/loadstring1/roblox-ai-bypass-plugin/raw/refs/heads/main/loader.lua)
2. Put [loader.lua](https://github.com/loadstring1/roblox-ai-bypass-plugin/raw/refs/heads/main/loader.lua) into %localappdata%\Roblox\Plugins\ directory
3. If your local plugins folder doesn't exist then just create it (it has to be case sensitive so create "Plugins" folder inside of Roblox folder)
4. Restart all studio instances if nothing showed up in plugins tab
5. Enjoy free AI bypass without having to update (it will auto update from the script on this github repo)


# Typebrick
A Type Function utility library for Roblox.

wally: https://wally.run/package/cameronpcampbell/typebrick

> [!TIP]
> Check out [Typeforge](https://github.com/typeforge-luau/typeforge), a type function utility library for Luau.

## Docs

### PropertiesOf(input: type) -> type
Returns a table of properties for the given Roblox instance.

```luau
type Result = PropertiesOf

type Result = {
    Anchored: boolean,
    ... *TRUNCATED*

### MethodsOf(input: type) -> type
Returns a table of methods for the given Roblox instance.

```luau
type Result = MethodsOf

type Result = {
    AddTag: (Instance, string) -> nil,
    ... *TRUNCATED*

### EventsOf(input: type) -> type
Returns a table of events for the given Roblox instance.

```luau
type Result = EventsOf

type Result = {
    AncestryChanged: {
        Connect: t1,
        ConnectParallel: (t2, (Instance, Instance?) -> ()) -> RBXScriptConnection,
        Once: (t2, (Instance, Instance?) -> ()) -> RBXScriptConnection,
        Wait: (t2) -> (Instance, Instance?)
    },
    ... *TRUNCATED*

### ChildrenOf(input: type) -> type
Returns a table of children for the given Roblox instance.

```luau
type Result = ChildrenOf<typeof(workspace.Part)>

type Result = {
    1: Attachment

### DescendantsOf(input: type) -> type
Returns a table of children for the given Roblox instance.

```luau
type Result = DescendantsOf<typeof(workspace)>

type Result = {
    1: Part,
    2: Camera,
    3: Terrain,
    4: Attachment


# Raycast Helper

A simple module for ray and shape casting with complex filtering.

Get it here:

* [Wally](https://wally.run/package/egomoose/raycast-helper)
* [Releases](https://github.com/EgoMoose/raycast-helper/releases)

## Raycast callbacks

Every cast function in the module allows for an optional "filter" argument. This function can be used to write custom filters for a specific cast in addition to the built in functionality from `Enum.RaycastFilterType`.

```Luau
local CollectionService = game:GetService("CollectionService")

local function exampleFilter(result: RaycastResult, cancel: () -> ())
    local hit = result.Instance :: BasePart

    if CollectionService:HasTag(hit, "castCancel") then
        -- at any point we can cancel the cast attempt which closes the thread and leaves the final result as nil
        cancel()
    end

    -- otherwise, return a boolean
    -- if true, we will accept this raycast result
    -- if false, we will not accept this raycast result and will add the instance and its descendants to the exclusion list
    return hit.CanCollide
end

## Example

In this example a ray is casted and only parts that have `Transparency == 0` are considered as valid candidates for the ray to hit.

```Luau
local function mustBeFullyVisible(result: RaycastResult)
    local hit = result.Instance :: BasePart
    return hit.Transparency == 0
end

local mouseRay = getMouseRay()
local result = RaycastHelper.raycast({
    origin = mouseRay.Origin,
    direction = mouseRay.Direction * 999,

    rayParams = RaycastHelper.rayParams({
        filterType = Enum.RaycastFilterType.Include,
        instances = {},
    })

    filter = mustBeFullyVisible,
})

## API

```Luau
export type FilterCallback = (RaycastResult, () -> ()) -> boolean

export type RaycastOptions = {
    worldRoot: WorldRoot?,
    rayParams: RaycastParams?,
    filter: FilterCallback?,

    origin: Vector3,
    direction: Vector3,

function RaycastHelper.raycast(options: RaycastOptions): RaycastResult?

export type BlockcastOptions = {
    worldRoot: WorldRoot?,
    rayParams: RaycastParams?,
    filter: FilterCallback?,

    cframe: CFrame,
    size: Vector3,
    direction: Vector3,

function RaycastHelper.blockcast(options: BlockcastOptions): RaycastResult?

export type SpherecastOptions = {
    worldRoot: WorldRoot?,
    rayParams: RaycastParams?,
    filter: FilterCallback?,

    origin: Vector3,
    radius: number,
    direction: Vector3,

function RaycastHelper.spherecast(options: SpherecastOptions): RaycastResult?

export type ShapecastOptions = {
    worldRoot: WorldRoot?,
    rayParams: RaycastParams?,
    filter: FilterCallback?,

    part: BasePart,
    cframe: CFrame?,
    direction: Vector3,

function RaycastHelper.shapecast(options: ShapecastOptions): RaycastResult?

export type RaycastParamOptions = {
    instances: { Instance }?,
    filterType: Enum.RaycastFilterType?,
    ignoreWater: boolean?,
    collisionGroup: string?,
    respectCanCollide: boolean?,
    bruteForceAllSlow: boolean?,

function RaycastHelper.params(options: RaycastParamOptions): RaycastParams