Knit Documentation

Knit provides two optional lifecycle methods to help orchestrate communication between services:

1. KnitInit: Fired after all services are created but before any service is guaranteed to be ready for consumption.

   • Use for: Setting up internal state, connecting to engine events (like Players.PlayerRemoving), or referencing other services.
   • Avoid: Calling methods or accessing events on other services here, as they may not be fully initialized.

2. KnitStart: Fired after all KnitInit methods have completed.

   • Use for: Inter-service communication. At this stage, you can safely call methods on other services or connect to their events because all services are guaranteed to be initialized.

Best Practice: Set up your service's core logic in KnitInit (or earlier in the ModuleScript) so that by the time KnitStart runs, the service is ready for use by others.

-- Example of using KnitInit for cleanup
function PointsService:KnitInit()
	game:GetService("Players").PlayerRemoving:Connect(function(player)
		self.PointsPerPlayer[player] = nil
	end)
end

Knit uses signals (based on RemoteEvent) to facilitate two-way communication between the server and client. You define these signals within the Client table of a service using Knit.CreateSignal().

Server-to-Client Events

To notify clients of an event (e.g., a value changing), use self.Client.SignalName:Fire(player, ...) on the server. Clients can listen using :Connect().

Client-to-Server Events

To allow clients to trigger server logic without expecting a return value, define a signal in the Client table. The server can listen for these in KnitInit using self.Client.SignalName:Connect(function(player) ... end). Clients trigger them using :Fire().

Unreliable Signals

For non-critical data (like cosmetic effects) where bandwidth is more important than guaranteed delivery or order, use Knit.CreateUnreliableSignal() in the Client table. This utilizes Roblox's UnreliableRemoteEvent.

-- Server: Creating and firing signals
local PointsService = Knit.CreateService {
	Name = "PointsService",
	Client = {
		PointsChanged = Knit.CreateSignal(),
		GiveMePoints = Knit.CreateSignal(),
		PlayEffect = Knit.CreateUnreliableSignal(),
	},
}

function PointsService:AddPoints(player, amount)
	self.Client.PointsChanged:Fire(player, newPoints)
end

-- Server: Listening to client signals in KnitInit
function PointsService:KnitInit()
	self.Client.GiveMePoints:Connect(function(player)
		print(player.Name .. " requested points")
	end)
end

-- Client: Listening and firing
local PointsService = Knit.GetService("PointsService")
PointsService.PointsChanged:Connect(function(points)
	print("Points updated:", points)
end)

PointsService.GiveMePoints:Fire()

Knit follows a specific execution flow to ensure all services and controllers are initialized before the application starts.

1. Require Knit: Import the Knit module.
2. Create Services/Controllers: Define your services (server) or controllers (client) as ModuleScripts.
3. Call Knit.Start(): This returns a Promise that manages the startup sequence:
   • All KnitInit methods are invoked simultaneously. Knit.Start() waits for all of them to complete.
   • Once all KnitInit methods finish, all KnitStart methods are invoked simultaneously.
   • After all KnitStart methods finish, the promise returned by Knit.Start() resolves.

Important: Services and controllers cannot be created after Knit.Start() has been called. Once created, they persist until the server shuts down or the player leaves.

local Knit = require(game:GetService("ReplicatedStorage").Packages.Knit)

-- Load services or controllers here

Knit.Start():catch(warn)