VyTaxian — Roblox Developer

Code

Script portfolio

Framework internals — expand any file to read the source.

.luau

Client Framework Boot

Starts the client framework and loads controller modules from the Controllers folder.

local Loader = require(game:GetService("ReplicatedStorage").VyTax.Loader)

local framework = Loader.new()

framework:LoadControllers(script.Parent.Controllers)

framework:Start()

.luau

UI Controller

Creates ScreenGui elements, reusable frames, buttons, labels, and timed notifications.

local Maid = require(game:GetService("ReplicatedStorage").VyTax.Maid)
local Signal = require(game:GetService("ReplicatedStorage").VyTax.Signal)

local UIController = {}
UIController.__index = UIController

function UIController.new()
	return setmetatable({}, UIController)
end

function UIController:_init()
	self._maid = Maid.new()
	self.ScreenGui = Instance.new("ScreenGui")
	self.ScreenGui.Name = "VyTaxUI"
	self.ScreenGui.IgnoreGuiInset = true
	self.ScreenGui.ResetOnSpawn = false
	self.ScreenGui.Parent = self.Player:WaitForChild("PlayerGui")
	self._maid:GiveTask(self.ScreenGui)
end

function UIController:_start()
	print("[VyTax] UIController started for", self.Player.Name)
end

function UIController:CreateFrame(name, properties)
	local frame = Instance.new("Frame")
	frame.Name = name
	for prop, value in properties do
		frame[prop] = value
	end
	frame.Parent = self.ScreenGui
	self._maid:GiveTask(frame)
	return frame
end

function UIController:Notify(title, message, duration)
	duration = duration or 3
	local frame = self:CreateFrame("Notification", {
		Size = UDim2.new(0, 300, 0, 80),
		Position = UDim2.new(0.5, -150, 0, 20),
		BackgroundColor3 = Color3.fromRGB(30, 30, 30),
		BackgroundTransparency = 0.2,
		BorderSizePixel = 0,
	})
	frame.ZIndex = 10

	local titleLabel = Instance.new("TextLabel")
	titleLabel.Size = UDim2.new(1, 0, 0, 30)
	titleLabel.BackgroundTransparency = 1
	titleLabel.Text = title
	titleLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
	titleLabel.Font = Enum.Font.GothamBold
	titleLabel.TextSize = 18
	titleLabel.Parent = frame

	task.delay(duration, function()
		frame:Destroy()
	end)
end

return UIController.new()

.luau

Server Framework Boot

Loads services, starts the framework, and logs player joins plus online player counts.

local Loader = require(game:GetService("ReplicatedStorage").VyTax.Loader)

local framework = Loader.new()

framework:LoadServices(script.Parent.Services)
framework:Start()

game:GetService("Players").PlayerAdded:Connect(function(player)
	print(("[VyTax] %s joined the game"):format(player.Name))
end)

task.spawn(function()
	while task.wait(300) do
		local count = #game:GetService("Players"):GetPlayers()
		print(("[VyTax] Players online: %d"):format(count))
	end
end)

.luau

Data Service

Wraps Roblox DataStore loading and saving with Promise-based player data sessions.

local Maid = require(game:GetService("ReplicatedStorage").VyTax.Maid)
local Promise = require(game:GetService("ReplicatedStorage").VyTax.Promise)

local DataService = {}
DataService.__index = DataService

function DataService.new()
	return setmetatable({}, DataService)
end

function DataService:_init()
	self._maid = Maid.new()
	self._sessions = {}
end

function DataService:Load(userId)
	return Promise.new(function(resolve, reject)
		local success, data = pcall(function()
			return game:GetService("DataStoreService"):GetDataStore("PlayerData"):GetAsync(userId)
		end)
		if success then
			self._sessions[userId] = data or self:_getDefaultData()
			resolve(self._sessions[userId])
		else
			reject(data)
		end
	end)
end

function DataService:_getDefaultData()
	return {
		Coins = 0,
		Level = 1,
		Experience = 0,
		Inventory = {},
		Settings = {},
	}
end

return DataService.new()

.luau

Player Service

Tracks active players, exposes player-added and player-removed signals, and provides lookup helpers.

local Maid = require(game:GetService("ReplicatedStorage").VyTax.Maid)
local Signal = require(game:GetService("ReplicatedStorage").VyTax.Signal)

local PlayerService = {}
PlayerService.__index = PlayerService

function PlayerService.new()
	return setmetatable({}, PlayerService)
