ModuleXC — ARGEMI STATION // DEV TERMINAL

PERSONNEL FILE

Who I am & what I do

I'm ModuleXC — a Roblox developer with 6 years of hands-on experience building complex systems from scratch. Started in 2019 with no English, no mentor — just raw curiosity and a lot of broken code. Like finding a signal out here in the dark and following it.

My focus is architecture and systems engineering — how code is structured, how it communicates, how it holds up under pressure. I build modular server/client frameworks, custom network layers, and security systems that actually work.

Beyond Roblox, I'm growing into general software development — studying reverse engineering, executors, and low-level security. Building toward running my own dev operation. The station doesn't sleep.

OOPmetatablesnetwork layers anti-cheatreverse engineeringmodular arch

profile.lua

1-- developer profile

3name = "ModuleXC"

4role = "Systems Dev"

5since = 2019

7lang = "Lua / Luau"

8focus = "Architecture"

9status = "ACTIVE"

10location = "Ukraine"

11votv_fan = true

12-- sleep_schedule = nil

ARGEMI-07ONLINE

STATION REPORT

Signal strength████████░░ 82%

Argemia detectedYES [PURPLE]

Lines of code written50,000+

Days until I sleep normallyUNKNOWN

Shrimp levelMAXIMUM 🦐

MISSION LOG

Projects I've shipped

2026
in progress

LARGE-SCALE SIMULATOR

Lead Developer · Architect · UI

Full modular architecture from scratch. Custom framework handling server/client communication, economy, progression, live events. Sole developer on a codebase that would normally require a team. Shipping soon.

LuaArchitectureSimulatorSolo

2025

TERRIBLE MOUSE ROLEPLAY

Systems Developer · Security

Full codebase refactor of a live game. Built a custom anti-cheat that blocked all known exploit vectors. The game was previously crashable by any player — that's no longer possible.

Anti-cheatRefactorSecurityLive

2025

RETROTRAP: TIME LEAK

Hired via TalentHub · Scripter

Contracted through TalentHub. Built action-style movement and mechanics for an RPG project. First time engineering that specific combination of systems — delivered on spec.

TalentHubRPGCombat

2025

KIVOTOS TOWER DEFENSE

Systems Developer

Reverse-engineered an 11-developer codebase, rewrote key systems, fixed architecture, improved performance. Left after reliability concerns — but the work shipped.

RefactorTDSConcluded

2023

BATTLEGROUND PROJECT

Solo Developer

Solo-built and launched a Battleground, assembled a test team. Spread too thin, discontinued. Painful — but it made architecture make sense on a deeper level.

SoloDiscontinuedLesson

DOCTRINE FILE

How I build

Don't trust the client. Make it pretty for the client.

Server validates. Client gets the smooth toast and the spinning loader. Both win.

Two or three remotes are enough. Stop spawning new ones.

Every project has the same payload shapes — route them through one entry. Less surface, less drift.

Modules are friends, not strangers.

Coupling is fine when it's intentional. Pretending modules are isolated when they aren't is worse than admitting the dependency.

OOP in Luau is ugly. Use it anyway. Scale demands it.

Metatables look weird, but a project past 5k lines without classes turns into a swamp. Pick the swamp you can drain.

One RemoteFunction router. Everything flows through it.

Server-side dispatcher with rate limits and validation per route. Adding a new feature shouldn't require new infrastructure.

Use the right tool. Heartbeat:Wait() beats task.wait(0.1).

"Roughly waits a tenth of a second" is not a behaviour. Frame-locked is.

If a module breaks 300 lines, it's doing two things.

Length is a smell, not a rule. But the smell is usually right.

POST-MORTEM ARCHIVE

Bugs I caught

INCIDENT-001 RESOLVED LEGACY · YEARS-OLD CODE

SYMPTOM

TDS enemies jittered visibly every frame. Looked like the game was lagging, but FPS was fine.

DIAGNOSIS

Position update loop used task.wait(0.1). The actual interval drifted with frame load — sometimes 80ms, sometimes 130ms. Interpolation between waypoints assumed a constant tick. It was not constant. The lie was visible.

FIX

Killed all task.wait in the movement hot path. Rebound to RunService.Heartbeat. Used the dt argument to advance progress, instead of guessing.

CODE

BEFORE — drift accumulates, frames lie // reconstruction from memory

while enemy.Alive do
    task.wait(0.1)  -- "roughly" 100ms — never actually 100ms
    progress += 0.1 * enemy.Speed
    enemy.Model:SetPrimaryPartCFrame(path:GetCFrameAt(progress))
end

AFTER — frame-locked, dt-driven // reconstruction from memory

local conn
conn = RunService.Heartbeat:Connect(function(dt)
    if not enemy.Alive then conn:Disconnect() return end
    progress += dt * enemy.Speed
    enemy.Model:SetPrimaryPartCFrame(path:GetCFrameAt(progress))
end)

Frame-locked beats time-locked. Always.

INCIDENT-002 RESOLVED

SYMPTOM

Towers fired in wrong directions. Sometimes hits registered on players standing nowhere near the line of fire.

DIAGNOSIS

Tower rotation was server-authoritative. By the time the client rendered the model, the server's "current angle" was already 1–2 frames stale. Visual barrel pointed one way, hit-detection used another. Compounded by a half-finished Enemy AI that didn't gate friendly-fire — damage applied to whoever was closest to the bullet, including the player who placed the tower.

FIX

Split the system. Server now owns logic — when to fire, what to hit, who takes damage. Client owns show — rotation, animation, recoil. Wrote two new modules: AnimationUtil (generic tween/playback helpers) and Animator per tower type, listening for server signals like fire and idle. Friendly-fire gate moved server-side as part of the same pass.

Server owns the truth. Client owns the show.

INCIDENT-003 RESOLVED

SYMPTOM

Damage buffs worked numerically — towers dealt the boosted DPS — but the firing animation still played at base speed. Visually the tower looked broken: bullets came out between idle frames, with no shooting motion at all on faster cooldowns.

DIAGNOSIS

The buff was a free-floating variable on the side of the combat module. The Animator had no idea it existed. Cooldown dropped, animation length didn't.

FIX

Refactored the buff into a state table on the tower itself — every modifier now lives in one place. Animator reads from that state and scales playback speed proportionally to the active cooldown. animationSpeed = baseDuration / currentCooldown. One source of truth, two consumers.

State scattered is state mocked. Centralize or suffer.