Senior / Lead Unity Engineer — Systems · Multiplayer · VR

Enes Sahin

I build the systems that make games scale.

  • Shipped on Steam
  • 400K+ registered users
  • VR multiplayer
  • Building games since 13
Download CV View projects

01 / Featured projects

drag · scroll · arrow keys — click a card for the case study

02 / Systems map

No levels, no percentages. Where it matters, a node points at the shipped work that proves it.

Unity & Engine

  • GameObject architecture
  • DOTS / ECS
  • Jobs + Burst
  • Addressables used in: Cargo Simulator chunk streaming
  • Profiling

Architecture

  • Composition over inheritance
  • DI — Zenject / VContainer
  • SOLID
  • Modular assemblies used in: HG framework, 10+ titles

Multiplayer

  • Client-server model
  • Replication used in: Highstreet VR multiplayer
  • Prediction
  • Packing & compression

VR & Physics

  • IK
  • Joints & constraints used in: Highstreet VR combat
  • Interaction systems

AI & Procedural

  • FSM used in: Cargo Simulator delivery agents
  • Behavior trees
  • NavMesh
  • Procedural roads used in: Cargo Simulator

Backend & Tools

  • ASP.NET
  • MySQL / NoSQL
  • Firebase
  • CI/CD used in: HG Builder — 2+ hrs/day saved
  • Python

03 / Quest log

Experience, newest first.

  1. [2025–2026]

    NocturnForge — Lead Game Developer

    • Founded and led development of My Corp Cargo Simulator, an open-world simulation game, shipped solo on Steam.
    • Grid-based world streaming on Addressables with precision handling; ID-based entity system for decoupled, data-oriented gameplay.
    • IK-driven interaction, FSM + Behavior Tree AI, procedural roads and navigation; custom DI container and editor tooling.
    • Unity
    • C#
    • Addressables
    • Steam

  2. [2023–2025]

    Highstreet Market — Senior Unity Engineer

    • Multiplayer VR/PC physics interaction: full-body IK grabbing, equipping, and wearable-to-weapon transformations.
    • Custom joint/constraint handling that eliminated latency-induced jitter on handheld objects in networked VR.
    • GameObject + ECS/DOTS with Jobs + Burst; built reusable ECS testing infrastructure; mentored on architecture and testing.
    • Unity
    • VR
    • Multiplayer
    • DOTS

  3. [2021–2023]

    Hero Games — Senior Game Developer

    • Architected the Idle Arcade Framework — modular save/load, economy, progression, and live-ops systems behind 10+ shipped and soft-launched titles.
    • Built HG Builder, a Python CI/CD tool (Fastlane + Slack) saving the team 2+ hours daily across multi-project releases.
    • Led an AI-driven 3D conversational character using OpenAI GPT and Google Text-to-Speech.
    • Unity
    • C#
    • Python
    • CI/CD

  4. [2021]

    University projects — Computer Engineering

    • B.Sc. Computer Engineering, Yıldırım Beyazıt University, Ankara (2017–2021).
    • VR combat prototype (HTC Vive): physics-driven gladiator combat with modular weapons, eye-tracking targeting, and foveated rendering for stable VR frame rates.
    • CPU ray tracing engine built from scratch, replicating a GameObject-Component architecture — ray casting, lighting models, reflections.
    • VR
    • Eye tracking
    • Ray tracing

  5. [2019]

    Idle Fisher

    • Top-down idle simulation: automated fishing, resource collection, and progression, with FSM + NavMesh agents.
    • Scalable economy (resource conversion, upgrades, passive income), enemy AI combat, and ScriptableObject-driven data architecture.
    • Integrated analytics, ads, A/B testing, and leaderboards for live-ops.
    • Unity
    • FSM
    • NavMesh

  6. [2017]

    Idle Town — solo, a high-school hobby

    • Asynchronous multiplayer Telegram game: 400K+ registered users, 1K+ active.
    • PHP + MySQL backend on webhooks and cron jobs; PvE/PvP/boss combat, clans, hero equipment systems.
    • Leaderboards across progression metrics and in-game payments via Xsolla.
    • PHP
    • MySQL
    • Webhooks

04 / Achievements

05 / Contact

Open to: Senior/Lead Unity roles — multiplayer, systems, VR. Remote (based in Ankara, TR) · EN / AR / TR.

Email me Download CV GitHub

My Corp Cargo Simulator

NocturnForge · 2025–2026 · NocturnForge · Founder & Lead, solo-developed