end

function PlayerService:_init()
	self._maid = Maid.new()
	self.PlayerAdded = Signal.new()
	self.PlayerRemoved = Signal.new()
	self._players = {}

	self._maid:GiveTask(game:GetService("Players").PlayerAdded:Connect(function(player)
		self._players[player.UserId] = player
		self.PlayerAdded:Fire(player)
	end))

	self._maid:GiveTask(game:GetService("Players").PlayerRemoving:Connect(function(player)
		self._players[player.UserId] = nil
		self.PlayerRemoved:Fire(player)
	end))

	for _, player in game:GetService("Players"):GetPlayers() do
		self._players[player.UserId] = player
	end
end

function PlayerService:GetPlayer(userId)
	return self._players[userId]
end

return PlayerService.new()

.luau

Remote Event Wrapper

Provides a typed RemoteEvent utility with client, server, wait, connect, and destroy helpers.

local Signal = require(script.Parent.Signal)
local Maid = require(script.Parent.Maid)

local Event = {}
Event.__index = Event

function Event.new(name, existing)
	local self = setmetatable({
		Name = name,
		_maid = Maid.new(),
	}, Event)

	self.Remote = existing or Instance.new("RemoteEvent")
	self.Remote.Name = name

	return self
end

function Event:FireServer(...)
	self.Remote:FireServer(...)
end

function Event:FireClient(player, ...)
	self.Remote:FireClient(player, ...)
end

function Event:Connect(callback)
	if game:GetService("RunService"):IsServer() then
		return self.Remote.OnServerEvent:Connect(callback)
	else
		return self.Remote.OnClientEvent:Connect(callback)
	end
end

function Event:Destroy()
	self._maid:DoCleaning()
	if self.Remote and self.Remote.Parent then
		self.Remote:Destroy()
	end
end

return Event

.luau

Framework Init Module

Exports the core framework modules and utility namespace from one package entry point.

local Module = {}

Module.Maid = require(script.Maid)
Module.Signal = require(script.Signal)
Module.Event = require(script.Event)
Module.Promise = require(script.Promise)
Module.Loader = require(script.Loader)

Module.Util = {}
Module.Util.Logger = require(script.Util.Logger)
Module.Util.Time = require(script.Util.Time)
Module.Util.Table = require(script.Util.Table)

return Module

.luau

Module Loader

Loads services, controllers, and components, injects dependencies, and starts lifecycle methods.

local Maid = require(script.Parent.Maid)

local Loader = {}
Loader.__index = Loader

function Loader.new()
	return setmetatable({
		_services = {},
		_controllers = {},
		_loaded = false,
		_started = false,
		_maid = Maid.new(),
	}, Loader)
end

function Loader:_loadModules(folder)
	local modules = {}
	for _, child in folder:GetChildren() do
		if child:IsA("ModuleScript") then
			modules[child.Name] = require(child)
		end
	end
	return modules
end

function Loader:LoadServices(folder)
	if self._loaded then return end
	local modules = self:_loadModules(folder)
	for name, service in modules do
		service.Name = name
		self._services[name] = service
		self._maid:GiveTask(service)
	end
end

function Loader:Start()
	if self._started then return end
	self._loaded = true
	self._started = true

	for _, service in self._services do
		local ok, err = pcall(function() service:_init() end)
		if not ok then warn(("[VyTax] %s _init error: %s"):format(service.Name, err)) end
	end
	for _, service in self._services do
		local ok, err = pcall(function() service:_start() end)
		if not ok then warn(("[VyTax] %s _start error: %s"):format(service.Name, err)) end
	end
end

return Loader

.luau

Maid Cleanup Utility

Cleans functions, threads, connections, instances, and destroyable objects from one task list.

local Maid = {}
Maid.__index = Maid

function Maid.new()
	return setmetatable({ _tasks = {} }, Maid)
end

function Maid:GiveTask(task)
	if task then
		table.insert(self._tasks, task)
	end
	return self
end

function Maid:DoCleaning()
	local tasks = self._tasks
	self._tasks = {}
	for i = #tasks, 1, -1 do
		self:_clean(tasks[i])
	end
end

function Maid:_clean(item)
	local t = typeof(item)
	if t == "function" then
		item()
	elseif t == "RBXScriptConnection" then
		item:Disconnect()
	elseif t == "Instance" then
		item:Destroy()
	elseif type(item) == "table" and item.Destroy then
		item:Destroy()
	end
end

return Maid