Skip to main content

Introduction

Pulse is a build system and framework for Roblox Lua scripts. It solves a specific problem: building large, multi-feature scripts without relying on GitHub or loadstring, and without managing a single massive file.

It started as a compiler. The framework layer was added later. It's in active development — things work, things break, decisions get revisited.

The problem with large scripts​

As a Roblox script grows — more features, more helpers, more logic — the standard approach is to split it into modules and use require() to connect them:

-- module A requires module B
local ESP      = require(repo.ESP)
local Aimbot   = require(repo.Aimbot)
local Helpers  = require(repo.Helpers)

Each module lives in a GitHub repo. The main script loads them at runtime via loadstring + HttpGet. This works, until:

Problem 1 — Obfuscation is a nightmare. Each module needs to be obfuscated separately. Running an obfuscator on 10+ files, keeping them in sync, and making sure cross-module references survive obfuscation is tedious and error-prone. Most people skip it — and ship readable source.

Problem 2 — Unobfuscated code on GitHub gets accounts banned. GitHub's automated scanners flag Roblox exploit scripts. Repos get taken down. Accounts get restricted. If you push unobfuscated Lua that's clearly an exploit script, it's a matter of time.

Problem 3 — Testing with the multi-module setup is slow. To test any change you need to obfuscate every module, push all files to GitHub, then use loadstring + HttpGet to load them. That's four steps just to verify a one-line change. Most executors don't support executing multiple files at once either — you'd need extra configuration just to run your local code. With rb: change a file, run rb build, inject one file. Done.

Problem 4 — Managing many files across a GitHub repo is painful. New feature? New file in the repo, new require() call, new entry in the module list. Rename something? Update every reference. Delete something? Hope nothing still requires it.

What Pulse does instead​

rb build compiles all your source files into a single .lua file — at build time, not runtime. No require() anywhere. No GitHub modules to manage at runtime.

The output is one file, already obfuscated. You push that one file to GitHub (or a Gist, or a paste site) and users load it with a single loadstring:

loadstring(game:HttpGet("https://raw.githubusercontent.com/.../script.obf.lua"))()

GitHub only sees an opaque blob of obfuscated bytecode — nothing that looks like an exploit script. One file. One push. Done.

During development, you work with clean, modular TypeScript files in a proper folder structure. The Pulse framework layer removes the boilerplate that makes large scripts painful: connection tracking, toggle logic, reactive UI binding, respawn handling. You write the logic; it handles the wiring.

The result: maintainable source code during development, one clean obfuscated file for deployment.

What you get​

The rb CLI — a build tool for your script project:

  • rb build — compiles all your TypeScript + Lua files into one .lua + obfuscated .lua
  • rb watch — auto-rebuild on every file save
  • rb lint — find dead signals and broken references
  • rb init — scaffold a new TypeScript project with examples

The Pulse framework — a component syntax compiled into your script:

  • signal — reactive state variables that wire UI and logic together
  • on.* handlers — event subscriptions with auto-cleanup (on.heartbeat, on.respawn, on.signal, …)
  • guard — null-safe variable unpacking
  • func — public methods between components
  • Built-in helpers: Pulse.Draw, Pulse.Aim, Pulse.Loop, and more
  • Key system — optional gate behind a key; static list or server-side validator
  • Premium tier — lock individual groupboxes; users unlock live with no re-injection

What it's not​

  • Not a runtime you load with require() — it compiles in
  • Not a UI library — it integrates with WindUI or Linoria for the actual UI
  • Not stable — active development means bugs and breaking changes exist
  • Not magic — it's the same Roblox API underneath, just organized

Development pace​

Pulse is maintained by one developer who has a day job. Updates happen when they happen — no roadmap, no release schedule. If something is broken, join the Discord and report it. Fixes land when they can.

If you find a bug or an edge case, the fastest path is reading the source (below) and understanding it yourself. The codebase is small enough that a few hours gets you up to speed.

Inspecting the source​

The rb CLI is an npm package (pulse-rb). After npm install -g pulse-rb (or the PowerShell installer), the source lives at:

~/.rb/  (or wherever pnpm stores global packages)
  pulse/runtime.lua        ← the reactive engine
  pulse/helpers/           ← all Pulse.* helpers
  adapters/windui.lua      ← WindUI adapter
  adapters/linoria.lua     ← Linoria adapter
  templates/               ← rb init scaffolds

Run rb docs to generate PULSE_DOCS.md in your project — a single-file reference of the full framework, ready to paste into an AI context window.

Next steps​

→ Quick Start — install rb and build your first script in 5 minutes

→ Mental Model — understand how compilation and signals work before writing code

→ Scripting School — learn Roblox scripting from scratch, from the executor perspective