Damian Saelee | GPU Programming, ML, and Systems Portfolio

Projects

Selected engineering work.

Selected projects focused on performance, systems design, and measurable engineering results.

Project 01

CUDA-Accelerated Mandelbrot Renderer

374 ms → 1.0 ms per render. Approximately 370× faster.

CUDA Mandelbrot renderer with smooth deep-zoom support, Nsight and NVTX profiling, and a measured ~370x speedup over the single-threaded CPU path.

GitHub Technical Details

Implementation notes Parallel rendering & profiling

Built a Mandelbrot renderer in C++ and CUDA that maps pixels independently across the GPU, enabling smooth real-time zooming and deeper fractal renders without the frame stalls of the original CPU path.

Instrumented the render loop with NVIDIA Nsight Systems and NVTX markers to trace both CPU and GPU execution. Profiling exposed a state-management bug where ComplexPlane::updateRender() kept rerunning because the app failed to transition from CALCULATING to DISPLAYING, causing unnecessary recomputation every frame.

After fixing the render-state transition and validating the CUDA path, full-frame time dropped from about 374 ms on CPU to about 1.0 ms on GPU, with the Mandelbrot kernel taking about 0.87 ms and the remaining ~0.13 ms spent in CPU-side post-processing and vertex/color updates. The project emphasizes parallel work distribution, profiling-led debugging, and measurable throughput gains backed by traces.

Distributed per-pixel escape-time computation across the GPU for parallel fractal generation
Used Nsight Systems and NVTX to isolate redundant recomputation in the render loop
Quantified remaining CPU-side post-processing after the kernel to guide next optimizations

Profiler evidence Nsight Systems · select an image to inspect

Nsight Systems timeline showing repeated executions of ComplexPlane updateRender caused by failing to transition from CALCULATING to DISPLAYING. — Trace issue **Repeated updateRender calls from a state-transition bug** The missing state transition triggered a full recomputation on every render loop.

Nsight Systems timing view for ComplexPlane updateRender on the CPU showing about 374 milliseconds for a single full-frame Mandelbrot computation. — CPU path **CPU timing: ~374 ms per full-frame render** Single-threaded baseline for a full-frame Mandelbrot computation.

Nsight Systems timing view for ComplexPlane updateRender on the GPU showing about 1.0 milliseconds total with roughly 0.87 milliseconds in the CUDA kernel. — GPU path **GPU timing: ~1.0 ms total with ~0.87 ms in the CUDA kernel** About 0.87 ms in the CUDA kernel; the remaining ~0.13 ms is CPU-side work.

Project 02

GPU-Accelerated Pokémon Card Classifier

199.871 s → 66.714 s over five epochs. 66.6% less training time.

End-to-end ML systems project combining asynchronous dataset collection, label normalization, ResNet-18 fine-tuning, and Nsight-driven throughput optimization.

GitHub Technical Details

Implementation notes Dataset & training pipeline

Built a Pokémon card image classification pipeline in Python using PyTorch, Torchvision, and CUDA, with asynchronous dataset collection through TCGdex and aiohttp plus automated train/validation/test organization.

Added label normalization to collapse noisy card names and card-specific variants into base Pokémon identities, which kept the supervised dataset more consistent and reduced label noise during training.

Profiled GPU execution and CPU-side input stalls with NVIDIA Nsight Systems and NVTX markers, then tuned the DataLoader pipeline instead of treating model code as the only bottleneck. The final 5-epoch run dropped from 199.871 s to 66.714 s, a 66.6% runtime reduction and roughly 3.0x speedup driven by better worker settings, persistent workers, pinned memory, non-blocking transfers, and prefetch_factor=4.

Collected card images asynchronously with TCGdex and aiohttp
Normalized labels like card variants into base Pokémon identities
Used Nsight Systems plus NVTX to tune DataLoader throughput, not just model code

Profiler evidence Nsight Systems · select an image to inspect

