Roblox systems for production combat.

I'm William North. I build combat, networking, tooling, and maintainable Luau systems for production Roblox games. As nsawill, I focus on clear architecture, reliable handoff, and shipping under live constraints.

Experience 5+ years building Roblox systems

Luau gameplay, live-game maintenance, and developer tooling shaped for production teams.

Live scale Live games up to ~1.5k CCU

Shipped projects where player load changes the engineering bar.

Delivery Multiple shipped projects

Public work across live games, Wally-ready libraries, and Roblox Studio tooling.

Based: United Kingdom
Focus: Roblox gameplay, networking, tooling
Stack: Luau, ModuleScripts, RemoteEvents, Wally/Rojo workflows
Open to: Contract, freelance, and full-time roles

Technical strengths built for Roblox production.

Game feel, authority boundaries, predictable multiplayer behavior, and team-friendly Luau structure.

01

Combat systems

Hit detection, timing windows, knockback, and readable PvP loops built for real gameplay use.

02

Client/server architecture

Clear authority boundaries that keep responsive feel without giving up server trust.

03

Networking & replication

RemoteEvent contracts shaped around latency, replication behavior, and predictable multiplayer outcomes.

04

Pathfinding / AI

Planner, navigator, and coordination patterns for NPC movement that stay stable under crowd pressure.

05

Data persistence

DataStore-facing state thinking that treats recovery and failure modes as part of production quality.

06

Performance optimization

Delivery shaped by compute budgets, repeated systems use, and avoiding avoidable runtime churn.

07

Modular Luau architecture

Reusable components, explicit APIs, and code paths teams can tune without rewriting core behavior.

08

Tooling / plugins

Studio workflow improvements that remove repetitive work and raise iteration speed for teams.

Shipped Roblox work under live constraints.

Live games, real players, release pressure, and measurable scale.

Doomed 2 Die showcase video Gameplay capture from Doomed 2 Die.

Selected game 01 · shipped live combat experience

Doomed 2 Die

Shipped combat work for a live Roblox game with 7.4M+ visits and about 1.5k peak CCU.

What I built
Built and tuned combat gameplay systems used in live release updates.
Production context
Active-player combat game with a small-server design, live updates, and team handoff needs.
Technical challenge
Keep combat updates predictable in 10-player servers while peak concurrency reached about 1.5k CCU.
Outcome
Shipped live combat updates for ~1.5k peak CCU, 7.4M+ visits, and several releases.
Peak CCU ~1.5k

Verified peak concurrency range.

Visits 7.4M+

Public production scale.

Server size ~10 players

Small-server combat tuning context.

Roblox Combat systems Live concurrency Production teamwork
Semi-Truck Obby showcase video Gameplay capture from Semi-Truck Obby.

Selected game 02 · shipped obby systems

Semi-Truck Obby

Live obby production work for a Roblox experience with 20M+ visits and about 1k peak CCU.

What I built
Built and shipped player-facing gameplay systems, including progression and stage flow.
Production context
High-traffic obby with frequent content iteration, monetization pressure, and active sessions.
Technical challenge
Ship fast updates without breaking stage flow, checkpoints, rewards, or session stability.
Outcome
Shipped fast-turnaround updates for a 20M+ visit experience that peaked around 1k CCU.
Peak CCU ~1k peak

Verified peak concurrency range.

Visits 20M+

Public production scale.

Delivery Many updates

Fast release cadence across live obby work.

Roblox Live game systems Iteration speed Team delivery
Open experience ↗

Public Roblox code proof, not just claims.

These public repos show how the work is structured: authoritative systems, reusable Luau modules, and developer-facing tooling that is meant to survive real project use.

Public Roblox library

Hitbox-Plus

Spatial query hit detection with server/client split, validation helpers, and lag compensation hooks.

Snapshot-backed rewind lookup for latency-aware combat validation.
Default rules for max distance, duplicate attacks, cooldowns, and optional line-of-sight.
Immediate combat feel without giving up authoritative trust boundaries.
Luau Wally Hit validation Studio sandbox
Public Roblox library

Pathfinding-Plus

Crowd-aware pathfinding with planner, navigator, and coordinator roles split by responsibility.

Normalized planning results with stuck detection, cancellation, and replans built in.
Shared compute budgeting and spacing helpers for multi-agent movement.
Shared path budgets for NPCs competing for movement compute.
Luau Wally Pathfinding Rojo example
Public Roblox library

SignalX

Event and messaging library focused on cleanup, priorities, middleware, replay, and debugging.

Scoped cleanup and tagged listeners for better lifecycle control in larger codebases.
Replay-on-connect, listener priorities, and debug visibility built into the API surface.
Communication boundaries that help teams ship features in parallel.
Luau Events Middleware Debugging

Small examples that show real system shape.

Public snippets showing naming, API design, and engineering boundaries.

Public code proof

Hit validation rules

Hitbox-Plus server excerpt for authoritative combat validation.

Server validation rule: distance + cooldown gating
if request.attackerPosition ~= nil then
    local distance = SpatialMath.distance(
        request.attackerPosition,
        candidate.position
    )

    if distance > self.maxDistance then
        return false, Types.RejectReason.MaxDistance, {
            distance = distance,
        }
    end
end

if self.targetCooldownSeconds > 0 then
    local key = string.format(
        '%s::%s',
        tostring(request.attackerId),
        tostring(candidate.id)
    )
    local lastAcceptedAt = self.targetHitTimes[key]

    if lastAcceptedAt ~= nil
        and request.serverTime - lastAcceptedAt <= self.targetCooldownSeconds
    then
        return false,
            Types.RejectReason.TargetCooldown,
            { lastAcceptedAt = lastAcceptedAt }
    end
