workspace/src/piloh/portfolio
>about.luau

Compiler Warning: LINTER_UNDERAGE_DEV

Notice: Currently an underage developer. Please keep this in mind for legal and contractual purposes regarding commissions or long-term commitments.

// Execution Context

Self-taught developer since late 2021, starting with Roblox Studio and C++. After years of building foundational systems and successfully delivering custom commissions, I am currently scaling up and transitioning to a stable part-time or full-time development role, but I don't mind still taking on commissions.

--> "Engineering scalable, deterministic game systems within the Roblox ecosystem."

developer.config.json
{
"availability": "During the day (UTC+2) 7 days/week",
"languages": ["English"],
"fastest_contact": {
"discord": "piloh"
}
}
>skills.config

Low-Level & Engines

C++VulkanMemory ManagementCMake

Luau & Roblox Ecosystem

Parallel LuauRojoWallyKnitProfileService

Math & Algorithms

Perlin NoiseOctreesKinematicsRaycasting3D Matrix Math

Architecture

FSMClean ArchitectureRPC OptimizationPromise
>projects.json
Custom C++ 3D Engine & Luau VM
Graphics & Scripting

Custom C++ 3D Engine & Luau VM

Developed a custom low-level 3D game engine using Vulkan API with a strict focus on Data-Oriented Design. Focused on a low-overhead Vulkan rendering pipeline, emphasizing Data-Oriented Design (DOD) to maximize CPU cache spatial coherence. The Entity Component System (ECS) architecture, implemented using the EnTT library, was utilized for the deterministic separation of game state and logic, enabling high-performance, zero-cost iteration over massive structural datasets. Built a non-linear scene graph based on spatial relational components and integrated it with the continuous collision detection engine of the ReactPhysics3D library. Dynamic spatial transformations are reconciled via a custom three-phase pipeline (kinematic propagation, numerical physics update, and upward verification pass for raycasting vectors). The native runtime was extended with a fully sandboxed Luau VM with asynchronous function binding, enabling safe behavior hot-reloading in real-time without re-linking binaries. Tooling includes runtime dynamic type reflection, allowing the custom ImGui-based editor to automatically instantiate inspector panels and explorers for arbitrarily declared, memory-allocated components. Real-world durability is achieved via a custom snapshot serialization algorithm coupled with a heap manager abstraction that restores deserialized stale pointers within the physics engine.

C++VulkanEnTTReactPhysics3DLuau+2
heropeak_generator_script.lua
local isWorker = script.Parent and script.Parent:IsA("Actor")