Nsight Systems timeline for the baseline Pokémon card classifier training run showing a total runtime of about 199.871 seconds. — Baseline **5-epoch training run: 199.871 s** Original pipeline before DataLoader and transfer tuning.

Nsight Systems timeline for the optimized Pokémon card classifier training run showing a total runtime of about 66.714 seconds. — Optimized **5-epoch training run: 66.714 s** Tuned workers, pinned memory, non-blocking transfers, and prefetching.

Project 03

Multiplayer Zombie RTS / Survival Game

Server-authoritative NGO + PlayFab/Azure flow with zombie LOD scaling for 300+ enemies

Server-authoritative Unity co-op survival project with dedicated server orchestration, PlayFab and Azure matchmaking flow, and LOD-based zombie synchronization for large AI counts.

GitHub Technical Details

Implementation notes Networking & deployment

Built a top-down co-op zombie survival and extraction game in Unity using Netcode for GameObjects, centered on server-authoritative gameplay where clients send inputs via ServerRpc and receive replicated state through NetworkVariables and ClientRpc.

Extended the project beyond local multiplayer by wiring a dedicated server flow through PlayFab login and matchmaking, an Azure Function that handles server allocation and a Dockerized PlayFab server build managed through GSDK lifecycle callbacks and NGO startup.

Focused heavily on simulation cost and network overhead. A custom ZombieSyncManager applies a 3-tier LOD strategy that reduces AI update frequency and disables NetworkTransform for distant zombies, helping the game scale to 300+ zombies while profiling at about 0.15 ms for 203 simultaneous zombies. Server testing on a 2 vCPU PlayFab VM ran at roughly 18% CPU and ~300 MB memory with 300 zombies active.

Implemented server-authoritative units, projectiles, damage, and zombie AI
Built a PlayFab plus Azure Functions allocation path for dedicated multiplayer servers
Optimized AI and sync cost with a 3-tier zombie LOD system for large enemy counts

Architecture snapshot Dedicated server flow, gameplay authority, and scale-focused systems design

Players + PlayFab login and matchmaking Dedicated Unity NGO server with server-authoritative simulation Azure Function allocation plus PlayFab Multiplayer Servers

ServerRpc, ClientRpc, and NetworkVariables drive authoritative gameplay sync ZombieSyncManager LOD tiers reduce AI and network cost as zombie counts rise Dockerized server builds integrate with the PlayFab GSDK lifecycle and cloud deployment flow

About

Curiosity, backed by implementation.

I am a Computer Science student who enjoys building performance-oriented software across GPU computing, machine learning systems, multiplayer game architecture, and systems-oriented development. I am especially interested in work that involves profiling, identifying bottlenecks, and improving throughput instead of stopping once something merely runs.

What I like working on

GPU acceleration, ML training and inference pipelines, systems-level optimization, multiplayer architecture, and software that benefits from careful measurement.

Engineering approach

I design and build systems around clear requirements, then profile bottlenecks, make targeted improvements, and validate the result with timing data, traces, or throughput measurements.

Core technical toolkit

C++, Python, C#, CUDA, PyTorch, Unity, NVIDIA Nsight Systems, NVTX, Docker, Git, and supporting ML/data tooling.

Skills

The tools behind the work.

Primary stack

Systems / Performance

ML / Data

Multiplayer / Runtime

Supporting tools

Resume

A closer look at my experience.

Technical projects, practical tools, and measured engineering results.

View Resume Open PDF

Contact

Let’s build something useful.

Open to conversations about software engineering, systems, and machine learning. Connect with me on LinkedIn.

GitHub

Explore my GitHub Repositories, source code, and technical write-ups

Connect on LinkedIn Background, experience, and recruiting contact

Damian Saelee.

Selected engineering work.

CUDA-Accelerated Mandelbrot Renderer

GPU-Accelerated Pokémon Card Classifier

Multiplayer Zombie RTS / Survival Game

Curiosity, backed by implementation.

The tools behind the work.

A closer look at my experience.

Let’s build something useful.