Watch on YouTube

What it is

An open-world cargo simulation game for PC — founded and built solo under NocturnForge, and released into Early Access on Steam (published by No King Interactive). A grid-based streaming world with procedural roads, where the delivery loop — packages, inventory, vehicles, characters — runs on fully data-driven systems.

What I built

Architecture

  • Core → Systems → Gameplay layering with composition-based design, and a modular codebase structured with assembly definitions for long-term scalability.
  • ID-based entity system enabling decoupled, data-oriented gameplay: entities are addressed by stable IDs rather than object references, so simulation state stays consistent as the world streams in and out.
  • Custom DI container, logging, and data-driven configuration systems.

World & performance

  • Grid-based open-world streaming built on Addressables, with floating-point precision handling and chunking.
  • CPU and rendering optimization: batching, SetPass reduction, LODs, lighting, and continuous profiling.

Gameplay & AI

  • Core gameplay systems: inventory, packages, delivery, character customization.
  • IK-driven interaction system for dynamic hand placement and interaction.
  • AI with FSM and Behavior Trees, procedural roads, and navigation systems.

Tools

  • Editor tooling and config pipelines built for solo-scale iteration speed.

The hard part

Problem. An open world breaks two assumptions Unity makes: that positions are world-space floats (precision degrades with distance from the origin) and that a gameplay entity is a loaded GameObject (streaming means most of the world isn’t loaded at any given moment).

Constraint. Team size: one. There was no budget to fight the engine — every system had to work with Unity’s lifecycle, not against it, and still ship.

Solution. The ID-based entity system separates simulation state from the loaded representation. Entities exist as data whether or not their chunk is resident; GameObjects become disposable views that attach when a chunk streams in via Addressables and detach when it unloads, with precision handled at the chunking layer instead of raw world-space floats.

Result. The game shipped on Steam, built end-to-end by one engineer. The ambient scene on this site — routes, streaming, deliveries — is a toy version of these exact systems.

Highstreet: Calamity

Highstreet · 2023–2025 · Senior Unity Engineer · VR multiplayer physics & combat

Watch on YouTube

What it is

A class-based multiplayer VR roguelike brawler — play solo or in co-op, fighting through procedurally generated waves and bosses to build your character. It runs on Meta Quest, PC VR, and in the browser via WebGL. I owned physics-driven interaction and combat as Senior Unity Engineer (Jul 2023 – Sep 2025, remote).

What I built

Physics & interaction

  • Full-body IK-based interaction systems: grabbing, equipping, and wearable-to-weapon transformations for immersive VR gameplay.
  • Custom physics joint/constraint handling for held objects — replacing the default physics behavior so handheld items stay stable instead of jittering under network latency.
  • Modular, component-driven combat system built on the physics-interaction layer.

Multiplayer & performance

  • Developed and maintained live multiplayer VR systems on a client-server model where critical collision is server-authoritative (anti-cheat) while local VR hand interaction resolves on the client.
  • Worked across GameObject and ECS/DOTS, using Jobs + Burst for performance-critical systems.

Engineering practice

  • Built reusable ECS testing infrastructure — automated world setup and system-level unit testing.
  • Mentored developers on architecture and testing practices.

The hard part

Problem. A handheld object in networked VR is contested by three authorities: the local player’s hand, the physics engine, and the networked server state. With latency in the loop, default physics makes held objects visibly jitter — and in VR, jitter on something in your own hand is instantly nauseating and breaks the entire illusion.

Constraint. Critical collision runs server-authoritative to stop cheating, but combat needs held objects to respond crisply and both players to agree on hits — smoothing alone would make combat feel mushy.

Solution. Custom joint and constraint handling resolves the hand-object relationship locally and crisply, while server corrections are absorbed where the player can’t perceive them — keeping the client responsive without breaking server authority.

Result. Latency-induced jitter on handheld objects was eliminated, keeping VR combat physical and believable over the network across Quest, PC VR, and WebGL on a live, shipped title.

Idle Fisher

Personal project · 2019 · Personal · built solo as a student

Watch on YouTube

What it is

A top-down idle fishing simulation with automated fishing, resource collection, and progression. Boats and fishers run as autonomous agents; the economy converts caught resources into upgrades and passive income. Built solo in 2019 as a student project.

What I built

  • Autonomous agents (boats / fishers) driven by FSM + NavMesh for hands-off fishing and movement.
  • Scalable economy — resource conversion, upgrades, and passive/idle income.
  • Combat — enemy AI and projectile-based ship interactions.
  • Modular, data-driven architecture on ScriptableObjects.
  • Live-ops integration — analytics, ads, A/B testing, and leaderboards.

