# Group

Fast iterator for viewing entities and components in a registry.

lua

    type ecr.Group<T...>

## Iteration

Iterates over all entities in the group.

  * **Type**

lua

        for id: Entity, ...: T... in Group<T...> do

  * **Details**

The entity followed by the component values are returned.

Components can be added, changed and removed during iteration. Components added during iteration are not returned for that iteration.

WARNING

During iteration, adding or removing components from entities not currently being iterated can invalidate the iterator.

## Length

Returns the amount of entities in the group.

  * **Type**

lua

        #Group<T...>: number


# View

Iterator for viewing entities and components in a registry.

lua

    type ecr.View<T...>

## Methods

### exclude()

Excludes entities with the given components from the view.

  * **Type**

lua

        function View:exclude<T...>(components: ...unknown): View<T...>

  * **Details**

Entities with _any_ of the excluded components, will not be returned during iteration.

### use()

Specifies a component to iterate along.

  * **Type**

lua

        function View:use<T...>(component: unknown): View<T...>

  * **Details**

Views, by default, iterate along the smallest pool within the given set of components. This function allows a specific pool to be iterated along instead.

## Iteration

Iterates all entities in the view.

  * **Type**

lua

        for id: Entity, ...: T... in View<T...> do

  * **Details**

The entity followed by the component values are returned.

Components can be added, changed and removed during iteration. Components added during iteration are not returned for that iteration.

WARNING

During iteration, adding or removing components from entities not currently being iterated can invalidate the iterator.

## Length

Returns the amount of entities in the view.

  * **Type**

lua

        #View<T...>: number

  * **Details**

For single component views, this returns the exact amount of entities in the view.

For multiple component views, this returns an estimated amount of entities. This estimate will not be less than the actual amount of entities.


# Observer

Tracks component changes, and can be cleared at will.

lua

    type ecr.Observer<T...>

## Methods

### exclude()

Excludes entities with the given components from the observer.

  * **Type**

lua

        function Observer:exclude<T...>(components: ...unknown): Observer<T...>

  * **Details**

Entities with _any_ of the excluded components, will not be returned during iteration.

### disconnect()

Disconnects the observer, stopping any new changes from being tracked

  * **Type**

lua

        function Observer:disconnect<T...>(): Observer<T...>

The observer must be empty before it is disconnected.

WARNING

This must be called for the observer to be garbage collected.

### reconnect()

Reconnects the Observer and allows it to track changes again.

  * **Type**

lua

        function Observer:reconnect<T...>(): Observer<T...>

### persist()

Stops automatic clearing of its entities after it is iterated.

  * **Type**

lua

        function Observer:persist<T...>(): Observer<T...>

### clear()

Clears all stored entities.

  * **Type**

lua

        function Observer:clear<T...>(): Observer<T...>

## Iteration

Iterates all entities in the observer.

  * **Type**

lua

        for id: Entity, ...: T... in Observer<T...> do

  * **Details**

The observer will return entities that had any of the given components added or changed since it was last cleared and still have all given components at the time of iteration.

The entity followed by the latest component values are returned.

Components can be added, changed and removed during iteration. Components added during iteration are not returned for that iteration.

Will automatically clear the observer unless `Observer:persist()` was called when iteration ends.

WARNING

Adding values during iteration can cause them to be cleared when iteration ends and they will never be iterated.

WARNING

During iteration, adding or removing components from entities not currently being iterated can invalidate the iterator.

## Length

Returns the amount of entities in the observer.

  * **Type**

lua

        #Observer<T...>: number


<source media="(prefers-color-scheme: dark)" srcset="/gh-assets/logo.svg"></source>
      <source media="(prefers-color-scheme: light)" srcset="/gh-assets/logo.svg"></source>

  Quick, customizable components for Fusion

## Quality components 🧩

Build quality UI faster with dozens of hand-crafted components. Everything is fully typed, so you can spend more time making UI instead of reading the docs.

##  Comprehensive theming 🎨

Style *all* components into the look and feel you desire with OnyxUI's dynamic theming system. Base values propagate into proportional scales, enforcing consistency with ease.

## Styling, now *not* stupid 🖌

Messy markup sucks. Style any component, with as little as half the code, using passthrough styling props. You can even create compound styles, like gradient strokes.

## [Documentation 📄](https://loneka.com/onyx-ui/)


### Quality components 🧩

Make quality UI faster with dozens of fully-typed components.

### Comprehensive theming 🎨

Give your UI the look and feel you desire with ease.

### Styling, now *not* stupid 🖌

Style any component, with less code, using passthrough styling props.


# Roblox Boilerplate

Consider this a project template of sorts? It's a bit scrappy and pulled together from pieces of the "engine" that I currently use to make games on Roblox.
I'm releasing this as a reference to hopefully help future Roblox developers see there's a much better way to have a game's architecture setup. It's inspired by Knit, but its also fully type-checked and compliant with Luau's `--!strict` typechecker.

Here be dragons. Best of luck if you sample from any material here.
Please do provide credit for anything I wrote here if you do though ;)

~ MaximumADHD


DataDelve is a graphical interface for Roblox’s DataStore API. When you need to interact with datastores in studio, you can use this plugin for a quick and easy experience.

For more info on DataDelve, see this: https://devforum.roblox.com/t/3067950.

Get it here: https://create.roblox.com/store/asset/18469510781/DataDelve-easy-free-datastore-editor

If you want the latest features, get the canary version:
 - https://create.roblox.com/store/asset/17652185888/DataDelve-Canary
 - https://github.com/pinehappi/DataDelve/releases/tag/canary.

# Contributing
You can contribute by creating issues for bugs or feature requests. You may also contribute code.

See the [architecture overview](./ARCHITECTURE.md) for an overview of how this plugin is structured and how to build it.

See the [contributing guide](./CONTRIBUTING.md) for more on how to contribute.

# Gallery

https://github.com/user-attachments/assets/02a70ebb-2200-4206-a410-272f6ee3b351


[stars]: https://github.com/latte-soft/wax/stargazers

[license]: https://github.com/latte-soft/wax/blob/master/LICENSE
[latest-release]: https://github.com/latte-soft/wax/releases/latest
[commits]: https://github.com/latte-soft/wax/commits
[discord]: https://latte.to/discord

[badges/stars]: https://img.shields.io/github/stars/latte-soft/wax?label=Stars&logo=GitHub

[badges/license]: https://img.shields.io/github/license/latte-soft/wax?label=License
[badges/latest-release]: https://img.shields.io/github/v/release/latte-soft/wax?label=Latest%20Release
[badges/last-modified]: https://img.shields.io/github/last-commit/latte-soft/wax?label=Last%20Modifed
[badges/discord]: https://img.shields.io/discord/892211155303538748?label=Latte%20Softworks%20Discord&color=5865F2

# Wax

[![Stars][badges/stars]][stars] [![License][badges/license]][license] [![Latest Release][badges/latest-release]][latest-release] [![Last Modified][badges/last-modified]][commits] [![Discord Server][badges/discord]][discord]

A Fast Runtime-Based Lua 5.1x+/Luau Project Bundler, Using Roblox Models and Module-Require Semantics

