Vanguard is a modern, modular Roblox framework built for developers who want a scalable and maintainable foundation for their experiences.
Inspired by Knit’s familiar Service and Controller workflow, Vanguard keeps that structure while adding a more complete framework layer: structured lifecycle management, built-in networking, server-authoritative validation, registered classes, components, utilities, plugin support, and type-friendly APIs.
Whether you are building a solo project or a larger production experience, Vanguard is designed to keep your code organized, predictable, and easier to expand.
Links
Vanguard-0.1.15.rbxm (58.2 KB)
Current Release
Vanguard 0.1.15 is now available.
This release adds:
- Plugin Developer API
- Replicator system for server-owned state trees
- Network protocol
2 - Remote kind metadata
- Plugin and replicator error codes
- Proper
.rbxmrelease build support - Expanded documentation
Important: Vanguard 0.1.15 uses network protocol 2. Vanguard 0.1.14 uses protocol 1, so make sure both server and client are using the same installed package version.
Availability
Vanguard is currently available through:
- Wally Package
- Source Code via GitHub
.rbxmrelease builds for manual installation
A verified Roblox Toolbox release is still planned for a future update.
Why Vanguard?
Knit has been a staple of Roblox development for years, but many projects need stronger structure, clearer startup behavior, built-in utilities, and safer networking patterns.
Vanguard was created to provide a familiar development experience while modernizing the framework around scalability, documentation, lifecycle control, and server authority.
Familiar Workflow
Developers coming from Knit will find familiar concepts like Services, Controllers, lifecycle hooks, and client-facing service APIs.
Modular by Design
Vanguard encourages clean project organization through services, controllers, components, classes, utilities, and plugins.
Built for Scale
Vanguard includes lifecycle ordering, service priority, module failure isolation, logging, network validation, and typed APIs to support larger projects.
Developer Focused
Vanguard prioritizes readability, maintainability, documentation, and long-term project health.
Features
- Service architecture
- Controller architecture
- Plugin Developer API
- Replicator state system
- Promise-based startup
- Structured lifecycle hooks
- Service priority
- Automatic module registration
- Module failure isolation
- Built-in networking layer
- Remote methods
- Reliable signals
- Unreliable signals
- Replicated properties
- Server-owned replicators
- Network validation
- Network authentication
- Network verification
- Rate limiting
- Components system
- Registered classes
- Public, private, and static class members
- Logging system
- Error codes with documentation links
- Cache utility
- Promise utility
- Math utility
- Switch utility
- Validator utility
- Dependency-free core
- Rojo support
- Wally support
- Type-friendly APIs
- Familiar Knit-inspired workflow
Installation
Requirements
- Roblox Studio
- A Rojo project
- Wally
0.3.x - Vanguard
0.1.15
Vanguard is dependency-free. All utility modules are included directly in the package.
Install with Wally
Add Vanguard to your project’s wally.toml:
[dependencies]
Vanguard = "twrblxdevs/vanguard@0.1.15"
Install dependencies:
wally install
Map the generated Packages directory into ReplicatedStorage:
{
"name": "MyGame",
"tree": {
"$className": "DataModel",
"ReplicatedStorage": {
"Packages": {
"$path": "Packages"
}
}
}
}
Require Vanguard:
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Vanguard = require(ReplicatedStorage.Packages.Vanguard)
Quick Start
Recommended Project Layout
src
|- server
| |- Bootstrapper.server.luau
| `- Services
| `- GreetingService.luau
|- client
| |- Bootstrapper.client.luau
| `- Controllers
| `- GreetingController.luau
`- shared
|- Classes
|- Components
`- Plugins
The exact folders are not required. Vanguard can bootstrap any Instance containing ModuleScripts.
Create a Service
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Vanguard = require(ReplicatedStorage.Packages.Vanguard)
local GreetingService = Vanguard.CreateService({
Name = "GreetingService",
Client = {
Greeted = Vanguard.CreateSignal(),
},
})
function GreetingService.Client:Greet(player, name)
local message = self.Server:BuildGreeting(name)
self.Greeted:Fire(player, message)
return message
end
function GreetingService:BuildGreeting(name)
return `Hello, {name}!`
end
function GreetingService:VanguardStart()
self.Logger:Info("Greeting service ready")
end
return GreetingService
Start the Server
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Vanguard = require(ReplicatedStorage.Packages.Vanguard)
Vanguard.Bootstrap({
Plugins = ReplicatedStorage.Shared.Plugins,
Services = script.Parent.Services,
Options = {
LogLevel = "info",
},
}):catch(function(err)
warn(`Vanguard server failed: {err}`)
end)
Create a Controller
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Vanguard = require(ReplicatedStorage.Packages.Vanguard)
local GreetingController = Vanguard.CreateController({
Name = "GreetingController",
})
function GreetingController:VanguardStart()
local GreetingService = Vanguard.GetService("GreetingService")
GreetingService.Greeted:Connect(function(message)
self.Logger:Info(message)
end)
GreetingService:Greet("Builder"):andThen(function(message)
self.Logger:Info(`Server returned: {message}`)
end):catch(function(err)
self.Logger:Warn(err)
end)
end
return GreetingController
Start the Client
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Vanguard = require(ReplicatedStorage.Packages.Vanguard)
Vanguard.Bootstrap({
Plugins = ReplicatedStorage.Shared.Plugins,
Controllers = script.Parent.Controllers,
Options = {
LogLevel = "info",
},
}):catch(function(err)
warn(`Vanguard client failed: {err}`)
end)
New in 0.1.15
Plugin Developer API
Plugins allow extensions, diagnostics, project-specific tooling, and future Studio tools to hook into Vanguard through public APIs.
return Vanguard.CreatePlugin({
Name = "DiagnosticsPlugin",
Version = "1.0.0",
Runtime = "Shared",
Hooks = {
ServiceRegistered = function(context, payload)
context.Logger:Debug(`Service registered: {payload.Name}`)
end,
},
})
Docs:
Replicators
Replicators are server-owned state trees for larger structured state.
Client = {
State = Vanguard.CreateReplicator({
Phase = "Lobby",
Score = {
Red = 0,
Blue = 0,
},
}),
}
Server code can update paths or patch state:
self.Client.State:SetPath("Score.Red", 1)
self.Client.State:Patch({
Phase = "Active",
})
Docs:
Lifecycle
During startup Vanguard:
- Loads and registers ModuleScripts
- Runs plugin init hooks
- Builds networking infrastructure
- Runs
VanguardInithooks - Runs plugin start hooks
- Schedules
VanguardStarthooks - Starts components
- Resolves the Bootstrap promise
This structured lifecycle makes startup predictable and easier to reason about.
Network Security
Vanguard includes a server-authoritative network guard pipeline for inbound remotes.
You can validate payloads, authenticate players, verify actions against server state, and rate-limit requests before service code runs.
This helps protect sensitive systems such as inventory, trading, purchases, matchmaking, profile loading, and other gameplay-critical logic.
Docs:
Roadmap
- Core Framework
- Service System
- Controller System
- Networking Layer
- Components System
- Classes
- Utility Modules
- Error Documentation Links
- Plugin Developer API
- Replicator System
- Wally Distribution
- Documentation
- Roblox Toolbox Release
- Additional Utility Modules
- Expanded Examples
- Studio Tooling
- Community Contributions
Roadmap:
Contributing
Contributions, bug reports, feature requests, and feedback are welcome.
Contribution guide:
Feedback
Questions, suggestions, bug reports, and constructive criticism are appreciated.
If you use Vanguard in one of your projects, I would love to hear what works, what feels rough, and what you would like to see improved next.