end
Source file ↗
Public code proof

NPC Coordination Model

Pathfinding-Plus excerpt for throttled NPC path requests across registered navigators.

Coordinator loop with request throttling
function Coordinator:_ensureLoop()
    if self._loopRunning or self._destroyed then
        return
    end

    self._loopRunning = true

    task.spawn(function()
        while not self._destroyed do
            local now = os.clock()

            if now >= self._nextGlobalIssueAt then
                local request = self._queue:PopReady(now)
                if request ~= nil then
                    self._nextGlobalIssueAt = now + self._requestInterval
                    local ok, result = pcall(request.execute)
                    request.callback(ok, result)
                elseif self._queue:GetSize() == 0 then
                    self._loopRunning = false
                    return
                end
            end

            task.wait(self._pollInterval)
        end
    end)
end
Source file ↗
Engineering proof

Authoritative Combat Validation Flow

Shows how responsive client input becomes a server-owned combat result without trusting raw client state.

Authority boundary enforcement
Client request

Build attack intent and local timing data close to player input.

Validation rules

Check latency, distance, duplicate attacks, teams, cooldowns, and optional line-of-sight.

Snapshot rewind

Resolve the hit against stored state instead of trusting the latest frame blindly.

Authoritative result

Return accepted hits and rejections in a structure gameplay code can use and debug.

Tooling and applied Roblox work.

Tooling, playable showcases, and applied gameplay work behind the core code proof.

StudioGit showcase video Walkthrough of the StudioGit plugin.

Tooling work 01 · Studio workflow automation

StudioGit

GitHub-style workflow tooling for Roblox Studio, built to keep common project actions inside the editor.

What it is
GitHub-style workflow plugin for Roblox Studio.
What I built
Built plugin UI, in-editor project actions, and workflow shortcuts.
Problem it solves
Brings source-control-style project workflow into Roblox Studio instead of forcing tool switching.
Impact
Turns repeated Studio project work into repeatable GitHub-like plugin actions.
Before tooling 6-8 manual steps

Find project state, switch tools, then repeat the same workflow by hand.

After tooling 1 in-Studio flow

Common GitHub-style actions happen from one plugin surface inside Roblox Studio.

Workflow impact ~50% less context switching

Estimated reduction from keeping repeated actions inside the editor.

Estimated
Luau Studio plugin GitHub-style workflow Developer UX
Portfolio Examples showcase video Technical showcase capture from the portfolio place.

Showcase work 02 · playable technical systems

Portfolio Examples

Playable Roblox showcase for rendering, mesh, and technical systems experiments.

What it is
Public Roblox place for technical system demonstrations.
What I built
Built ocean simulation, screen shader tests, mesh tools, and custom content workflows.
Problem it solves
Lets reviewers judge technical work in motion instead of reading static claims.
Impact
Shows Roblox engine range beyond gameplay footage.
3D ocean simulation Screen shaders Mesh tools Roblox
Open experience ↗
Taxi Fare showcase video Gameplay capture from Taxi Fare.

Applied gameplay 03 · vehicle systems

Taxi Fare

Vehicle systems focused on driving feel, rewards, and progression feedback.

What it is
Vehicle gameplay systems for a Roblox driving experience.
What I built
Built and tuned driving feel, reward feedback, and progression-facing gameplay logic.
Problem it solves
Turns vehicle controls and reward feedback into readable moment-to-moment gameplay.
Impact
Shows applied gameplay delivery beside the public library work.
Roblox Gameplay systems Production delivery Live systems

Floppy PVP

The clearest single example of how I think about combat design, system boundaries, and multiplayer trust.

Floppy PVP case study video Prototype combat capture with sprinting, strikes, knockback, and ragdolling.
Engineering proof

Combat State Architecture

Maps a ragdoll PvP prototype into tunable layers so input, validation, and feedback stay separate.

Combat flow: state, attacks, validation, feedback
Movement & stance state

Sprinting and stability values define pressure and vulnerability.

Attack input layer

Left/right punches, kicks, and headbutts use explicit startup, active, and recovery windows.

Networking & validation

Responsive input feeds bounded server damage and knockback checks.

Outcome feedback

Damage, stance loss, and ragdoll states produce readable swings.

Before 1 mixed prototype loop

Movement, attack input, hit response, and feedback shared one tuning surface.

After 4 explicit combat layers

Movement state, attack windows, validation, and feedback tune independently.

Constraints 3 attack phases + server-owned damage

Startup, active, and recovery windows stay responsive while force remains bounded.

Design

Readable combat first

Limited move set: sprint, left punch, right punch, kick, headbutt. Spacing and timing come before move count.

Architecture

Separate the layers

Movement, attack input, hit resolution, and feedback each own separate state.

Networking

Responsive without blind trust

Local input stays responsive. Server code bounds damage, force, hit zones, and state transitions.

Outcome

Prototype with production constraints

Exposes tuning values for phase timing, knockback force, stance loss, and ragdoll thresholds.

Hiring signal

Available for Roblox gameplay / systems roles

Best fit: combat systems, networking, tooling, live game systems.

Combat systems Networking Tooling Live game systems
Systems-focused

Built for teams, not one-off demos

Architecture is meant to survive updates, handoffs, and the reality of live Roblox production.

Live experience

Production awareness changes the engineering bar

Doomed 2 Die and STO shaped how I design for concurrency, release pressure, and maintainable handoff.

Team speed

Maintainability is part of the deliverable

Reusable tools, explicit APIs, and system boundaries reduce rewrite risk during handoff.

Contact

Need a Roblox systems developer who ships production code?

Available for Roblox gameplay, systems, and tooling work. Message me on Discord for team roles, contract work, or project delivery. Use the GitHub section above for public code proof.