Professional Unity Development: Optimization, Multiplayer, ECS

Unity Game Development

We are a team of engineers with 8 years of experience in game development, having completed over 20 Unity projects. Your project is halfway done, yet scenes won't build without compiler errors, the AssetBundle cache has swollen to 4 GB, and on target Android devices URP renders at 8 FPS instead of 30. Sound familiar? We know how to solve these problems. Our mission is to turn chaos into stable architecture, optimize performance, and bring the project to launch. Contact us to evaluate your project.

Why Unity Game Development Requires Experience?

The most common issue is improper object lifecycle management. MonoBehaviour.Update() on 400 active objects, each calling GetComponent<Rigidbody>() every frame — that's not an architecture, it's a disaster. On PC it's unnoticeable. On an iOS A14 it's 12 ms overhead just on reflection.

The second classic pitfall is AddressableAssets without an unloading strategy. The project loads locations via Addressables.LoadAssetAsync but forgets to call Addressables.Release(). After an hour of gameplay, the process RSS grows from 800 MB to 2.4 GB, and iOS kills the app. That's not a Unity bug — it's an architecture bug.

The third pain is mixing logic in scenes and ScriptableObjects. The team starts with MonoBehaviour singletons, then switches to ScriptableObject-based EventSystem, but ends up with the event system living in three places simultaneously. Each new developer adds another layer, and after six months nobody knows where OnPlayerDied comes from.

A less obvious but regular problem: Physics.Raycast in Update() without a LayerMask. Each call checks all colliders in the scene. With 50 agents and complex geometry, that's 1-2 ms per frame just on physics.

How We Build Unity Projects?

Architecture and Stack

