Luau Developer Toolchain Guide — Professional Workflow with Rojo, Selene, StyLua & Wally [2026]

Roblox Studio is a capable IDE, but it lacks professional-grade features like Git integration, static analysis, and package management. By combining Rojo, Selene, StyLua, and Wally, you can achieve a modern software development workflow equivalent to any mainstream tech stack.

The core challenges with Studio-only development: - Version control: Studio's `.rbxl` format makes Git diffs nearly unreadable - Code quality: No real-time detection of bugs or deprecated API usage - Team development: Simultaneous editing and code reviews are difficult - Dependency management: External library updates require manual effort An external toolchain solves all of these and dramatically improves team scalability.

Rojo syncs `.luau` files from your filesystem to the Roblox Studio object tree in real time. Key features: - Git-manage Luau files in their natural directory structure - Start with `rojo serve`, then connect via the Studio plugin - Define file-to-Roblox tree mappings in `.project.json`

# Initialize a Rojo project
rojo init my-game
cd my-game
rojo serve

Just click Connect in the Studio Rojo plugin — from then on, every file save triggers an automatic Studio update.

Selene is a high-performance static analysis tool written in Rust with native Roblox API support. Key capabilities: - Detects unused variables, shadowing, and deprecated API calls - Ships with built-in Roblox standard library definitions - Supports custom lint rules

# selene.toml
[lints]
global_usage = "allow"
roblox = true

Combined with the VSCode extension, warnings appear inline while you type.

StyLua is a Lua/Luau-dedicated code formatter that automatically enforces consistent style across the entire team.

# stylua.toml
column_width = 120
indent_type = "Spaces"
indent_width = 4
quote_style = "AutoPreferDouble"
call_parentheses = "Always"

# Format all source files
stylua src/

# Check mode for CI
stylua --check src/

Integrating `--check` into your CI/CD pipeline prevents improperly formatted code from merging.

Wally, hosted at `wally.run`, is the npm or Cargo equivalent for the Luau ecosystem.

# wally.toml
[package]
name = "myorg/my-game"
version = "0.1.0"
registry = "https://github.com/UpliftGames/wally-index"

[dependencies]
Promise = "evaera/promise@4.0.0"
ProfileService = "madstudioroblox/profileservice@1.0.0"
Signal = "sleitnick/signal@1.5.0"

wally install

Running `wally install` generates a Packages folder, making libraries accessible via `require(Packages.Promise)`.

Rokit manages Rojo, Selene, StyLua, and Wally versions through a single `rokit.toml`.

# rokit.toml
[tools]
rojo = "rojo-rbx/rojo@7.4.4"
wally = "UpliftGames/wally@0.3.2"
selene = "Kampfkarren/selene@0.27.1"
stylua = "JohnnyMorganz/StyLua@0.20.0"

rokit install

Team members run `rokit install` once to get every tool at the exact same version — no version drift.

luau-lsp is an LSP implementation providing: - Autocomplete: Method completion for Roblox APIs and custom classes - Type checking: Static type errors from `--!strict` mode shown inline - Go to definition: Jump to ModuleScript source with F12 - Hover info: Inline function signatures and documentation Install the "Luau Language Server" VSCode extension and it starts automatically.

TestEZ is Roblox's official unit testing framework with a Jest-like API.

-- AnimalSpec.luau
return function()
    describe("Animal", function()
        it("should have correct name", function()
            local animal = Animal.new("Rex", "Woof")
            expect(animal:getName()).to.equal("Rex")
        end)
    end)
end

Paired with Lune, tests can run outside Roblox Studio and integrate directly into CI/CD pipelines.

Lune runs Luau without Roblox Studio, making it ideal for build scripts, file operations, and HTTP calls in CI/CD.

-- build.luau
local fs = require("@lune/fs")
local process = require("@lune/process")

local result = process.spawn("rojo", {"build", "--output", "game.rbxl"})
if result.ok then
    print("Build succeeded")
else
    error(result.stderr)
end

Q1. Isn't Roblox Studio alone sufficient? A. For solo small-scale projects, yes. But for team development, long-term maintenance, and code reviews, an external toolchain provides significant advantages in both speed and quality. Q2. What are the minimum essential tools for team development? A. Rojo (for Git management) and luau-lsp (for code completion) are the top priorities. Adding Rokit (version unification) and Selene (code quality) is strongly recommended next. Q3. How mature is Wally compared to npm or Cargo? A. The package count doesn't match npm, but all major Roblox development libraries — Promise, Signal, ProfileService, and more — are available. As of 2026, active maintenance continues. Q4. Do Selene and luau-lsp type checking overlap? A. They serve different purposes. Selene detects code style issues, deprecated APIs, and logic patterns. luau-lsp detects type-system errors. Using both is recommended. Q5. When should I use Lune? A. Use Lune for CI/CD automated builds, test execution scripts, and file generation tools — any scenario where you need to run Luau code outside Roblox. Q6. Can this toolchain be used for non-Roblox Luau projects? A. Yes. Selene, StyLua, and Lune are pure Luau/Lua tools independent of Roblox. Rojo and Wally are Roblox-specific.

Need help setting up a Roblox development toolchain, building a CI/CD pipeline, or structuring your engineering team? Oflight's specialists provide end-to-end support from environment setup to long-term maintenance. Visit our Software Development Service for details.