Here are my Projects

Collaborated in a team of four on an Assetto Corsa telemetry pipeline with Python/Lua collection, a Go and SQLite backend, and a Unity dashboard for lap playback, vehicle-position replay, and performance charts.

• C#
• Unity
• Go
• SQLite
• Python
• Lua

Jan 2026 - Apr 2026

Technical work

• Built and iterated on the Unity TrackSide analyzer, including packet playback, speed/throttle/brake/steering charts, and car-position replay on generated track maps.
• Integrated the Unity front end with a Go HTTP server and SQLite database, including demo-build work to bundle and launch the backend alongside the analyzer.
• Created Assetto Corsa telemetry collection tooling in Python/Lua to capture lap and vehicle data for ingestion into the database pipeline.
• Worked across telemetry schemas for packets, laps, tires, and vehicle dynamics. Earlier pipeline variants used PostgreSQL; the Unity analyzer uses SQLite.

Built a Python/PyTorch racing agent for Assetto Corsa using Soft Actor-Critic. The main implementation combines a Gymnasium environment, shared-memory telemetry, vJoy driving controls, and racing-line rewards.

• Python
• PyTorch
• Gymnasium
• NumPy
• TensorBoard
• vJoy

Jan 2026 - Apr 2026

Technical work

• Implemented SAC training with n-step replay, TensorBoard metrics, model checkpoints, and training/evaluation tools.
• Implemented reward and curriculum logic around forward progress, racing-line distance, border risk, low-speed/off-track termination, action smoothness, and lap-completion bonuses.
• Extended the experimental BernoulliShift branch with demonstration-aware replay, Q-filtered behavior cloning, discrete shift policies, action masks, and training-state restoration. That branch uses Gym and ViGEm controls.
• Added demonstration recording/visualization tools and shifter, replay, and checkpoint tests in BernoulliShift.

Built a server-authoritative tactical AI prototype in Roblox. Agents use goal-oriented action planning, vision and sound sensing, and individual memory to search, fight, reload, and use cover.

• Luau
• Roblox
• Rojo
• React Lua
• NoobPath

Jul 2026 - Aug 2026

Technical work

• Implemented bounded, cost-based GOAP planning with per-agent beliefs and action execution.
• Integrated NoobPath movement and SPEARHEAD weapon control for cover-based combat.
• Built a React Lua debug panel for inspecting plans, beliefs, actions, and planner logs.

Built a marketplace for storyboard artists and filmmakers with portfolio profiles, filtered discovery, Google sign-in, and project applications. The current React/TypeScript app uses Vercel Functions and Supabase-hosted PostgreSQL.

• TypeScript
• React
• Tailwind CSS
• Vercel Functions
• Supabase
• PostgreSQL
• Vitest

Technical work

• Built the React/TypeScript frontend with artist/filmmaker entry paths, filterable discovery grids, profile pages, cards, and detail modals.
• Implemented Vercel serverless APIs for artists, projects, applications, profiles, featured content, and filter-count endpoints backed by Supabase/PostgreSQL.
• Integrated Google OAuth and JWT-based auth for sign-in, persisted sessions, protected profile editing, and project application flows.
• Modeled relational data for users, artists, portfolios, projects, applications, counts, indexes, and triggers, with Vitest coverage for key API utilities.

Built a statically typed language and JavaScript compiler using Ohm.js and Node.js. The repository also includes a separate Next.js/React showcase written in TypeScript.

• JavaScript
• Node.js
• Ohm.js
• Next.js
• React
• TypeScript

Technical work

• Implemented the compiler pipeline from grammar parsing through semantic analysis, optimization, and JavaScript code generation.
• Defined language support for typed variables, functions, recursion, arrays, control flow, loops, type casts, boolean logic, and arithmetic expressions.
• Built semantic checks for scope resolution, redeclarations, type compatibility, function arguments, loop-only breaks, return validation, and array indexing.
• Added automated parser, analyzer, generator, optimizer, and compiler tests covering valid programs, semantic errors, generated JavaScript, and constant-folding behavior.

Built a custom 3D graphics framework and demo scene directly on WebGL, implementing meshes, transforms, camera projection, lighting, animation, and interaction without three.js.

• JavaScript
• React
• Vite
• WebGL
• GLSL
• HTML Canvas
• Vitest

Technical work

• Owned credited geometry work for the Box, Freddy, and Fan assets, including custom mesh generation and imported JSON meshes used in the rendered scene.
• Implemented credited scaling and perspective matrix functionality, helping the engine support object transforms and projected 3D world space.
• Contributed to final scene behavior and movement integration, including animated objects and keyboard-driven navigation in the WebGL canvas.
• Helped build a reusable graphics architecture with mesh data, object/group transforms, camera support, shaders, and render-loop orchestration.

Built an Assetto Corsa Lua app with an in-game telemetry panel and car-centered track map, alongside a prototype Go/SQLite backend for telemetry storage and queries.