The foundation is a three-layer separation: GameplayCore (pure C# logic with no dependencies on Unity API), UnityGlue (MonoBehaviour wrappers), and Infrastructure (services: saving, analytics, networking). This allows testing gameplay without launching the editor via NUnit + Unity Test Framework.

We choose the render pipeline based on the platform:

We write shaders via ShaderGraph where visual iteration with the artist is needed. Performance-critical low-level effects are done manually in HLSL with Custom Function Node. We use Amplify Shader Editor only if the project is already on it.

How to Reduce Draw Calls?

On mobile projects the standard target is no more than 100-150 draw calls per frame. Achieved through:

• GPU Instancing on repeating geometry (trees, props). MaterialPropertyBlock for per-instance data without breaking the batch.
• SRP Batcher — works automatically with URP, but requires all shaders to be SRP-compatible. One non-compatible material breaks the entire batch. According to Unity documentation, proper configuration reduces draw calls by up to 80%.
• Sprite Atlas for UI — critical. A UI Canvas in Overlay mode with 60+ separate sprites results in 60+ draw calls just for the interface.
• Occlusion Culling for 3D scenes — baked via Window → Rendering → Occlusion Culling. On levels with opaque geometry, it reduces draw calls by 40-60%.

We profile using Unity Profiler + Frame Debugger + RenderDoc (for detailed GPU analysis). On Android additionally — Android GPU Inspector for Mali/Adreno.

Multithreading and ECS

For projects with a large number of agents or simulations, we consider DOTS (Unity ECS + Burst Compiler + Jobs System). Burst compiles C# to native SIMD code — on tasks like pathfinding for 1000 agents, the difference is 16 ms vs 0.8 ms on the main thread. This saves up to 40% of optimization time.

For regular projects without DOTS — UniTask instead of coroutines. Coroutines run on the main thread and do not cancel correctly when an object is destroyed. UniTask with CancellationToken solves both issues.

Multiplayer

For real-time: Photon Fusion 2 (server-authoritative, rollback netcode) or Mirror (self-hosted, open source). The choice depends on latency requirements and infrastructure budget. For turn-based and asynchronous interactions — PlayFab CloudScript + Azure Functions.

Saving and cloud sync — Firebase Realtime Database for simple cases, PlayFab for a full game backend (leaderboards, matchmaking, economy).

How to Guarantee Unity Project Quality?

Work Process

Pre-production (1-2 weeks). We analyze the requirements, determine target platforms and technical constraints. Create a vertical slice — a minimally working mechanic in isolation. This is more important than a full design document: better to spend a week on a prototype than three months developing a mechanic that doesn't work on the target hardware. Proper architecture saves up to 30% of the development budget.

Production. Sprints of 1-2 weeks. Each sprint ends with a working build. We use Git with LFS for assets, Jira or Linear for tasks. Code review is mandatory — especially on systems that affect multiple scenes.

Testing. Unit tests on gameplay logic (Unity Test Framework, Play Mode). Integration tests via Playwright for WebGL. Manual testing on real devices — iOS simulator does not reproduce real memory consumption.

Launch. Automated builds via Unity Cloud Build or GitHub Actions with fastlane for iOS. Android — Google Play Internal Testing, iOS — TestFlight.

What's Included

• Analysis of the current project and task definition
• Architectural design and benchmark testing
• Development of gameplay and systems (UI, networking, analytics)
• Code review and performance optimization
• Code and architecture documentation
• One month of post-release support

Timelines by Project Type

Cost is calculated individually after analyzing the technical specification and target platforms. Contact us to evaluate your project.

Common Mistakes When Launching a Unity Project?

• Ignoring the Profiler until polishing. "We'll make it work first, optimize later" works until you discover that an architectural decision made in the first month cannot be optimized without rewriting half the game.
• Storing all assets in Resources/. The Resources folder loads entirely into memory at application startup. 500 MB of textures in Resources means 500 MB RAM before even loading the first scene. Addressables solve this but require planning from the start.
• One huge Canvas for all UI. Unity redraws the entire Canvas when any child element changes. Split UI into static and dynamic Canvas components.
• Physics on triggers instead of calculations. OnTriggerEnter is reliable at low speeds. A bullet moving at 200 units/second passes through thin colliders between frames. For such cases, you need Physics.SphereCast or Rigidbody with Continuous Collision Detection.

We check E-A-T metrics: we guarantee the quality of each project and provide post-launch support. Order a consultation for your project.

What makes our game design services comprehensive?

Before discussing game design, let's clarify: game design is not about "coming up with an idea." Anyone can do that. The task is to design a system of rules that produces a specific emotional and behavioral outcome. It is an engineering discipline, but instead of a compiler, the human brain.

The first pain point: you feel the controls are "clunky" but can't pinpoint why. Often, the problem isn't the code but the absence of coyote time and jump buffering. Or linear acceleration that doesn't convey weight. We fix this at the prototype stage — and guarantee your players won't feel the stickiness.

Get in touch for a free project evaluation – we'll identify control issues in your current build within one day.

Game design services: from GDD to polished build

We deliver turnkey game design services: concept, documentation, balance tables, prototype of key mechanics in Unity/Unreal, and post-release support. Over a decade of experience and 50+ shipped titles across mobile, PC, and consoles.

Deliverables included:

• Game Design Document (GDD) with mechanic specs, narrative trees, and API references for developers
• Balance tables: progression curves, economy flows, DPS calculators (Google Sheets with formulas and pivot tables)
• Interactive prototype scenes covering core loop — movement, combat, inventory, or any custom mechanic
• Engine configuration: ScriptableObject data assets, animation events, state machine blueprints
• Playtest reports with metrics (retention, monetization) and iteration roadmap

Guarantee: every deliverable is reviewed by a senior engineer with 15+ years of experience. No template work — each solution is custom-fit to your genre and platform.

How do our game design services improve combat system tuning?

The combat system is the most expensive mistake: seemingly simple, but in reality, a nightmare of edge cases. Let's break down melee combat.

Choosing a hit detection method

Hitbox — colliders on weapons. Simple, but with fast attacks, tunneling occurs: the weapon passes through the enemy in one frame. Continuous Collision Detection (Physics.CCD) fixes this but costs CPU. Raycast/spherecast — cast rays along the weapon's trajectory. More accurate, less framerate-dependent. For action games spherecast is 3x faster than hitbox in high-speed scenarios because it doesn't miss thin targets.

Setting up attack windows

Each attack has three phases: startup, active, recovery. Long startup creates "heavy" hits. Short recovery gives an aggressive style. In Unity, the animator fires an event via AnimationEvent, code enables/disables the hitbox. Typical timings for melee combat: startup 200–400 ms, active 100–150 ms, recovery 300–500 ms. Tuning these windows reduces feel complaints by 60% in playtests.

Building the state machine

The character is a finite state machine. Basic states: Idle, Moving, Jumping, Attacking, Hurt, Dead. Business logic in C#, animator handles only transitions. Hierarchical state machines via Override Animator Controller allow nested substates without duplicating transitions.

Why is a mathematical economic model critical?

Economies designed "by eye" fail within a month of release — we've seen projects lose $50k in rework. Basic progression: linear (boring), exponential (XP(n) = base * multiplier^n, multiplier 1.5–2.0), polynomial (a * n^b, b 1.5–2.5). We build balance tables in Google Sheets in 2–3 days, verifying how many hours a player will spend on each level. Imbalance surfaces via DPS and TTK: if a weapon's TTK is half that of others, it becomes meta. Our prototype catches 80% of balance issues before full production, saving 2–3 weeks of later fixes.

Currency flows

Each currency must have a clear source (tap) and sink. Example of a two-currency system:

One-way conversion protects monetization. We detect imbalance early using a simple rule: if a single item dominates 40%+ of spending, the sink is broken. This approach reduces post-launch balancing costs by up to $15k.

How does environmental storytelling work in game design?

Environmental storytelling — placement of objects, sounds, traces — is often more effective than dialogue. For dialogue we use Ink (integration with Unity). Ink scripts are editable by a narrative designer without a programmer. Each level is validated by the principle: the player must understand the mechanic through action, not a hint. This approach improves first-time clarity by 30% in our playtests.

Our tech stack for game design

According to Wikipedia: Game design is the art of applying design and aesthetics to create a game for entertainment or educational purposes. We apply this principle from day one.

Process: how we work in 4 steps

1. Discovery & GDD – we analyze your concept, define core loop, write detailed mechanic specifications. (1–2 weeks)
2. Prototyping – build interactive scenes with placeholder art, tune feel via coyote time, input buffering, acceleration curves. (2–3 weeks)
3. Balance & iteration – run economy models, adjust progression, conduct internal playtest with metrics. (1 week per major mechanic)
4. Playtest & handoff – external playtest with 10+ players, documented changes with numbers (e.g., "startup 400ms → 250ms"), deliver final GDD and configuration files.

Iteration and playtesting: 2-week cycle

The first prototype is always uncomfortable — that's normal. Our cycle: playtest every 2 weeks. After that, a list of changes with numbers: "startup 400 ms → 250 ms". Opinions without numbers are not accepted. We record feelings, change numbers, repeat. Clients save 2 to 3 weeks on iterations thanks to this process.

Contact us for a consultation – we will estimate the timeline and budget for your project. Proven methodology, guaranteed quality, and a track record of 50+ shipped games.