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.