The hard part

Problem. “Idle” means the game keeps playing itself — agents have to fish, path, and fight believably whether or not the player is watching, with no hand-holding.

Solution. Each boat/fisher is modeled as an FSM over NavMesh so behavior is autonomous and composable, and balance is driven from ScriptableObject data so the economy can be tuned without touching code.

Result. A complete idle game with autonomous agents and a tunable economy — the 2019 groundwork for the idle/arcade systems I later built at Hero Games.

Ant Hilton Idle

Hero Games · 2021–2023 · Hero Games · Sole programmer

Watch on YouTube

What it is

A mobile idle mining game. Ant colonies dig through areas, extracting blocks that convert into gold. Gold funds upgrades — more ants, faster movement, and a better block-to-gold conversion rate — with sub-upgrades that stack to raise the gold each mined block yields. Clear an area and it’s replaced with an empty room you can fill with decorations; each decoration generates steady passive income scaled to its level, upgradeable up to a cap. At Hero Games I was the sole programmer, working alongside a game designer and an artist.

What I built

As the sole programmer, I built all of the game’s systems:

  • Idle mining loop — ant agents mining blocks, block-to-gold conversion, and offline/idle progression that keeps earning while the player is away.
  • Layered upgrade economy — ant count, movement speed, and conversion rate, plus stacking sub-upgrades that compound the gold earned per block.
  • Room & decoration system — completed areas convert into rooms; placeable, upgradeable decorations produce stable passive income by level, up to a max tier.
  • Mobile live-ops surface — ads, analytics, and IAP-ready monetization.

The hard part

Problem. An idle economy has to stay rewarding across wildly different time scales — the first minute and the hundredth hour — without stalling early or trivializing later. Two income sources (active mining plus passive decoration income) and compounding upgrade tiers make the numbers grow fast.

Solution. A data-driven economy where mining yield, conversion, and decoration income scale on tuned curves, and offline progression is computed from elapsed time rather than simulated — so returns feel fair whether the player was gone a minute or a day.

Result. A complete, released idle title, with all of its systems coded by one engineer.

Idle Town

Solo project · 2017 · Solo · a high-school hobby

What it is

An asynchronous multiplayer idle game played entirely inside Telegram, built solo as a hobby while still in high school. It reached 400K+ registered users with 1K+ active players — and, though a hobby, it was a genuinely commercial product.

What I built

Backend

  • The entire game server in PHP + MySQL, driven by webhooks and cron jobs.
  • Resource, building, and progression systems with upgrade pipelines and time-based mechanics.

Gameplay

  • PvE, PvP, and boss combat with player progression and scaling.
  • Clan system with shared progression and role-based management.
  • Hero system with equipment-based upgrades and power scaling.
  • Leaderboards and rankings across multiple progression metrics.

Live game

  • In-game payments via Xsolla — a real, commercial economy that earned $8,000+ in revenue, run solo.
  • Localized into 9 languages (English default), with professional translations.

The hard part

Problem. 400K+ registered users and 1K+ active players hitting a game that had no game servers in any traditional sense — just PHP, MySQL, cron jobs, and webhooks.

Constraint. One student, a student’s budget, and a stack chosen for being cheap to run rather than easy to scale.

Solution. Lean on the idle genre’s shape: state changes are either explicit player actions (webhooks, cheap to process one at a time) or time-based progression (computed in scheduled batches by cron instead of simulated continuously). The database does the multiplayer; nothing needs a persistent connection.

Result. The game served 400K+ registered users as a solo hobby project built in high school — and taught the systems thinking the rest of this portfolio is built on.

Nice Cream - Idle Tycoon

Hero Games · 2021–2023 · Hero Games · Gameplay engineer

Watch on YouTube

What it is

An idle dessert-shop tycoon: build an ice-cream empire, hire and automate staff — chefs, cashiers, waiters, baristas — unlock new products, and keep earning idle gold while you’re offline. Originally built at Hero Games; it’s currently live on the Play Store, relaunched under Leap Games. I worked on it as a gameplay engineer.

What I built

As a gameplay engineer on the team, I worked across:

  • Core gameplay systems and the idle production/sales loop.
  • Staff automation — the hire-and-automate managers that keep the shop running.
  • Performance optimization for the mobile target — keeping a screen full of staff, customers, and products smooth on low-end phones.
  • General feature work — whatever the game needed to ship and keep iterating.