if isWorker then
	-- BACKGROUND WORKER LOGIC
	local actor = script.Parent :: Actor
	local ProgressEvent = actor:WaitForChild("ProgressEve...
Procedural Generation

80k x 80k Procedural Voxel Generation

Designed and implemented a highly optimized, multi-threaded procedural generation system capable of deterministically synthesizing giant voxel landscapes spanning 80,000 by 80,000 spatial units. The architecture utilizes a distributed, asynchronous Actor-Pull model in the Parallel Luau ecosystem, where a central dispatcher coordinates task prioritization using a spiral index mapping algorithm. SharedTable structures are utilized to pass data between threads with zero memory-copying overhead. Terrain topology is evaluated using multi-octave Perlin noise integrated with multi-dimensional domain warping, applying non-linear mathematical filters to eliminate vector singularities and grid artifacts at coordinate extremes. To circumvent the platform's strict memory allocation constraints (which would otherwise result in a 26GB memory footprint), I designed a dynamic shell thickness estimator to prune the internal octree. By analyzing local topological gradients, the system dynamically adjusts octree depths, forcing Empty Mips compression in deep subterranean structures while preserving fine details on high-contrast vertical cliffs. Additional features include custom I/O pathways that bypass standard diagnostic memory dump cycles, a failsafe deadlock detection subsystem, and a hybrid plugin context that allows direct serialization of billions of voxels to static persistent memory.

Parallel LuauOctreePerlin NoiseActor-Pull
ParanoiaManager.luau
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local Knit = require(ReplicatedStorage.Packa...
Architecture

Asymmetric Psychological Horror Architecture

Designed and implemented a production-grade, highly modular systems architecture for an asymmetric psychological horror game using the Luau language. Using Rojo for environment management and Wally for package dependencies, the business logic was completely isolated from visual components. Client-server communications are managed via Knit RPC services, minimizing transmission payload overhead. Data persistence is managed via ProfileService, integrating session-locking and Promise-based exception handlers to eliminate race conditions. The user interface was built using the Fusion library, yielding declarative, reactive HUD components that avoid manual tree mutations. Built a multi-threaded player proximity profiling engine running on the Heartbeat cycle. The dynamic isolation indices are calculated in real-time to drive sensory payloads on client devices. Implemented an artificial latency simulation (fake lag) system through busy-waiting locks in the RenderStepped loop, as well as an algorithmic spatial audio deconstruction filter utilizing non-linear TweenService interpolation. Developed a real-time text obfuscation parser that uses stochastic variables to emulate typoglycemia and typing latency, injecting modified packets directly into the client's TextChatService.

LuauRojoWallyKnitProfileService+1
M1Service.luau
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace"...
Gameplay Framework

Deterministic Melee Combat Framework

Engineered a robust, deterministic melee combat framework using Rojo and Wally. Orchestrated game state transitions via custom asynchronous loops and Promises. The core includes a character kinematics controller overriding default physics behavior in favor of custom momentum vector manipulation. Designed strict spatial validation, blocking jump/dash combinations on the Y-axis when the avatar is airborne. Built a fatigue calculator that decays jump velocity on successive inputs, enforcing a non-linear respiratory cooldown. Hit registration features directional validation based on the dot product of relative player vectors. Frontal-cone block state procedurally absorbs damage, while rear attacks bypass defense and trigger speed-throttling. The strike sequences are driven by a Finite State Machine (FSM) enabling smooth, low-latency chaining between dashes and M1 attacks. Implemented a separate local camera controller utilizing rotation matrices for unrestricted view angles during translation movements. Designed an asynchronous HUD that subscribes directly to cooldown states, utilizing UIGradient clipping masks to display millisecond-accurate skill recovery. Procedural rendering effects are triggered asynchronously upon hit validation.

LuauRojoPromisesFSMRaycasting
Advanced Movement & Animation System
Animation & Movement

Advanced Movement & Animation System

Developed a comprehensive movement and locomotion system based on a custom character state coordinator and a dynamic animation controller. The primary challenge lay in integrating over 30 separate animations (sprinting, sliding, dashing, vaulting, landing) and ensuring seamless blending and transition states. Constructed a user input routing layer mapping keystrokes to specific physical forces. Implemented a central state coordinator to handle execution priorities and eliminate state conflicts (e.g., preventing sliding during a mid-air dash). Built an animation manager to synchronize physical states with appropriate AnimationTracks. The manager handles track weights, playback priority levels, and transition smoothing to avoid visual snaps. Optimized client performance by minimizing concurrently active animation tracks. Individual physics sub-modules handle specialized movement forces, including slide friction and dash velocity vectors. Built modularly to allow simple additions of new actions. The final product resembles mechanics found in modern fast-paced action titles, delivering high responsiveness, clean animation blending, and modular scalability.

Roblox APIState MachineAnimationTracks
>reviews.log

// Please contact me (e.g., on Discord or via email) if you would like to leave a review.

4.5/5

Insane work on the combat framework. The movement feels buttery smooth. Totally worth the price, took a bit longer to iron out the bugs. 4.5/5

V
@VoidWalker
5/5

Bro's low level knowledge is crazy. Helped me optimize my voxel game from 20fps to steady 60. Highly recommend. 5/5

D
@Dev_Alex
5/5

Very professional. The custom Luau VM integration was exactly what our engine needed. Clean code, well documented. 5/5

S
Studio Lead (NDA)
5/5

The horror systems he coded are terrifyingly good. Fake lag and audio manipulation worked flawlessly on production. 5/5

N
@NightmareDev
>contact.sh
contact.shUTF-8
const contact = {
  discord: "piloh",
  email: "piloh8907@gmail.com",
  roblox: "roblox.com/users/1310143767",
  github: "github.com/PilohWhy",
  status: "Looking for complex commission work."
}