• Lua
• Go
• SQLite
• Custom Shaders Patch
• LuaSocket

Technical work

• Implemented the Assetto Corsa app manifest and Lua callback lifecycle for window rendering, UI pre-rendering, and simulation update hooks.
• Built reusable UI primitives for transparent panels, centered text, image rendering, click handling, custom fonts, and rotating map assets.
• Mapped live car position and heading onto Assetto Corsa track map assets using map.ini scaling/offset data, with mouse-wheel zoom support.
• Added collect/unlink controls and prototype CSV streaming through LuaSocket, alongside a separate Go HTTP service for SQLite storage and queries.

Built a Unity prototype that generates terrain at runtime and updates world chunks as the player moves.

• C#
• Unity

Technical work

• Used Unity Terrain for runtime environment generation.
• Organized world updates around terrain chunks during play.

A Unity first-person action-puzzle game with a timestamp-based rewind system for NPCs and physics objects. Players restore earlier states to solve timing, combat, and traversal encounters.

• C#
• Unity
• WebGL
• NavMesh
• Input System

Technical work

• Built a timestamp-based rewind framework for NPCs and physics objects, restoring position, rotation, velocity, health, AI steps, and activation state during reverse playback.
• Implemented first-person movement, camera look, sprint/crouch/jump, pickup/drop interactions, ammo collection, reload flow, recoil, tracers, and hit effects.
• Scripted NavMesh enemy agents with patrol/instruction sequences, FOV and line-of-sight raycasts, alert propagation, combat states, animations, and rewind-safe freezing/restoration.
• Created rewind-aware level objects including timed doors, falling rocks, physics boxes, explosive props, HUD clock/playback indicators, pause flow, and audio feedback.

A 48-hour Unity action-stealth game with wall-gripping movement, a charge-limited time-slowing ability, and GOAP-driven guards. Players escape containment by navigating surfaces and managing their eye power.

• C#
• Unity
• URP
• Input System
• Tilemap

Technical work

• Implemented wall-adjacent movement with Rigidbody2D physics, surface trigger detection, gravity toggling, and pooled tendril particle attachments.
• Built a charge-based eye mechanic that drains/recharges, slows global time, boosts player responsiveness, and drives vignette, UI, and audio feedback.
• Created factory-composed enemy behaviors using sensors, beliefs, goals, actions, and a GOAP-style planner for patrol, chase, shooting, melee, and idle states.
• Shipped HUD/menu flow with Input System events, health/eye bars, pause/restart/menu routing, and an escape/end-state typing sequence.

A Unity chase game with physics-based movement, escalating enemy pressure, and chunked procedural terrain. World generation uses Burst/Jobs and pooled terrain and structures.

• C#
• Unity
• Cinemachine
• Unity Behavior
• Burst
• Unity Jobs

Technical work

• Built a Rigidbody-based horse controller with sprinting, jumping, mouse-look camera targeting, follow-direction steering, and speed/jump scaling by player level.
• Implemented the progression loop: pickups increase a decaying resource, trigger level changes, swap music layers, update UI bars, and drive the win/fail sequence.
• Created wanted-level enemy escalation with spawn caps, weighted enemy selection, culling, score rewards, darts, goo slow effects, cop-car knockback, and UI star feedback.
• Developed chunked procedural terrain using Perlin height maps, Burst/Jobs smoothing, terrain/detail/tree placement, structure collision spacing, and pooled terrain/structure reuse.

A 48-hour Unity action prototype built around absorbing NPCs, growing in size, and destroying the environment. Includes NPC pursuit and flee behavior, pooled spawning, and blood effects.

• C#
• Unity
• URP
• Cinemachine
• Input System

Technical work

• Implemented a growth loop where NPC collisions add health, scale the player model, increase Rigidbody mass, and update the blood gauge UI.
• Built civilian flee behavior, cop pursuit/shooting behavior, bullet damage, and pooled NPC spawning/despawning around the player.
• Created splatter and blood-trail systems using randomized decals, pooled blood pools, timed trail stamping, and particle/audio feedback.
• Added destructible buildings and props gated by player size, including sinking destruction sequences, rubble particles, NPC release, and a final win condition.

A Unity crafting and combat game where players paint and enchant a sword, then wield it in physics-driven fights. Custom weapons persist as PNG/JSON data and load with generated 2D colliders.

• C#
• Unity
• WebGL
• URP
• Input System

Technical work

• Built a blacksmith painting system with draw, fill, erase, hilt-mask, and elemental brush tools, including weight tracking and gold-based enchantment costs.
• Saved crafted weapons as runtime PNG and JSON data, then reloaded them into later scenes as playable sprites with generated PolygonCollider2D hitboxes.
• Implemented physics-driven combat where mouse-swinging a weapon can damage enemies, propel the player, and trigger fire, ice, lightning, and bomb effects.
• Connected dialogue, customer weight limits, scale-result videos/animations, fight outcomes, gold rewards, music, and scene transitions through persistent game state.