I turn your 2D art into playable Unity prototypes in 30 days.
Stop struggling with C# and Unity mechanics. I build the technical framework, enemy logic, and scene architecture so you can pitch your game for funding.
You have the vision. I write the code.
Game artists and creative directors shouldn't get bogged down in raycasts, state machines, and race conditions. I translate your concepts, sprites, and design documents into robust, publisher-ready Unity systems.
Zero Spaghetti Code: Clean, scalable C# scripts.
Architected with decoupled ScriptableObjects, explicit state machines, and SOLID principles. No monolithic scripts with 3,000 lines of messy logic. When you hire full-time developers post-funding, they can easily build upon the architecture instead of rewriting it.
Rapid Vertical Slices: Focus on core mechanics like player controllers and enemy spawning routines.
We zero in on what makes your game uniquely satisfying: responsive character feel, crisp jump curves, juice, screen shake, enemy wave algorithms, and core game loops that grab publishers and players within 10 seconds of holding the controller.
Seamless Handoff: Delivered via Unity Version Control ready for your team.
Everything is pushed to Git or Unity Version Control (PlasticSCM) with clean branch structure, organized prefab folders, and thorough documentation. Plus a personalized 30-minute architecture walkthrough video explaining every system.
Recent Prototypes
Explore recent vertical slices built for indie creators. Each project solves complex mechanical requirements with clean C# engineering.
Upload gameplay GIF here
2D Platformer Mechanics (Physics, Coroutines, State Machines)
Sub-pixel movement, kinematic custom collision solver, jump apex gravity reduction, coyote time, jump buffering, wall sliding, and asynchronous dash coroutines with zero frame drops.
- ▸ Custom Raycast Controller (No Rigidbody jitter)
- ▸ Hierarchical State Machine (Grounded, Air, Dash)
- ▸ Gamepad & Keyboard Input Buffering
Upload gameplay GIF here
Virtual Ecosystem Simulation (Entity Interactions, Resource Logic)
Autonomous entity life cycles, sensory radius detection, food chain predation trees, and spatial grid partitioning to handle hundreds of simulated creatures simultaneously without GC spikes.
- ▸ Spatial Grid Hash Partitioning
- ▸ ScriptableObject Entity Archetypes
- ▸ Emergent Population Fluctuation Curves
Upload gameplay GIF here
Combat Loop & Enemy Spawning (Wave management, Audio triggers)
Tight hitstop micro-pauses, modular weapon combos, directional knockback, pool-managed enemy spawner routines, dynamic camera shake, and synchronized audio event hooks.
- ▸ Zero-Allocation Object Pool Manager
- ▸ Configurable JSON / Scriptable Wave Director
- ▸ Dynamic Audio Trigger Bus with Pitch Variation
How It Works
A transparent, sprint-based workflow structured specifically for indie founders and artists. You supply the art and vision; I deliver the playable build.
Step 1: Scope & Plan
(Defining the exact mechanics of the vertical slice)
We review your art assets, design docs, and target gameplay references. We extract the must-have mechanics, eliminate scope creep, and define clear acceptance criteria for your 3-minute pitchable vertical slice.
- ✓ Technical mechanic breakdown checklist
- ✓ Target frame rate & platform specs (PC / Steam Deck / WebGL)
- ✓ Unity project setup & Git repository initialization
Step 2: Rapid Development
(Building out the greybox in Unity)
I code the C# architecture, integrate your 2D sprites, wire up physics and state machines, and deliver playable test builds every Friday. You test directly on your machine and provide real-time feedback on game feel and pacing.
- ✓ Weekly playable test builds (WebGL / PC Standalone)
- ✓ Input smoothing, enemy behaviors, and camera framing
- ✓ Rapid iteration on jump curves and combat responsiveness
Step 3: Delivery & Handoff
(Transferring the repository and documentation)
Final build testing, complete repository ownership transfer via Unity Version Control or GitHub, and clean architecture documentation so you can confidently pitch publishers or hire junior programmers to continue production.
- ✓ 100% Repository & Asset ownership transfer
- ✓ Comprehensive code documentation & Architecture video
- ✓ Pitch-ready standalone executable build for investors
Pricing Packages
Three fixed-scope entry points, sized to where your project is right now. Every quote below is a starting point — final scope is confirmed with you before any invoice goes out.
The Sandbox
Perfect for testing a single core mechanic to see if it's fun.
- ✓ 1-2 core mechanics
- ✓ Greybox environment
- ✓ 1-week delivery
The Demo
A fully playable loop with a start and end condition.
- ✓ Complete gameplay loop
- ✓ Basic audio & UI
- ✓ Enemy spawning / logic
- ✓ 2-3 week delivery
The Vertical Slice
A polished, pitch-ready demo ready for Kickstarter or publishers.
- ✓ Custom art integration
- ✓ Scene management & Menus
- ✓ Clean C# scripts
- ✓ Unity Version Control handoff
Every package includes full source code, Git/Unity Version Control history, and IP ownership on completion. Request a quote to confirm final scope — invoicing happens manually after we agree on details.
Ready to build your vertical slice?
Fill out the project scope below to get started.