*Powered by [Lune](https://github.com/lune-org/lune), a standalone Luau script runtime*

## 🎉 About

Wax is an all-in-one bundler for projects in Lua 5.1x+ and [Luau](https://luau-lang.org), supporting and enforcing Roblox-like module require semantics (like using `require()` with a relative `script` global), and also normal `string` file paths like in generic Lua.

This is more of a successor to [Maui](https://github.com/latte-soft/maui), a similar, but much more limited and inherently flawed project for bundling Roblox projects, but **only** for running in Roblox. Wax, on the other hand, *bundles* completely outside of the Roblox engine, and generates code that can *run* outside it aswell. **Wax can 'bridge the gap' between traditional Lua projects and modern Roblox/Luau workflows, or anything in-between.**

### Features

*See [Usage](#🚀-usage) for more details on utilizing various features*

* Bundle directly from a [Rojo project](https://rojo.space/docs/v7/project-format) file (`*.project.json`), or just a generic Roblox model file. (`*.rbxm` or `*.rbxmx`) *For working directly with Rojo project files, you **must** have the `rojo` command in your $PATH*
* Created with **debugging in mind** from the start. *With output minification disabled*, even proper line info (matching to the original source files) can be shown in errors; for example, `[WaxRuntime].Script.OtherScript:1: intentional error`
* Built-in support for minifying bundled output directly with [Darklua](https://darklua.com) and either our default configuration (no extra steps), or your project's own `.darklua.json/json5` file for making personal tweaks.
* Localized/flattened modified globals in closures, meaning `getfenv`/`setfenv` aren't used to modify the script's environment - This also means that in Luau, `safeenv` runtime optimizations are maintained, and closures run 'natively' with no user modification!
* Automated CI/deployment pipeline usage in mind, with the `ci-mode` flag; no user confirmation prompts, and exits with a `1` status code upon any errors
* A 'virtual' Roblox-like DOM for scripts that can run completely outside of Roblox, while also allowing module imports (`require()`) with a simulated relative `script` global, or traditional filesystem path strings like in [Lune](https://github.com/lune-org/lune) or the Lua/Luau CLI REPLs.

Additionally, you can check out some example "projects" in our [tests](tests) directory if you don't really know what all of this is about, or how to get started..

## ⚙ Installation

For your project, you **must** have at least [Lune](https://github.com/lune-org/lune) installed, most easily done and managed with [Aftman](https://github.com/LPGhatguy/aftman):

1. Goto Aftman's GitHub repository (linked above), and follow its installation instructions for your platform
2. Open the root directory of your project in your system's terminal, and run the following:

aftman init
aftman add lune-org/lune

3. If you've setup Aftman properly, you can now try running `lune --help`, and if all is well you should see something similar to the following in your terminal:

$ lune --help
A standalone Luau runtime

Usage: lune [COMMAND]
...

### Add Wax to Your Lune Scripts

If you already have a "`lune`", "`.lune`", or similar directory in your project for these scripts, feel free to use it - for the sake of this example guide, I'm going to use "`lune`" as the example directory for Lune script(s).

1. If you haven't already, create a directory named "`lune`" in the root of your project
2. Inside of this newly created directory, create a file named "wax.luau", and paste in the following (or directly download `wax.luau` from the latest release on the [releases page](https://github.com/latte-soft/wax/releases))

*(DO NOTE: if you're using the 'remote' loader below, you won't be able to use Wax offline, and request times per running the script could be impractical for both speed and efficiency depending on your internet connection; consider manually installing `wax.luau` from the latest release on the releases page, linked above)*

```lua
    Wax - A Fast Runtime-Based Lua 5.1x+/Luau Project Bundler, Using Roblox Models and Module-Require Semantics
    MIT License | Copyright (c) 2023-2025 Latte Softworks <https://latte.to>

-- You set the following string to "latest" (case insensitive), or any version tag
-- on Wax's releases page (e.g. "0.4.2")
local WaxVersion = "latest"

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

local net = require("@lune/net")
local luau = require("@lune/luau")

local FileLink = if string.lower(WaxVersion) == "latest" then
    "https://github.com/latte-soft/wax/releases/latest/download/wax.luau"
else `https://github.com/latte-soft/wax/releases/download/{WaxVersion}/wax.luau`

luau.load(net.request(FileLink).body, {
    debugName = "Wax",
})()

3. Now, when running `lune run wax`, you should see something similar to what's in the next section ([Usage](#🚀-usage)) in your terminal. Voilà!

## 🚀 Usage

From your terminal in the root directory of your project, run `lune run wax`, or just `lune run `

Wax 0.4.2
A Fast Runtime-Based Lua 5.1x+/Luau Project Bundler, Using Roblox Models and Module-Require Semantics

USAGE:
    lune run wax [subcommand] [options]

* When no subcommand is provided, this usage message is displayed
* Provide all options in the following format (no "--" flag prefix): option=value

SUBCOMMANDS:
    help      Displays this usage message

    version   Displays Wax's version

    bundle    Builds a bundled script file from a given Roblox model (*.rbxm/*.rbxmx)
              or Rojo project file (*.project.json, requires the `rojo` command
              available in your PATH environment variable), to an output path

      OPTIONS for `bundle`:
      * input[="default.project.json"]
            The input Roblox model (*.rbxm/*.rbxmx) or Rojo project (*.project.json) file
            path for Wax to bundle from

      * output[="{input-filename}.lua"]
            The final output file path (must end in .lua or .luau) for the bundled script

      * minify[=false]
            If codegen output should be "minified", which also omits any runtime line
            debugging info (offsets). For 'full' codegen minification (outside of just
            LuaEncode's table output), you must have the `darklua` command available in
            your PATH environment variable.
            Additionally, with Darklua, if a ".darklua.json/json5" file isn't found in the
            CWD (your dir "position" in your terminal), it'll use the default configuration
            we provide (see `lune/lib/data/DefaultDarkluaConfig.luau`)

      * env-name[="WaxRuntime"]
            The name of the "environment" of the bundled script. This is the "name" of
            the root object (like the `game` DataModel in Roblox) and displays in virtual
            runtime errors (e.g. "[WaxRuntime].Script:1: Some error message")

      * darklua-config-path[=(".darklua.json", ".darklua.json5")]
            When `minify` is set as true, this path can be used to directly pass your own
            Darklua config file's path, instead of only checking for the default paths
            it looks for

      * temp-dir-base[="{output-dir}"]
            If you're providing a Rojo project file as input or minifying with Darklua,
            a temporary directory is created inside of this directory path, and is removed
            by the time Wax has completed processing

      * extra-offset-lines[=0]
            (Only applicable to when `minify` is set to false) Internally acknowledges
            any extra lines offset from the top of the script (like if you're adding a
            header of sorts to the codegen) for line debugging info. Ths MUST be exactly
            accurate to its name (*extra* lines, so you may want to do something like
            `#ExtraHeader - 1` if you're using this option)

      * ci-mode[=false]
            (*Primarily* for automated CI pipelines or deployment systems) Never gives
            any user input prompts, and will *always* exit with a `1` status code upon an
            'error' or warning during the build process

      * verbose[=true]
            "Verbose" (detailed) output logging from CLI/bundler

## Runtime Spec Details

* If there's only 1 instance directly under the model root and it's a `ModuleScript`, that module will automatically run at init and pass its return through the **real** script, just as expected with normal module behavior. Additionally, like a model on Roblox's [Developer Marketplace](https://create.roblox.com/marketplace/models), a `ModuleScript` under the model root named (exactly) "MainModule" will also have the same functionality, even if there is more than 1 instance directly under the model root

* The real `getfenv`/`setfenv` functions are not overriden by global flattening whatsoever, so by using for example `getfenv(0)` it will return the actual root function environment of the complete, bundled script. *Just know that its behavior isn't modified whatsoever for virtual closures!*

* Instance `ClassName`s that will bundle:
  * `Folder`
  * `Script`
  * `LocalScript`
  * `ModuleScript`
  * `StringValue`

* Implemented Instance 'properties' :
  * `Instance.ClassName: string`
  * `Instance.Name: string`
  * `Instance.Parent: Instance?`
  * `StringValue.Value: string`

* Implemented Instance 'methods':
  * `Instance:GetFullName(): string`
  * `Instance:GetChildren(): {Instance}`
  * `Instance:GetDescendants(): {Instance}`
  * `Instance:FindFirstChild(name: string, recursive: boolean?): Instance?`
  * `Instance:FindFirstAncestor(name: string): Instance?`
  * `Instance:WaitForChild(name: string, timeOut: number?)` *The actual behavior of the virtual `WaitForChild` impl is identical to `FindFirstChild`, but it needs to be implemented due to many codebases using it for relative module `require()` paths*

## Runtime API Reference

**All virtual closures have a special `wax` global for accessing AOT Wax build info, an isolated `shared` table, and 'real' globals Wax replaces.**

* `wax.version`

The version of Wax the current script was bundled with.

```lua
wax.version: string

* `wax.envname`

The string provided in the `env-name` option at build-time. ("`WaxRuntime`" by default)

```lua
wax.envname: string

* `wax.shared`

A table shared across all virtual closures in a bundled project, similar to the real `_G`/`shared` globals.

```lua
wax.shared: {[any]: any}

* `wax.script`

The real `script` global of the current script, (for with Roblox etc) as opposed to the virtual script ref override by Wax. If there isn't a real `script` global above Wax's environment anyway, this will be `nil`.

```lua
wax.script: LuaSourceContainer?

* `wax.require()`

The real `require()` function given by your Lua runtime as opposed to Wax's virtual override. (Lua, Luau (vanilla repl), Roblox Engine, Lune etc)

```lua
wax.require(...: any): ...any

## Build from Source

1. Clone the repository with `git`:

git clone https://github.com/latte-soft/wax.git
cd wax

2. With [Aftman](https://github.com/LPGhatguy/aftman) installed and configured:

*Accept any new tools for installation from the `y/n` prompts, or append `--no-trust-check` to the following command*

aftman install

3. Build with `lune` ([lune/make.luau](lune/make.luau)):

lune run make

If successful, the resulting bundled scripts will be output in the `build/` directory:

build
├── wax.dbg.luau
└── wax.luau

## 🏛 License

*See file: [LICENSE](LICENSE)*

MIT License

Copyright (c) 2023-2025 Latte Softworks <https://latte.to>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


## Latte Softworks

Organization & Community Focused Towards Software Development, Security Research, and Digital Infrastructure

We're both an organization & community, dedicated towards general development & discussion on software, security research, and digital infrastructure. As an organization, we develop and maintain various open-source projects, publish security write-ups, and constantly aim to do the impossible and raise the bar!

#### Social Links

[ ##### Discord Server Join our official Discord community server! ](https://latte.to/discord)

[ ##### GitHub Organization Our GitHub organization profile, hosting our public projects and write-ups. ](https://github.com/latte-soft)

[ ##### Twitter Account Our official Twitter account, where we post general announcements and info from time to time. ](https://twitter.com/lattesoftworks)

[ ##### Roblox Group Our official group on the Roblox platform. ](https://www.roblox.com/groups/10685936/Latte-Softworks)

#### Projects

[ ##### RDD  Locally download Windows/Mac Roblox deployments directly from your browser ](https://rdd.latte.to)

[ ##### Wax  Fast table serialization library for pure Luau/Lua 5.1+ ](https://github.com/latte-soft/wax)

[ ##### Commander SOON™ Administration System & Panel for Roblox _(Currently in Development)_ ](https://commander.run)

[ ##### Maui LEGACY _(Superseded by`Wax`)_ Roblox Studio plugin for packing Modules into executable Luau scripts ](https://github.com/latte-soft/maui)

#### Peoples

[ ##### Chad Hyatt ](https://hyatt.page)

[ ##### 0xJustus ](https://github.com/0xJustus)

[ ##### Jamarcus Sanchez ](https://www.roblox.com/users/4131569840/profile)


# Luau

Luau (lowercase _u_ , /ˈlu.aʊ/) is a small, fast, and embeddable programming language based on Lua with a gradual type system.

[ Get Started ](https://luau.org:443/getting-started/) [ News ](https://luau.org:443/news/) [ Try Luau online ](https://play.luau.org)

# Try Luau!

Section titled “Try Luau!”

# Why Luau?

Section titled “Why Luau?”

Performance

Luau is a high-performance managed language with a fast bytecode compiler and interpreter, and an optimized, incremental garbage collector. Its optional JIT compiler runs on x64 and arm64, and supports plugins that extend native code generation to any embedder-defined types.

Safety

Luau has a state-of-the-art gradual type system with features like [type refinements](https://luau.org:443/types/type-refinements) and [type functions](https://luau.org:443/types/type-functions). This system is powered by an ambitious and powerful type inference engine that aims to both rule out program errors, _and_ provide autocomplete with minimal annotations.

Accessibility

Luau is designed to be easy-to-learn, and easy-to-use over time. The syntax of the language is small and easy to pick up, and the semantics of the language should be broadly unsurprising to most programmers, with recursive functions, conventional loops and branching, and so forth.

Delightfulness

Luau aims to be pleasant and productive to use, and to make programming as fun as it can be! Besides the language itself, we’re building a full suite of developer tools: package management, linting, code transformation, documentation generation, and servers for editing and debugging code.

Embeddability

Luau, like Lua before it, is designed with embedding in mind. The language features an extended version of Lua’s C API with better support for coroutines and yielding, code coverage, and more performant, tagged userdata. We’ve also carefully sandboxed Luau, limiting the exposed API surface by default and enabling embedders to safely support executing untrusted code from their users.

Compatibility

Whenever possible, Luau aims to be backwards-compatible with Lua 5.1 and at the same time to incorporate features from later revisions of Lua. However, Luau is not a full superset of later versions of Lua - we do not always agree with Lua design decisions, and have different use cases and constraints. All post-5.1 Lua features, along with their support status in Luau, [are documented here](https://luau.org:443/compatibility).


# Embrace creativity, not chaos.

Used by 30M+ developers, Kohl's Admin is the most powerful, reliable, and trusted solution for Roblox experience management.

# ✨ Power Meets Simplicity

Everything you need to manage your game effectively.

- **Modern Interface:** A sleek, customizable user interface that fits perfectly with any game style. Choose from various themes or create your own with responsive design and intuitive controls.
- **Built-in Monetization:** Create your own products to sell roles and commands, or earn revenue from ours. Get up to 40% commission on every global VIP gamepass or hat sold in your game.
- **Global Charts:** Turn your admin system into a discovery engine and gain exposure from players exploring the ecosystem with free advertising and live rankings.
- **High Performance:** Optimized code ensures zero lag impact on your experience with fast execution.
- **Smart Autocomplete:** Never guess a command again. Our intelligent autocomplete system provides argument suggestions, error highlighting, and instant validation as you type.
- **Secure Architecture:** Flexible, role-based access control and anti-abuse protection keeps your game safe.
- **Effortless Setup:** Automatic updates mean you're always on the latest version with new features and fewer bugs.
- **Limitless Customization:** Extend functionality with community-made addons for infinite scalability and custom logic.

# 🙌 Contributing

We welcome and encourage contributions from the community! Check out our [Contributor Guidelines](CONTRIBUTING.md) to learn how you can get involved.

### 🙏 Recognition for Contributors

- **In-Game Credits:** Your name will be featured in the `credits` command within Kohl's Admin.
- **Inside Access:** Access to exclusive features, early previews, and private channels within the community.
- **Special In-Game Benefits:** Enjoy exclusive perks within participating experiences that use Kohl's Admin.
- **Monetary Compensation (For Exceptional Contributions):** We value your time and effort. See the [Contributor Guidelines](CONTRIBUTING.md#compensation) for details.

Thank you to all our contributors for helping make this project a success! ❤

# 💡 Ideas or Issues?

Found a bug? Have a feature request? Let us know by opening an issue:

# 📄 License

This project is licensed under the [MIT License](LICENSE.txt).


0 Developers

0 Experiences

0 Commands

0 Years

## Power Meets Simplicity

Everything you need to manage your game effectively.

### Modern Interface

A sleek, customizable user interface that fits perfectly with any game style. Choose from various themes or create your own.

  * Customizable Themes
  * Responsive Design
  * Intuitive Controls

### Built-in Monetization

Create your own products to sell roles and commands, or earn revenue from ours. Get up to 40% commission on every global VIP gamepass or hat sold in your game.

  * Earn up to 40% Commission
  * Global VIP Integration
  * Sell Custom Roles

### Global Charts

Turn your admin system into a discovery engine and gain exposure from players exploring the ecosystem.

  * Free Advertising
  * Live Rankings
  * New Players

[See Charts](https://www.roblox.com/join/f7tg3)

[](https://www.roblox.com/join/f7tg3)

### High Performance

Optimized code ensures zero lag impact on your experience.

  * Optimized Code
  * Fast Execution
  * Zero Lag

### Smart Autocomplete

Never guess a command again. Our intelligent autocomplete system validates commands instantly as you type.

  * Argument Suggestions
  * Error Highlighting
  * Instant Validation

;fly Players(s) Speed?

FLY <command>

Enables flight for one or more player(s).

fly

unfly

ff

### Secure Architecture

Flexible, role-based access control keeps your game safe from abuse.

  * Anti-Abuse Protection
  * Command Requests
  * Role-Based Access

;ban all

USER(s) <allPlayers>

The Player(s) or UserId(s) to ban.

Can't target yourself

### Effortless Setup

Automatic updates mean you're always on the latest version.

  * Always Secure
  * New Features
  * Less Bugs

> version

🛡 Running Kohl's Admin v0.11.5 by @Scripth

### Limitless Customization

Extend functionality with community-made addons.

  * Infinite Scalability
  * Easy Integration
  * Custom Logic

> install addon

✅ Successfully installed addon!

...and so much more

## Ready to Upgrade Your Game?

Join millions of developers using the most trusted admin system on Roblox.

[Get Kohl's Admin](https://create.roblox.com/store/asset/172732271)


# ⚡ Remo

Remo is a simple and type-safe remote library for Roblox.

It's easy to set up events and asynchronous functions that are ready for use.

## 🔥 Quick Start

Call `createRemotes` to initialize your remote objects.

Declare a remote by calling `remote`, or create a namespace by calling `namespace`.

```ts
// TypeScript
const remotes = createRemotes({
    // An event processed on the client
    event: remote<Client, [value: number]>(t.number),

    // A function whose value is processed by the server
    async: remote<Server, [value: number]>(t.number).returns<string>(t.string),

    // An event fired to a client, with logging
    logged: remote<Client, [value: number]>(t.number).middleware(loggerMiddleware),
});

remotes.event.connect((value) => print(value));

remotes.async.request(123).then((value) => print(value));

```lua
-- Luau
type Remotes = {
    -- An event processed on the client
    event: Remo.ServerToClient<number>,

    -- A function whose result, a string, is processed on the server
    async: Remo.ServerAsync<(number), (string)>,

    -- An event fired to a client, with logging
    logged: Remo.ServerToClient<number>,

local remotes: Remotes = Remo.createRemotes({
    event = Remo.remote(t.number),
    async = Remo.remote(t.number).returns(t.string),
    logged = Remo.remote(t.number).middleware(loggerMiddleware),
})

remotes.event:connect(print)

remotes.async:request(123):andThen(print)

## 📦 Installation

### Roblox-TS

[Take me to the NPM package →](https://www.npmjs.com/package/@rbxts/remo)

```bash
npm install @rbxts/remo
yarn add @rbxts/remo
pnpm add @rbxts/remo

### Wally

[Take me to the Wally package →](https://wally.run/package/littensy/remo)

```toml
[dependencies]
Remo = "littensy/remo@VERSION"

## ✨ Features

- 📚 Remote events and functions are fully type-checked and support Luau autocompletion.

- 🔐 Validate arguments and return values with [`t`](https://github.com/osyrisrblx/t).

- ⚛ Declare your remotes in one place and use them anywhere.

- 🛟 Safe to use in Hoarcekat or other environments outside of a running Roblox game.

## 📖 Usage

See the [examples](examples) folder for more detailed examples.

### 🔌 Creating remotes

`createRemotes` is used to create a set of remotes. It receives the remote schema, which is an object that maps remote names to their definitions created by `remote`:

- `remote<Mode, Args>(...validators?)` creates a remote event with the given argument types. If validators are provided, they will be used to validate the arguments passed to the event.

- `remote(...).returns<Result>(...validators?)` creates a remote function with the given argument and return types. If validators are provided, the return value will be validated before the promise is resolved.

- `namespace(schema)` creates a nested namespace of remotes.

```ts
// TypeScript
const remotes = createRemotes({
    event: remote<Client, [value: number]>(t.number),
    async: remote<Server, [value: number]>(t.number).returns<string>(t.string),
    namespace: namespace({
        event: remote<Client, [value: number]>(t.number),
        async: remote<Server, [value: number]>(t.number).returns<string>(t.string),
    }),
});

```lua
-- Luau
local remotes: Remotes = Remo.createRemotes({
    event = Remo.remote(t.number),
    async = Remo.remote(t.number).returns(t.string),
    namespace = Remo.namespace({
        event = Remo.remote(t.number),
        async = Remo.remote(t.number).returns(t.string),
    }),
})

### 🛟 Type safety

#### TypeScript

In TypeScript, [`t`](https://github.com/osyrisrblx/t) is recommended to ensure remotes can only be called with the correct arguments, but it is optional.

`remote` receives either a `Client` or `Server` flag that is used to specify whether the remote is processed by the client or the server.

```ts
const remotes = createRemotes({
    // event processed on the client and fired by the server
    client: remote<Client, [value: number]>(t.number),

    // event processed on the server and fired by the client
    server: remote<Server, [value: number]>(t.number),
});

#### Luau

In Luau, for full type-checking in your editor, you will need to define a separate type for your remotes using the following types:

- `ClientToServer`: A remote event that is fired by the client and processed by the server.

- `ServerToClient`: A remote event that is fired by the server and processed by the client.

- `ServerAsync`: A remote function that is invoked by the client and processed by the server.

- ~~`ClientAsync`~~: A remote function that is invoked by the server and processed by the client. Not recommended, as requesting values from the client is unsafe.

```lua
type Remotes = {
    client: Remo.ServerToClient<number>,
    server: Remo.ClientToServer<number>,
    serverAsync: Remo.ServerAsync<(number), (string)>,
    namespace: {
        client: Remo.ServerToClient<number>,
        server: Remo.ClientToServer<number>,

local remotes: Remotes = Remo.createRemotes({
    client = Remo.remote(t.number),
    server = Remo.remote(t.number),
    serverAsync = Remo.remote(t.number).returns(t.string),
    namespace = Remo.namespace({
        client = Remo.remote(t.number),
        server = Remo.remote(t.number),
    }),
})

Defining two-way remotes is not recommended in Luau, as it would require function overloads that may affect intellisense.

### 📡 Using remotes

#### 🟡 Events

`fire` is analogous to `FireServer` and `FireClient`. It sends the given arguments over the remote event to be processed on the other side.

```lua
-- client -> server
remotes.event:fire(...);

-- server -> client
remotes.event:fire(player, ...);
remotes.event:fireAll(...);
remotes.event:fireAllExcept(player, ...);
remotes.event:firePlayers(players, ...);

To listen for events, use `connect` to connect a callback to the remote event. If validators are provided, they must all pass before the listeners are called.

```lua
-- client -> server
local disconnect = remotes.event:connect(function(player, ...)
    print(player, ...)
end)

-- server -> client
local disconnect = remotes.event:connect(function(...)
    print(...)
end)

#### 🟣 Async functions

Similar to InvokeClient and InvokeServer, `request` is used to invoke a remote function. It sends the given arguments over the remote function to be processed on the other side, and returns a promise that resolves with the return value of the function.

Arguments are validated before the handler is called, and the return value is validated before the promise is resolved.

```lua
-- client -> server async
remotes.async:request(...):andThen(function(result)
    print(result)
end)

-- server -> client async
remotes.async:request(player, ...):andThen(function(result)
    print(result)
end)

To bind a handler to a remote function, use `onRequest`. If validators are provided, they must all pass before the handler is called.

The handler can return a value or a promise that resolves with a value. If the handler throws an error or the promise rejects, the caller will receive it as a promise rejection.

```lua
-- client -> server async
remotes.async:onRequest(function(player, ...)
    return result
end)

-- server -> client async
remotes.async:onRequest(function(...)
    return result
end)

Roblox-TS will automatically hide client- or server-only APIs based on whether you are using them on the client or on the server. However, this is not currently implemented in Luau, so take precautions to ensure you are calling `fire` or `connect` on the correct side.

### ⛓ Middleware

Middleware can be used to intercept and modify arguments and return values before they are processed. This can be used to implement features such as logging, rate limiting, or more complex validation.

#### 📦 Built-in middleware

- `loggerMiddleware` creates detailed logs of the arguments and return value of a remote invocation.

- `throttleMiddleware(options?)` prevents a remote from being invoked more than once every `throttle` seconds.
  - If `trailing` is true, the last event will be fired again after the throttle period has passed. Does not apply to async functions.
  - If an async remote is throttled, or it is not done processing the last request, the promise will resolve with the result of the last invocation. If there is no previous value available, the promise will reject.

#### 🧱 Creating middleware

Middleware is defined as a function that receives the next middleware in the chain and the remote it was called for. It returns a function that will be called when the remote is invoked, and depending on how it invokes the next middleware, it can modify the arguments and return value.

Here's an example middleware function that logs the arguments and return value of a remote:

```ts
// TypeScript
const loggerMiddleware: RemoteMiddleware = (nextFn, remote) => {
    return (...args: unknown[]) => {
        if (remote.type === "event") {
            print(`${remote.name} fired with arguments:`, ...args);
            return nextFn(...args);

        print(`${remote.name} called with arguments:`, ...args);

        const result = nextFn(...args);

        print(`${remote.name} returned:`, result);

        return result;
    };
};

```lua
-- Luau
local loggerMiddleware: Remo.Middleware = function(next, remote)
    return function(...)
        if remote.type == "event" then
            print(`{remote.name} fired with arguments:`, ...)
            return next(...)
        end

        print(`{remote.name} called with arguments:`, ...)

        local result = next(...)

        print(`{remote.name} returned:`, result)

        return result
    end
end

#### ⚙ Using middleware

Middleware may be applied to a single remote, or to all remotes.

```ts
// TypeScript
const remotes = createRemotes(
        event: remote<Client>(t.number).middleware(loggerMiddleware),
    },
    ...middleware,
);

```lua
-- Luau
local remotes = Remo.createRemotes({
    event = Remo.remote(t.number).middleware(loggerMiddleware),
}, ...middleware)

Note that middleware is applied in the order it is defined. Additionally, middleware applied to all remotes will be applied _after_ middleware applied to a single remote.

## 📚 API

### `createRemotes(schema)`

Creates a set of remotes from a schema.

```ts
function createRemotes(schema: RemoteSchema, ...middleware: RemoMiddleware[]): Remotes;

#### Parameters

- `schema` - An object whose keys are the names of the remotes, and whose values are the remote declarations.

- `...middleware` - An optional list of middleware to apply to all remotes.

#### Returns

`createRemotes` returns a Remotes object, which contains the remotes defined in the schema.

You can access your remotes through this object, and it also has a `destroy` method that can be used to destroy all of the remotes.

### `remote(...validators?)`

Declares a remote to be used in the remote schema.

```ts
function remote<Mode, Args>(...validators: Validator[]): RemoteBuilder;

#### Parameters

- `...validators` - A list of validators to call before processing the remote.

#### Returns

`remote` returns a RemoteBuilder, which can be used to define a remote. It has the following functions:

- `remote.returns(validator)` - Declares that this is an async remote that returns a value of the given type.

- `remote.middleware(...middleware)` - Applies the given middleware to this remote.

- `remote.unreliable()` - Marks this remote as an [unreliable remote event](https://devforum.roblox.com/t/introducing-unreliableremoteevents/2724155).

### `namespace(schema)`

Declares a namespace to be used in the remote schema.

```ts
function namespace(schema: RemoteSchema): RemoteNamespace;

#### Parameters

- `schema` - An object whose keys are the names of the remotes, and whose values are the remote declarations.

#### Returns

`namespace` returns a RemoteNamespace, which declares a namespace of remotes. It does not have a public API.

### `getSender(...)`

Returns the player that sent the remote invocation using the arguments passed to the remote. This checks whether the first argument is a table or an instance with a `ClassName` property equal to `"Player"`.

This is used for finding the `player` argument in a middleware function on the server.

```ts
function getSender(...args: unknown[]): Player | undefined;

#### Parameters

- `...args` - The arguments passed to the remote.

#### Returns

`getSender` returns the player that sent the remote invocation, or `undefined` if the remote was not invoked by a player.

### `loggerMiddleware`

Creates detailed logs of the arguments and return values of a remote invocation.

```ts
const loggerMiddleware: RemoMiddleware;

### `throttleMiddleware(options?)`

Prevents a remote from being invoked more than once every `throttle` seconds.

```ts
interface ThrottleMiddlewareOptions {
    throttle?: number;
    trailing?: boolean;

function throttleMiddleware(options?: ThrottleMiddlewareOptions): RemoMiddleware;

function throttleMiddleware(throttle?: number): RemoMiddleware;

#### Parameters

- `options` - An optional object with the following properties:
  - `throttle` - The number of seconds to throttle the remote for. Defaults to `0.1`.
  - `trailing` - If `true`, the last event will be fired again after the throttle period has passed. Does not apply to async functions. Defaults to `false`.

#### Returns

`throttleMiddleware` returns a middleware function that throttles the remote with the given options.

## 🪪 License

Remo is available under the MIT license. See the [LICENSE.md](LICENSE.md) file for more info.


Adonis is a community-maintained server moderation and management system created for use on the Roblox platform.

##  ✨ Installation

📢 **New to Adonis? Take a look at our [official quick start video](https://youtu.be/1f9x9gdxLjw) or read [the unofficial setup guide](https://devforum.roblox.com/t/1535122).**

If you get stuck, feel free to ask for assistance on our [Discord server](https://discord.gg/H5RvTP3).

### Method 1 (recommended): Official Roblox Model

1. [Take a copy](https://www.roblox.com/library/7510622625/) of the Adonis loader model from the Roblox Library.
2. Insert the model into Studio using the Toolbox, and place it under `ServerScriptService`. (Do not leave it in the `Workspace`!)

### Method 2: GitHub Releases

1. Download the `rbxm` file snapshot from the [latest release](https://github.com/Epix-Incorporated/Adonis/releases/latest).
2. Import the model file into Studio.

ℹ **Note:** By default, snapshots included in releases have [`DebugMode`](#debug-mode) enabled.

### Method 3: Filesystem

1. Download the repository to your computer's file system.
2. Install and use a plugin like [Rojo](https://rojo.space/) to compile Adonis into a `rbxmx` file.
    If using Rojo, you can run `rojo build /path/to/adonis -o Adonis.rbxmx` to build an `rbxmx`.
3. Import the compiled model file into Studio.

🔐 **Warning:** By default, loaders compiled from the repository have [`DebugMode`](#debug-mode) enabled.

**⚠ Method 3 compiles the *bleeding edge* version of Adonis, which may be not fully tested and is highly unstable.**

### ⚙ Configuring Adonis

Once you've inserted the Adonis loader into your game, open `Adonis_Loader` > `Config` > `Settings`, and change `settings.DataStoreKey` to something absolutely random (eg. `"2fgi02e)^Q"`). This is for security as it prevents serverside tampering with Adonis's datastores.

You may then edit the Settings module to configure Adonis to suit your game. Instructions and elaboration are provided within the Settings module.

### 🔧 Debug Mode

#### **PLEASE NOTE THAT THIS FEATURE IS INTENDED FOR DEVELOPMENT/DEBUGGING PURPOSES ONLY, PLEASE CHANGE `ModuleID` FOR CUSTOM MODULES**
The `DebugModule` feature enables a number of debug features, including but not limited to:

1. Not protecting the Adonis model (such as parenting it to nil)
2. Exposes a debugging API
3. Enables debugging commands for Creators

The Adonis loader provides a `DebugMode` option which will load a local copy of the `MainModule` rather than fetching the latest version. This could be useful if you are a contributor working on the `MainModule`. Debug mode expects the `MainModule` to share the same parent with the loader model (e.g. both should be in `ServerScriptService`). **By default, snapshots provided in releases have `DebugMode` enabled.**

#### Toggling debug mode

1. Open `Adonis_Loader` > `Loader` > `Loader`
2. Change `DebugMode` at the end of the `data` table to the desired value (e.g. `DebugMode = false`)

* Official Adonis Loader: <https://www.roblox.com/library/7510622625/Adonis-Admin-Loader-Epix-Incorporated>
* Official MainModule: <https://www.roblox.com/library/7510592873/Adonis-MainModule>
* Nightly MainModule: <https://www.roblox.com/library/8612978896/Nightlies-Adonis-MainModule>

### Reference

* 📄 Documentation: <https://github.com/Epix-Incorporated/Adonis/wiki>
* 📘 User Manual: <https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase>
* 📜 Contributing Guide: <https://github.com/Epix-Incorporated/Adonis/blob/master/CONTRIBUTING.md>

### Social

* Discord Server: <https://discord.gg/H5RvTP3> or <https://dvr.cx/discord>
* Roblox Group: <https://www.roblox.com/groups/886423>

### Misc

* Plugins Repository: <https://github.com/Epix-Incorporated/Adonis-Plugins>
* Donor Perks Pass: <https://www.roblox.com/game-pass/1348327>

## ⭐ Contributing

The purpose of this repository is to allow others to contribute and make improvements to Adonis. Even if you've never contributed to GitHub before, we would appreciate any contributions that you can provide.

### 📜 Contributing Guide

Read the [contributing guide](CONTRIBUTING.md) to get a better understanding of our development process and workflow, along with answers to common questions related to contributing to Adonis.

### ⚖ License

Adonis is available under the terms of [the MIT license](LICENSE.md).

### Thank you to our contributors

[![contributors](https://contributors-img.web.app/image?repo=Epix-Incorporated/Adonis)](https://github.com/Epix-Incorporated/Adonis/graphs/contributors)


## What is Adonis?

Adonis is a server moderation and management system created for the Roblox platform.

Uploaded to GitHub for collaboration and issue tracking.

## Adonis Loader

<https://www.roblox.com/library/7510622625/Adonis-Admin-Loader-Epix-Incorporated>

## Adonis MainModule (Source)

<https://www.roblox.com/library/7510592873/Adonis-MainModule>

## Documentation:

<https://github.com/Epix-Incorporated/Adonis/wiki>


[ Epix-Incorporated ](https://github.com/Epix-Incorporated) / ** [Adonis](https://github.com/Epix-Incorporated/Adonis) ** Public

  * ### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/Epix-Incorporated/Adonis/wiki).

  * [ Notifications ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis) You must be signed in to change notification settings
  * [ Fork 225 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)
  * [ Star  455 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)

# Home

Jump to bottom

Dimenpsyonal edited this page Sep 6, 2024 · [12 revisions](https://github.com/Epix-Incorporated/Adonis/wiki/Home/_history)

Adonis is a community-maintained server management and moderation system created by Sceleratis (Davey_Bones).

👉 Refer to the side panel for specific sections/information.

📘 **User Manual:** [https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)

Documentation is currently work-in-progress.

Documentation for the Adonis _G API can be found [here](https://github.com/Epix-Incorporated/Adonis/discussions/603).

## ⭐ Contributing

View the contribution guidelines and instructions [here](https://github.com/Epix-Incorporated/Adonis/blob/master/CONTRIBUTING.md) if you'd like to contribute to the Adonis project.

## 🔗 Links

  * Adonis Loader: <https://www.roblox.com/library/7510622625/Adonis-Loader>
  * Adonis MainModule: <https://www.roblox.com/library/7510592873/Adonis-MainModule>
  * Nightly MainModule: <https://www.roblox.com/library/8612978896/Nightlies-Adonis-MainModule>

Adonis Navigation Start  |  Guides  |  Tables
---|---|---
[Home](https://github.com/Epix-Incorporated/Adonis/wiki/Home) |  [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme) |  [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)

  * [Home](https://github.com/Epix-Incorporated/Adonis/wiki)
  * [User Manual & Feature Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)
  * [_G API](https://github.com/Epix-Incorporated/Adonis/wiki/G-API)
  * [Plugins and Modules](https://github.com/Epix-Incorporated/Adonis/wiki/Plugins-&-Modules)
  * [Structure](https://github.com/Epix-Incorporated/Adonis/wiki/Structure)

## Guides

  * [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme)

## Tables

  * [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)
  * [server.Admin](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Admin)
  * [server.Anti](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Anti)
  * [server.Commands](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Commands)
  * [server.Core](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core)
  * [server.Functions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Functions)
  * [server.HTTP](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.HTTP)
  * [server.Logs](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Logs)
  * [server.Process](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Process)
  * [server.Remote](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Remote)
  * [server.Variables](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Variables)

### Clone this wiki locally


[ Epix-Incorporated ](https://github.com/Epix-Incorporated) / ** [Adonis](https://github.com/Epix-Incorporated/Adonis) ** Public

  * ### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase).

  * [ Notifications ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis) You must be signed in to change notification settings
  * [ Fork 225 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)
  * [ Star  455 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)

# User Manual & Feature Showcase

Jump to bottom

Expertcoderz edited this page Sep 20, 2023 · [14 revisions](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase/_history)

# Contents

  1. [Command Usage Guide](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#section-1-command-usage-guide)
  2. [The "UserPanel" GUI](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#section-2-the-userpanel-gui)
  3. [UI Themes Showcase](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#section-3-ui-themes-showcase)
  4. [Moderation Commands Reference](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#section-4-moderation-commands-reference)
  5. [Adonis Features Showcase](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#section-4-adonis-features-showcase)

## ℹ **Notice**

**This manual is intended for regular users, moderators and admins in ROBLOX games using the Adonis admin system. For guidance on installing Adonis in your game as a developer, please refer to the [README](https://github.com/Sceleratis/Adonis/blob/master/README.md) file in the repository. For API documentation, navigate to the [other pages](https://github.com/Sceleratis/Adonis/wiki) on this wiki.**

# Section 1: Command Usage Guide

## Execution

These are the following ways by which an Adonis command can be executed by a user:

  * by chat (as long as chat commands have not been disabled)
  * by command console (default keybind for opening the console is `'`; the console may be restricted or disabled according to settings)
  * by other interfaces such as `:cmdbox`

In all cases, the prefix (which is `:` by default for admin commands and `!` by default for player commands) _must_ be included at the start of each command for it to work.

ℹ **Tip:** To run a command silently in the chat (so that other players do not see it), either prepend it with "/e " (eg. "/e :kill scel") or enable chat command hiding in your [client settings](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#client-settings).

## Player Selectors

Commands that take players as their argument (eg. `:kill`) will normally support either a singular player or a comma-separated list of player names.

**Example:** `:god scel` or `:kill noob1,noob2`

Note that player names are not case-sensitive and may be partial, eg. `scel` for `Sceleratis`.

In addition to simply using player names, the following special identifiers for targeting certain groups of players exist:

  * `me` \- yourself (the executor of the command)
  * `all` \- everyone in the server
  * `others` \- everyone in the server except yourself
  * `admins` \- all admins in the server
  * `nonadmins` \- everyone except admins in the server
  * `random` \- a random person in the server
  * `#NUM` \- random players in the server
  * `@USERNAME` \- targets a specific player whose username is exactly
  * `%TEAM` \- members of the team
  * `$GROUPID` \- members of the group with ID (number found in the Roblox group webpage URL)
  * `radius-NUM` \- anyone within a -stud radius of you

Placing `-` before any selector or player name will _invert_ the selection and select everyone except those within the selection defined after `-`. To illustrate, using the `others` selector is essentially the same as doing `all,-me`.

**Example:** `:explode -radius-10` \- explodes all players further than 10 studs from you.

## Batch Commands

Multiple commands can be ran sequentially at a time by separating them using the batch key, which defaults to `|` (vertical pipe).

Additionally, you can insert timed delays using `!wait <duration in seconds>`.

**Example:** `:ff me | :m Exploding everyone in 10 seconds! | !wait 10 | :explode all` \- gives you a forcefield and makes a message announcement, waits 10 seconds, then explodes everyone.

## Repetition

Admins/moderators by default have access to the `:repeat <times> <delay>` command, which easily allows a command to be ran in a loop.

**Example:** `:repeat 10 1 :sword me | :heal me` \- will give you a sword and heal yourself once every 1 second, for 10 times.

## Reference Commands

  * `:cmds` for a list of available commands
  * `:cmdinfo <command>` for detailed info about a specific command
  * `!brickcolors` for a list of valid BrickColors (can be used in some commands which take a brickcolor argument)
  * `!materials` for a list of material types
  * `:capes` for a list of preset capes available to admins
  * `:musiclist` for a list of preset audios
  * `:insertlist` for a list of assets that can be inserted using `:insert <name>` (set by the developer in `settings.InsertList`)

[Return to Top](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#contents)

# Section 2: The "UserPanel" GUI

The UserPanel GUI can be used to quickly access certain things in Adonis, such as commands, as well as configure Adonis client or server settings. This wiki page will go over the different tabs within Adonis's UserPanel GUI and what they do.

## Info

The info tab shows you information about Adonis, and gives the user convenient buttons to perform actions such as opening the command list, viewing the changelog, viewing credits, getting the loader, or getting the system's source in the form of its MainModule.

## Donate

This is where users can donate to Adonis's development and control settings related to their donator perks. These perks can be disabled by the place owner in the settings module of the Loader. Donation perks are intended to be purely visual and should not impact gameplay. When users donate in your game, Roblox will give the place owner 10% of the sale.

## Keybinds

The keybinds tab allows users to bind command strings to a specific key, so when they press that key the specified command gets executed.

## Aliases

Aliases allow you to create custom commands that point to existing commands, or a combination of existing commands. When creating an alias, you can add markers for command arguments. The order the argument identifiers appear in the command string is the order the arguments will be replaced in.

To better understand lets go through what's going on in the above screenshot: The command string `:kill <arg1> | :fire <arg1> <arg2>` is bound to `:killfire` The following happens when `:killfire scel Really red` is ran:

  1. In the command string, both substrings for `<arg1>` is replaced with `scel` and the substring `<arg2>` is replaced with `Really red`
  2. `:killfire scel Really red` is replaced by `:kill scel | :fire scel Really red`.
  3. The new command string gets processed like any other command. In this case we are running two commands at once, in other words a "batch" command as indicated by the `|` separating the two commands. The BatchKey setting can be used to change the `|` (vertical pipe) to whatever you'd like as long as it is not the same as the SplitKey or any of the Prefix settings.

It's important to note that the number of arguments is determined by the number of unique argument identifiers. Also, the actual text within the argument identifier is not important and is only used to match user-supplied arguments to where they should be. The order that these unique argument identifiers appear in the command string is what determines which which identifier will match argument 1, the next unique one found being argument 2, and so on. This is important to keep in mind. If you were to change the command string to `:kill <arg2> | :fire <arg2> <arg1>` and then chatted `:killfire scel Really red` `scel` would be assigned to `<arg2>` and `Really red` would be assigned to `<arg1>` so `:killfire Really red scel` would not work (as `:kill scel` would now be `:kill Really red`) It should also be noted that arguments that are intended to take spaces must appear last as otherwise portions of them may be treated as part of previous arguments when using the default SplitKey (a blank space.)

This system is currently still in development and may see improvements in the near future, such as manually defining in the alias string how arguments should be interpreted and matched to the command string. For now, you should not add argument indicators to the alias string. They should only be in the command string, and the order they appear is what currently determines the argument position they will be matched to in the chatted message.

## Client

You've likely noticed that the UserPanel GUI in the screenshots here does not look like the default UserPanel. This is because Adonis supports multiple themes, my personal favorite being the Rounded theme (the one seen in these screenshots.) The default theme is named "Default" and is used for all UI development, and determines the default GUIs and UI modules used in the event the selected theme does not have the GUI being generated.

Users can choose what theme they would like to use by clicking the text next to the arrow pointing down next to the "Theme" listing.

There are also a few other client-specific settings. It should be noted that these settings are user-specific and only affect the user's client. They are not game breaking and only seek to offer finer control over certain things if the user wishes to do so.

### Client Settings

Setting | Description
Keybinds | Enables/Disables keybinds (if disabled, keybinds will no longer work until re-enabled)
UI Keep Alive | Determines whether or not Adonis should attempt to prevent the deletion of its GUIs when the player respawns.
Particle Effects | Adonis contains a number of commands that involve particle effects, which for some users may be irritating or even performance-impacting. All particle effects are local to each client and as such can be toggled using this setting.
Capes | Like particle effects, capes (such as donor capes) are handled locally and can be disabled.
Hide Chat Commands | Whether Adonis commands that you run via the chat will automatically be hidden from other players.
Console Key | This is the key that will open/close the command console (the bar that appears when you press the Quote key by default).
Theme | Allows you to select the UI theme you want to use. Changing this to "Game Theme" will use whatever theme is set in the Adonis settings module (in the Loader). This is used by default for all new users.

## Game

This is where creators can control Adonis related server settings for their game while in-game instead of in studio. "Clear all saved settings" will clear any settings previously written to the datastore. This is especially useful if you encounter issues after changing a setting in-game or quickly want to revert to only what is set within the settings module. Anything with "Cannot change" next to it can only be changed in studio currently.

If you ever change the prefix in-game and suddenly find yourself unable to open settings to fix it, running `:adonissettings` will open the UserPanel GUI and focus the "Game" tab so you can fix any issues. The `:adonissettings` command will _always_ use `:` as a prefix so you can't accidentally change it to something unusable.

[Return to Top](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#contents)

# Section 3: UI Themes Showcase

The following are the themes that come with Adonis by default:

## Default

GUI | Screenshot
UserPanel |
HelpButton |
Console |
Notification |
Message |
Hint |
Error |

## Rounded

GUI | Screenshot
UserPanel |
Console |
Notification |
Error |

## Colorize

Note: rainbow effects are animated with chromatic interpolation.

GUI | Screenshot
UserPanel |
Console |
Notification |
Message |
Hint |
Error |

## BasicAdmin

This theme only changes the announcement GUIs.

GUI | Screenshot
Message |

## Aero

Made by [@Expertcoderz](https://github.com/Expertcoderz).

GUI | Screenshot
UserPanel |
HelpButton |
Console |
Notification |
Message |
Hint |
Error |

## Unity

Made by [@LolloDev5123](https://github.com/LolloDev5123).

GUI | Screenshot
UserPanel |
HelpButton |
Console |
Notification |
Message |
Error |

## Windows XP

Made by [@P3tray](https://github.com/P3tray).

GUI | Screenshot
UserPanel |
HelpButton |
Console |
Notification |
Message |
Hint |
Error |

[Return to Top](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#contents)

# Section 4: Moderation Commands Reference

This section serves as a basic reference guide for the essential moderation commands offered by Adonis.

## General

### `:kick <player> <reason>`

Disconnects the specified player from the server. If specified, the reason is shown to the player.

## Warning Players

### `:warnings <player>`

Displays the specified player's warning log.

### `:warn <player> <reason>`

Gives the specified player a warning, upon which they will be notified with the reason.

### `:kickwarn <player> <reason>`

Gives the specified player a warning and kicks them; displays the warning reason in their kick message.

### `:removewarning <player> <reason>`

Deletes the specified warning from the player's warning log.

### `:clearwarnings <player>`

Clears the player's warning log.

## Banning Players

### `:banlist`

Displays a list of normal bans.

### `:timebanlist`

Displays a list of time-banned users.

### `:trellobanlist/:sbl`

Displays a list of users banned via Trello; only applicable if Trello integration is configured.

### `:ban/:serverban <player> <reason>`

Bans the specified player from the current server. Note that they may still be able to join other servers.

### `:permban/:gameban <player> <reason>`

Bans the specified player from _all_ game servers, for an indefinite amount of time. Enforced immediately, so if the user is in a server other than where the command is run, they will be kicked by the system.

### `:tempban/:timeban <player> <duration (s/m/h/d)> <reason>`

Bans the specified player from _all_ game servers, for a specific amount of time. Enforced immediately.

**Example:** `:tempban Player1 3d` \-- globally-bans Player1 for 3 days.

### `:trelloban <player> <reason>`

Adds the specified player to the Trello ban list, if Trello integrations are configured for the game.

ℹ **Tip:** The above commands support full usernames for the `<player>` argument, which means you can ban specific users who are not currently in your server.

## Player Notes

### `:notes <player>`

Displays a list of notes on the specified player.

### `:note <player> <note>`

Sets a note on the specified player.

### `:removenote <player> <note>`

Removes a note from a specified player. Specify `all` for `<note>` to clear all notes on that player.

[Return to Top](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#contents)

# Section 5: Adonis Features Showcase

Here's a miscellaneous collection of some interesting features that many users of the Adonis admin system may not be aware of:

## 🚩 `:teams`

This is an interface that allows you to view, create, delete and join teams easily.

## 🛠 `:tools` \-- Inventory Monitor GUI

This utility allows you to view and manage players' backpacks via a user-friendly realtime inventory monitoring interface. An alternative to manually running the `:viewtools <player>`, `:removetool <player> <tool name>` and `:removetools <player>` commands.

## 📂 `:explorer`

This is a built-in alternative to `:dex` which allows you to view and navigate the game's file structure as well as delete objects.

## 📃 `:players`

Displays full a list of in-game players along with some live-updated info about the state of their characters; may be useful for moderators if your game has the regular player list GUI hidden.

## 🔍 `!profile <player>`

Displays quite comprehensive information about a specific player.

_Some details such as safechat status and the "Game" tab are hidden from non-admins for security reasons._

## ℹ `!serverinfo`

Displays information about the current server.

_Some details are hidden from non-admins for security reasons._

## 🕵 `:incognito <player>`

A powerful command that allows admins to hide themselves from other players in the server by vanishing from their player lists.

[Return to Top](https://github.com/Sceleratis/Adonis/wiki/User-Manual-&-Feature-Showcase#contents)

That's all, folks!

Notice anything wrong? Submit an issue [here](https://github.com/Sceleratis/Adonis/issues/new/choose) or discuss it in our official [Discord server](https://discord.com/invite/H5RvTP3).

Adonis Navigation Start  |  Guides  |  Tables
---|---|---
[Home](https://github.com/Epix-Incorporated/Adonis/wiki/Home) |  [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme) |  [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)

  * [Home](https://github.com/Epix-Incorporated/Adonis/wiki)
  * [User Manual & Feature Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)
  * [_G API](https://github.com/Epix-Incorporated/Adonis/wiki/G-API)
  * [Plugins and Modules](https://github.com/Epix-Incorporated/Adonis/wiki/Plugins-&-Modules)
  * [Structure](https://github.com/Epix-Incorporated/Adonis/wiki/Structure)

## Guides

  * [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme)

## Tables

  * [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)
  * [server.Admin](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Admin)
  * [server.Anti](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Anti)
  * [server.Commands](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Commands)
  * [server.Core](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core)
  * [server.Functions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Functions)
  * [server.HTTP](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.HTTP)
  * [server.Logs](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Logs)
  * [server.Process](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Process)
  * [server.Remote](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Remote)
  * [server.Variables](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Variables)

### Clone this wiki locally


[ Epix-Incorporated ](https://github.com/Epix-Incorporated) / ** [Adonis](https://github.com/Epix-Incorporated/Adonis) ** Public

  * ### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable).

  * [ Notifications ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis) You must be signed in to change notification settings
  * [ Fork 225 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)
  * [ Star  455 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)

# The "Service" Metatable

Jump to bottom

Dimenpsyonal edited this page Mar 11, 2024 · [12 revisions](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable/_history)

In Adonis, the "service" variable is a metatable provided by the Service core module containing many essential functions and variables used by both the server and client. The service table for the client is nearly identical to the service table for the server with the exception of a few variables added by either the client or server during loading.

If an index is requested from the service table (eg. service.Players) it will first check if it contains the requested index. If it does not contain the requested index, the it will query game:GetService(index) and return the result instead. This offers a slightly quicker alternative to typing game:GetService() when getting a Roblox service.

# Special Functions & Variables

The following is a list of functions and variables that can be found in the service metatable.

Note that ... implies user defined arguments that are not necessarily required to use a function or used directly by the function. This is almost always arguments to be passed to a user defined function.

Variables starting with * indicate an optional variable.

# service.EventService

The EventService table/object contains functions related to event and task handling. All members of the EventService object can be accessed as members of the service metatable.

## TrackTask(Name, Function, ...)

Creates a new Adonis-tracked "task" thread. If Name starts with "Thread:" Adonis will create the task as a coroutine, otherwise TrackTask will yield until function completion. TrackTask will pass ... as arguments to the specified task function and will return the result.

    --// Add existing players in case some are already in the server
    for _, player in service.Players:GetPlayers() do
        service.TrackTask("Thread: LoadPlayer "..tostring(player.Name), server.Core.LoadExistingPlayer, player);
    end

## EventTask(Name, Function)

Creates a special function that can be called by an event to spawn a new task each time the event fires.

    service.Players.PlayerAdded:Connect(service.EventTask("PlayerAdded", server.Process.PlayerAdded))

## GetTasks()

Returns a table containing currently tracked tasks.

## Events

Acts as a proxy to service.GetEvent(EventName) which will return a special event object for EventName.

The event object contains methods like :Connect(function), :Fire(...), and :Wait()

### :Connect(function)

Will attach a user specified function to the event. When :Fire(...) is called, the arguments passed to :Fire(...) will be passed to the attached function.

### :ConnectOnce(function)

Same as :Connect() except disconnects after firing once.

### :Fire(...)

Runs all functions attached to the event and passes ... to them.

### :Wait()

Waits for the event to fire once. Will return whatever arguments :Fire(...) sent. Yields.

### Adonis Events

Adonis has a number of custom events that can be used by plugins or Adonis itself.

Events List:

    --// SERVER
    CommandRan(Player, Data)
      Data is a table containing the following:
        Message = msg,     --// The full message the player chatted; Previously the "Message" param
        Matched = matched, --// The :kick in :kick me (the MatchedString param previously (the command basically))
        Args = args,       --// The command arguments (the me in :kick me)
        Command = command, --// The command's data table (contains the function and all info about the command being ran)
        Index = index,     --// The command's index in the command table
        Success = success, --// Did the command run? Did it fail? Did it return anything for some reason? This will tell us..
        Error = error,     --// If it failed, what was the error?
        Options = opts,    --// The options ("opts" table) passed to Process.Command; Contains stuff like isSystem and CrossServer flags
        PlayerData = pDat  --// Data about the player, such as Level, isAgent, isDonor, and the Player object itself

    CustomChat(Player, Message, Mode)
    PlayerChatted(Player, Message)
    PlayerAdded(Player)
    PlayerRemoving(Player)
    CharacterAdded(Player)
    NetworkAdded(NetworkClient)
    NetworkRemoved(NetworkClient)
    LogAdded(LogType, Log, LogTable)

    --// Currently Disabled
    ObjectAdded(Object)
    ObjectRemoved(Object)
    Output(Message, Type)
    ErrorMessage(Message, Trace, Script)

    --// CLIENT
    CharacterAdded()
    CharacterRemoving()

Example:

    --// Connect to the LogAdded event
    service.Events.LogAdded:Connect(function(LogType, Log, LogTable)
        print("New " .. LogType .." log: ".. Log.Text .. " - " .. Log.Desc)
    end)

    --// Wait for a log to be added
    local LogType, Log, LogTable = service.Events.LogAdded:Wait()

    --// Fire the LogAdded event
    service.Events.LogAdded:Fire("Command", {Text = "Player1: :ff me", Desc = "Player1 ran a command"}, server.Logs.Commands)

    --// Also here's the list of potential LogTypes:
    --// Chats in the first entry of this table corresponds to server.Logs.Chats, it's log type is "Chat"
    local indToName = {
        Chats = "Chat";
        Joins = "Join";
        Script = "Script";
        Replications = "Replication";
        NetworkOwners = "NetworkOwner";
        RemoteFires = "RemoteFire";
        Commands = "Command";
        Exploit = "Exploit";
        Errors = "Error";

## CheckEvents(*Waiting)

Currently disabled. Responsible for determining which events are done and should be cleaned up.

## ForEach(Table, Function)

Iterates through a given table, calling Function(Table, Index, Value) for each item in the table.

## WrapEventArgs(Table)

Responsible for wrapping arguments passed to event functions.

## UnWrapEventArgs(Table)

Unwraps objects in the given table.

## GetEvent(EventName)

Returns a special object for Adonis events. Refer to the Events section. Identical to service.Events.EventName

## HookEvent(EventName, Function)

Attaches a function to the specified EventName. Identical to calling service.Events.EventName:Connect()

## FireEvent(EventName, ...)

Identical to service.Events.EventName:Fire(...)

## RemoveEvents(EventName)

Removes all event hooks associated with EventName.

# service.ThreadService

The ThreadService object can be accessed via service.ThreadService. Unlike WrapService, EventService, and HelperService the functions and variables in ThreadService cannot be accessed as members of the service metatable. Instead, they can be accessed using the ThreadService object.

## Tasks

Table containing running tasks.

## Threads

Table containing running threads.

## CheckTasks()

Responsible for removing "dead" tasks.

## NewTask(Name, Function, *Timeout)

Creates a new task and returns newTask.Resume,newTask

Tasks have a number of functions. At it's core a task is a proxy object to a coroutine.

Every task contains the following:

    PID - a unique identifier for the task
    Name - task name
    Index - index in the Tasks table
    Created - time the task was created
    Changed - a table containing task related event functions, such as :connect(function), :fire(...); Fires when task changes
    Timeout - how long the task can run for, default inf (0)
    Running - bool that's true when the task is running
    Function - the task's function
    R_Status - current task status
    Finished - table containing tasks related event functions, such as :connect(function), fire(...), and :wait(); Fires when task finishes
    Function - task function handler
    Remove - removes the task
    Thread - task thread handler
    Resume - resumes the task
    Status - returns task status
    Pause - suspends the task
    Stop - stops and removes the task
    Kill - ends and removes the task
    End - ends the task

## RunTask(Name, Function, ...)

Creates a new task with Name and Function, then runs the new task with arguments ...

## TimeoutRunTask(Name, Function, Timeout, ...)

Same as RunTask but with a timeout.

## WaitTask(Name, Function, ...)

Same as RunTask, but yields until task.Finished fires.

## NewEventTask(Name, Function, *Timeout)

Returns a function that can be used to create a new task each time an event fires.

## Stop, Wait, Pause, Yield,

coroutine.yield

## Status

corotuine.status

## Running, Get

coroutine.running

## Create

coroutine.create

## Start

coroutine.resume

## Wrap

corotouine.wrap

## New(Function)

Creates a new coroutine and adds it to threads

## End(Thread)

Attempted to end the supplied thread and remove it

## Wrap(Function, ...)

Creates a new coroutine, adds it to threads, and then calls Resume with ...

## Resume(Thread, ...)

Calls resume on the specified thread with ...

## Remove(thread)

Removes the specified thread.

## StopAll()

Stops all threads.

Adonis Navigation Start  |  Guides  |  Tables
---|---|---
[Home](https://github.com/Epix-Incorporated/Adonis/wiki/Home) |  [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme) |  [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)

  * [Home](https://github.com/Epix-Incorporated/Adonis/wiki)
  * [User Manual & Feature Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)
  * [_G API](https://github.com/Epix-Incorporated/Adonis/wiki/G-API)
  * [Plugins and Modules](https://github.com/Epix-Incorporated/Adonis/wiki/Plugins-&-Modules)
  * [Structure](https://github.com/Epix-Incorporated/Adonis/wiki/Structure)

## Guides

  * [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme)

## Tables

  * [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)
  * [server.Admin](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Admin)
  * [server.Anti](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Anti)
  * [server.Commands](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Commands)
  * [server.Core](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core)
  * [server.Functions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Functions)
  * [server.HTTP](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.HTTP)
  * [server.Logs](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Logs)
  * [server.Process](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Process)
  * [server.Remote](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Remote)
  * [server.Variables](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Variables)

### Clone this wiki locally


[ Epix-Incorporated ](https://github.com/Epix-Incorporated) / ** [Adonis](https://github.com/Epix-Incorporated/Adonis) ** Public

  * ### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core).

  * [ Notifications ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis) You must be signed in to change notification settings
  * [ Fork 225 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)
  * [ Star  455 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)

# Tables: server.Core

Jump to bottom

Dimenpsyonal edited this page Dec 6, 2023 · [3 revisions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core/_history)

This is the "Core" table. It houses functions and variables that are essential to the core functionality of Adonis. If something happened to this table or its contents the entire system would become unusable. Functions within this table handle things like initial setup of the RemoteEvent/RemoteFunction, client loading, etc.

## (Table) Variables:

Contains Core-related variables, such as the TimeBans table.

## Datastore-related variables

    --// Datastore update/queue timers/delays
    DS_SetDataQueueDelay = 0.5;
    DS_UpdateQueueDelay = 1;
    DS_AllPlayerDataSaveInterval = 30;
    DS_AllPlayerDataSaveQueueDelay = 0.5;

    --// Used to change/"reset" specific datastore keys
    DS_RESET_SALTS = {
        SavedSettings = "32K5j4";
        SavedTables =     "32K5j4";
    };

## DisconnectEvent ()

Disconnects and destroys all events related to security and the RemoteEvent

## MakeEvent ()

Creates the RemoteEvent and RemoteFunction used for server-client communication.

## UpdateConnections ()

Updates the list of NetworkServer - Player connections

## UpdateConnection (Player: userdata)

Same as UpdateConnections but for a specific player.

## GetNetworkClient (Player: userdata)

Returns the NetworkClient belonging to 'Player'

## SetupEvent (Player: userdata)

Creates a new player-specific RemoteEvent to be used for client-server communication. Not currently used.

## PrepareClient ()

Creates a client loader in ReplicatedFirst. Not currently used in favor of handling the client loading process via HookClient(Player)

## HookClient (Player: userdata)

When a player joins this function is called and handles the process of preparing the client and parenting it to the player.

## LoadClientLoader (Player: userdata)

Handles the loading of existing players at server startup. Calls Process.PlayerAdded(Player)

## MakeClient ()

Places the client into StarterPlayerScripts. Not currently used in favor of HookClient

## ExecutePermission (SourceScriptObject: userdata, Code: string, isLocal: bool)

Determines if the given script object 'SourceScriptObject' is allowed to run. If 'Code' is provided it will be used as a pseudo-password. If 'isLocal' is true it will be treated as a LocalScript.

Returns: if allowed, table containing Source, noCache, runLimit, number of Executions

## GetScript (ScriptObject: userdata, Code: string)

Returns the registered script object matching 'ScriptObject' or 'Code'

## UnRegisterScript (ScriptObject: userdata)

Unregisters 'ScriptObject' for execution.

## RegisterScript (Data: table)

Registers Data.Script as being allowed to execute along with it's related information.

## GetLoadstring ()

Returns a new loadstring module.

## Bytecode (LuaCode: string)

Converts 'LuaCode' into bytecode and returns the result. This is used before sending any code to run to the client.

## NewScript (Class: string, Source: string, AllowCodes: bool, NoCache: bool, RunLimit: int)

Creates, registers, and returns a new script of class 'Class'

## SavePlayer (Player: userdata, Data: table)

Updates Player's data (in Core.PlayerData) do 'Data'

## DefaultPlayerData (Player: userdata)

Returns the default player data for 'Player'

## GetPlayer (Player: userdata)

Returns the PlayerData for 'Player' Also updates the PlayerData cache and will retrieve data from the datastore if not already cached.

## ClearPlayer (Player: userdata)

Clears data related to a player, resetting it to the default values.

## SavePlayerData (Player: userdata, CustomData: (opt)table)

Save's data for 'Player' to the datastore.

## SaveAllPlayerData ()

Saves all player data.

## GetDataStore ()

Returns the DataStore.

## DataStoreEncode (Key: string)

Returns the salted, encrypted, Base64 encoded version of a given key to be used in the datastore.

## SaveData (...)

Calls Core.SetData(...)

## RemoveData (Key: string)

Removes 'Key' and related data from the datastore.

## SetData (Key: string, Value)

Sets 'Key' to 'Value' in the datastore cache & datastore (when the datastore is updated)

## UpdateData (Key: string, Function: function)

Calls UpdateAsync for the given 'Key' with 'Function'

## GetData (Key: string)

Returns data related to 'Key' from the DataCache/datastore

## IndexPathToTable (string,TableAncestry: table)

Attempts to find the given table based on the path provided. Returns: foundTable, foundTableIndex

## DoSave(Data: table)

Saves settings or tables to the datastore based on information provided in 'Data'

## LoadData (Key: string, Data: table)

Loads saved settings, tables, etc.

## StartAPI ()

Handles the creation and monitoring of _G.Adonis

Adonis Navigation Start  |  Guides  |  Tables
---|---|---
[Home](https://github.com/Epix-Incorporated/Adonis/wiki/Home) |  [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme) |  [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)

  * [Home](https://github.com/Epix-Incorporated/Adonis/wiki)
  * [User Manual & Feature Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)
  * [_G API](https://github.com/Epix-Incorporated/Adonis/wiki/G-API)
  * [Plugins and Modules](https://github.com/Epix-Incorporated/Adonis/wiki/Plugins-&-Modules)
  * [Structure](https://github.com/Epix-Incorporated/Adonis/wiki/Structure)

## Guides

  * [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme)

## Tables

  * [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)
  * [server.Admin](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Admin)
  * [server.Anti](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Anti)
  * [server.Commands](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Commands)
  * [server.Core](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core)
  * [server.Functions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Functions)
  * [server.HTTP](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.HTTP)
  * [server.Logs](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Logs)
  * [server.Process](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Process)
  * [server.Remote](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Remote)
  * [server.Variables](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Variables)

### Clone this wiki locally


[ Epix-Incorporated ](https://github.com/Epix-Incorporated) / ** [Adonis](https://github.com/Epix-Incorporated/Adonis) ** Public

  * ### Uh oh!

There was an error while loading. [Please reload this page](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme).

  * [ Notifications ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis) You must be signed in to change notification settings
  * [ Fork 225 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)
  * [ Star  455 ](https://github.com/login?return_to=%2FEpix-Incorporated%2FAdonis)

# Guide: Creating a theme

Jump to bottom

Dimenpsyonal edited this page Mar 11, 2024 · [2 revisions](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme/_history)

# Getting started

In order to create a theme, you must have the Adonis Loader inside your game. You will also need to have access to the Adonis MainModule, but you do not need to keep this.

# Part 1

## Copying the theme

Go to the temporary Adonis MainModule copy and go to `MainModule > Client > UI`. This will allow you to see all the UI themes that Adonis uses. Select whichever one it is that you would like to base your new theme on! In our example, we will use Unity.

## Transferring the theme

Copy the theme you wish to base your new theme on and paste it in your loader at: `Adonis_Loader > Config > Themes`. You can now delete MainModule if you wish.

# Part 2

## Setting up your new theme

  1. Now you've successfully copied your theme over to your loader, you can start setting it up. Rename the theme to whatever it is you wish for it to be called. In this guide we will call it `ExampleTheme`.
  2. Now check that your theme has a StringValue inside called `Base_Theme`. If it doesn't, create it! This is the theme that Adonis will use if it cannot find a specific GUI. In our example we will set this to Aero.
  3. You've successfully installed the new theme! You can now select it in the menu. However, at the moment it is the exact same as another theme.

## Creating your new theme

  * Now it's time to customise your new theme. You can delete any GUIs you don't want to customise, and Adonis will automatically use the Base_Theme for these cases.
  * In this example, we will turn the colour of the UI into red and change the font to Source Sans Pro.
  *     * To do this, we will go to `ExampleTheme > Window > Drag` and change the FontFace from Ubuntu to Source Sans Pro. Then we will go into Drag and change the background frame to Red.
  * You can edit the UI further. If you wish to see the changes you are making, drag the ScreenGui into StarterGui. Just remember to put it back into the theme folder when you're done editing!
  * Additionally, you can also edit the UI code to include new features or change existing ones, such as click sounds.
  *     * Note that some UIs do not have ScreenGuis by default (such as Notifications/Hints)- this is intentional and you will have to add a ScreenGui to see these in StarterGui.

Congratulations! Just publish the game and you've successfully made an Adonis theme. If you have any queries, or would like to see a different guide, just ask in our communications server.

Adonis Navigation Start  |  Guides  |  Tables
---|---|---
[Home](https://github.com/Epix-Incorporated/Adonis/wiki/Home) |  [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide%3A-Creating-a-theme) |  [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)

  * [Home](https://github.com/Epix-Incorporated/Adonis/wiki)
  * [User Manual & Feature Showcase](https://github.com/Epix-Incorporated/Adonis/wiki/User-Manual-&-Feature-Showcase)
  * [_G API](https://github.com/Epix-Incorporated/Adonis/wiki/G-API)
  * [Plugins and Modules](https://github.com/Epix-Incorporated/Adonis/wiki/Plugins-&-Modules)
  * [Structure](https://github.com/Epix-Incorporated/Adonis/wiki/Structure)

## Guides

  * [Creating a theme](https://github.com/Epix-Incorporated/Adonis/wiki/Guide:-Creating-a-theme)

## Tables

  * [The "Service" Metatable](https://github.com/Epix-Incorporated/Adonis/wiki/The-%22Service%22-Metatable)
  * [server.Admin](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Admin)
  * [server.Anti](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Anti)
  * [server.Commands](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Commands)
  * [server.Core](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Core)
  * [server.Functions](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Functions)
  * [server.HTTP](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.HTTP)
  * [server.Logs](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Logs)
  * [server.Process](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Process)
  * [server.Remote](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Remote)
  * [server.Variables](https://github.com/Epix-Incorporated/Adonis/wiki/Tables:-server.Variables)

### Clone this wiki locally