Fashion Arcade Idle

Hero Games · 2021–2023 · Hero Games · Gameplay engineer

Watch on YouTube

What it is

An idle fashion-store tycoon. You run a clothing store: collect fabric, turn it into clothing, sell it, and reinvest — buying more racks to serve more customers and expanding the shop. Hire cashiers and fabric technicians to automate production and sales, and upgrade their speed as you scale. Built at Hero Games.

What I built

I built the game’s core fabric-weaving mechanic and its supporting systems:

  • Fabric weaving via dynamic mesh manipulation — the player moves over a piece of fabric and rolls it up, and the mesh deforms in real time until it becomes a finished piece of clothing. This was the game’s signature interaction.
  • Upgrade systems for production and shop scaling.
  • Staff automation — hiring and upgrading cashiers and fabric technicians (the workers that produce clothing), including their speed upgrades.

The hard part

Problem. The fabric-weaving mechanic had to feel physical and satisfying — fabric visibly rolling into clothing as you move over it — but run on mobile, where rebuilding mesh geometry every frame is exactly the kind of thing that tanks the frame rate.

Solution. Dynamic mesh manipulation that deforms and rolls the fabric mesh in real time as the player moves across it, kept cheap enough to stay smooth on the mobile target.

Result. A tactile signature mechanic — the core of how the game feels — running on phones.

Hide and Seek

Hero Games · 2021–2023 · Hero Games · Sole programmer

Watch on YouTube

What it is

A mobile arcade-idle infiltration game. You feed starter blocks into a machine that converts them into pickaxes, then deliver the pickaxes to a camp. Miners queue up, each grabs a pickaxe and moves to a ready zone; you collect the ready miners and lead them to the target zone. There, fields of unmined blocks sit under the gaze of patrolling guards — you paint each miner the right color so they blend in, mine a path to the gate, and once every block is cleared the miners open it. Past the gate they regroup, charge, and take out the remaining enemies. At Hero Games I was the sole programmer, working alongside a game designer and an artist.

What I built

As the sole programmer, I built every gameplay system:

  • Production pipeline — blocks into the conversion machine, pickaxes out, delivery to camp, and the miner queue that picks up tools and advances to the ready zone.
  • Miner agents and escort flow — collecting ready miners and leading them to the objective.
  • Stealth layer — guard patrol and vision, plus the color-matching mechanic that keeps correctly-painted miners unnoticed.
  • Mining, gate-unlock, and the end-of-zone charge-and-attack combat resolution.
  • Progression across zones and the mobile live-ops surface (ads, analytics, IAP).

The hard part

Problem. The game is really a pipeline of dependent stages — convert, deliver, queue, collect, escort, disguise, mine, breach, fight — where each stage feeds the next. If any stage stalls or desyncs (a miner with no pickaxe, a wrong-colored miner spotted), the whole loop jams.

Solution. Miners are modeled as small state machines moving through an explicit queue, with each stage gated on the resource it needs — so throughput scales smoothly as the player upgrades and the pipeline never deadlocks.

Result. A complete arcade-idle title with a deep multi-stage loop, all of it coded by one engineer.

Escape

Hero Games · 2021–2023 · Hero Games · Sole programmer

Watch on YouTube

What it is

A hypercasual escape game. A vending machine dispenses batteries; you collect them and carry them to power stations, filling each until they’re all powered and the exit gate unlocks — then on to the next level. A killer patrols the level the whole time, but can’t detect you while you’re hiding in a vent. At Hero Games I was the sole programmer, working alongside a game designer and an artist.

What I built

As the sole programmer, I built the full game’s code:

  • Core loop — battery spawning from the vending machine, pickup-and-carry, and power-station filling that gates the level exit.
  • Killer AI — continuous patrol, player detection, and pursuit — plus the vent-hiding rule that breaks line of sight and makes you undetectable.
  • Level flow and progression across escalating levels.
  • Mobile live-ops surface — ads, analytics, and IAP-ready monetization.

The hard part

Problem. Hypercasual tension lives or dies on the chase — the killer has to feel dangerous without being unfair, and hiding has to feel like a real escape, not a loophole.

Solution. A patrol-and-detect AI with clear, readable states (patrol → alert → chase) and a hard stealth rule — vents fully break detection — so the player always understands why they were caught and how to get away.

Result. A tight, readable hypercasual loop, coded end to end by one engineer.