Consulting on Visual Optimization of Game Graphics

Frame time 28ms on Samsung Galaxy A53 with a target of 16.6ms. Unity Profiler shows Camera.Render taking 18ms of that. The developer checks Frame Debugger — 340 draw calls, half of which are UI Canvas in Screen Space - Overlay mode with Rebuild every frame. We solve such problems in a day, but without precise diagnostics, iterations stretch into weeks. Our experience: over eight years in gamedev, more than 50 projects where we achieved stable 60 FPS on mid-range hardware.

Consulting on visual optimization is about diagnosing bottlenecks and providing a concrete action plan, not "use fewer polygons." We deliver not just a report, but also the understanding for your team to independently find and fix issues in the future. We guarantee a 2–3x reduction in bug-fix time after our consultation.

What problems does visual optimization solve?

CPU side. UnityEngine.Rendering.RenderPipeline.Render in Profiler — the first entry point. If it's >10ms on mobile with a simple scene, we dig deeper. Canvas.SendWillRenderCanvases — a flag for problematic UI. ShadowCaster.Render — too many shadows or excessive shadow distance. Animator.Update with many active animators in the scene — each active Animator consumes CPU regardless of visibility.

GPU side. Snapdragon Profiler for Android, Xcode GPU Frame Capture for iOS — more precise than Unity Profiler for GPU analysis. Fillrate overdraw visible via Unity Scene View in Overdraw mode — red zones indicate multiple redraws. Typical problem: particle systems with Additive blending draw 15–20 layers over the background — each layer is a full fillrate pass.

Memory. Memory Profiler package — not the built-in Profiler. A heap snapshot shows specific textures consuming VRAM. An uncompressed 4K texture = 64 MB VRAM, worse without mipmaps — when the object is far, GPU still reads full resolution.

Why Dynamic Batching fails on mobile?

Dynamic batching automatically batches meshes with the same material if they are <=900 vertices and 300 triangles. But if objects have different MaterialPropertyBlock values (e.g., color set via script), batching breaks. GPU Instancing is 3x more efficient on mobile GPUs because it reduces draw calls with a single rendering call for multiple objects. Migrating to GPU Instancing is one of the most effective changes.

What typical problems do we find?

• Canvas Rebuild every frame. Canvas.willRenderCanvases fires on any change to a child element — move, color, text. If a HUD updates a timer every second, the entire Canvas recalculates. Solution: split Canvas into static and dynamic parts. Animated elements on a separate Canvas.
• Shadow Distance. On mobile platforms Shadow Distance = 150 (default) draws cascaded shadows for everything within 150 units of the camera. Real need — usually 20–40 units. Shadow render time difference is 3–4x.
• MipMap Streaming not configured. Without QualitySettings.streamingMipmapsActive = true, all textures load at full resolution on scene start. For mobiles with 3–4 GB RAM this is critical — a scene with 200 textures can consume 600 MB VRAM on start.

How does a visual optimization consultation proceed?

1. Audit. We run the project on the target device with Profiler attached, capture several typical scenes. Analyze frame breakdown, draw calls, fillrate, memory snapshot. Result — a list of bottlenecks with estimated potential gain.
2. Action plan. Prioritize by "fix complexity / performance gain" ratio. Low-hanging fruit (shadow distance, canvas split, texture compression) first. Architectural changes (GPU Instancing migration, LOD reorganization) with effort estimation.
3. Implementation support. We implement changes ourselves or guide the team during self-fixing. For the latter: a written technical guide with specific settings and expected results.

What's included in a visual optimization consultation?

• Documentation: report with charts, Profiler and Frame Debugger screenshots, priority recommendations.
• Optimization code: ready shaders, scripts for Instancing setup, configs for Addressables.
• Access: temporary access to our demo stand with reference solutions.
• Training: 2-hour session analyzing typical errors and answering team questions.
• Support: consultations on arising difficulties for one month after the main phase.

We use a combined approach: first CPU profiling to find logical bottlenecks, then GPU detailing via RenderDoc and Snapdragon Profiler. This uncovers both obvious and hidden problems — for example, incorrect LOD setup or inefficient shader use.

Tools we use

Timelines and savings

Average project saving — debugging budget reduction by 30–50% due to precise root cause identification. The consultation cost is fixed after initial analysis of the project and target platforms. Contact us to discuss your project and get a preliminary estimate. Order a consultation, and we will help solve performance issues.

Manual pre-release preparation as a source of delays

We automate the entire pre-release pipeline for mobile and XR games. A studio is about to release a game — a week before the date, the manager remembers they need to build an AAB, sign it, and upload to Google Play. The build engineer manually starts the build, waits an hour, forgets to enable IL2CPP, the build crashes on Android 12. Rebuilding takes another hour. Simultaneously, the icon needs to be redesigned to meet new Google requirements. As a result, the release is delayed by three days. Experience shows: manual pre-release preparation is the primary source of delays and bugs that do not manifest on the developer's machine.

How to set up CI/CD for mobile game builds?

Pipeline tools

GameCI — open-source Docker images for Unity builds, running on GitHub Actions, GitLab CI, or any other CI provider. Key components: unity-builder (builds for the target platform), unity-test-runner (runs Unity Test Framework before build), unity-return-license (returns the license — critical for Pro). Unity Cloud Build is simpler but less flexible and expensive for frequent builds. Fastlane is the standard for final steps: signing, uploading to stores, metadata.

Typical pipeline

jobs:
  test:
    name: Run Unity Tests
    uses: game-ci/unity-test-runner@v4
    with:
      unityVersion: 2022.3.20f1
      testMode: playmode

  build-android:
    name: Build Android
    needs: test
    uses: game-ci/unity-builder@v4
    with:
      targetPlatform: Android
      androidKeystoreBase64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
      androidKeystorePass: ${{ secrets.KEYSTORE_PASSWORD }}
      androidKeyaliasPass: ${{ secrets.KEY_PASSWORD }}

  upload-to-play:
    name: Upload to Google Play (Internal Track)
    needs: build-android
    uses: r0adkll/upload-google-play@v1
    with:
      serviceAccountJsonPlainText: ${{ secrets.SERVICE_ACCOUNT_JSON }}
      packageName: com.yourcompany.yourgame
      releaseFiles: build/Android/*.aab
      track: internal

Secrets, not variables — all keys in CI secrets. AAB instead of APK has been mandatory for several years. Tracks: internal → closed → open → production. Promotion — manual or Fastlane supply promote.

iOS specifics

Unity builds an Xcode project, then xcodebuild. Need Distribution Certificate and Provisioning Profile (App Store). Fastlane Match solves the problem of certificate synchronization within the team:

lane :build_ios do
  match(type: “appstore”, readonly: true)
  build_app(workspace: “Unity-iPhone.xcworkspace”,
            scheme: “Unity-iPhone”,
            export_method: “app-store”)
  upload_to_testflight
end

App Store Connect API Key replaces login/password, does not break with 2FA.

Step-by-step pipeline setup

1. Audit Unity PlayerSettings (Graphics APIs, Scripting Backend, stripping).
2. Create CI configuration with GameCI — define test, build, and deploy jobs.
3. Integrate Fastlane for code signing and store uploads.
4. Store all secrets (keystore, certificates, API keys) in encrypted CI variables.
5. Run a test release on internal track, verify end‑to‑end.

Each step includes validation: build must pass on a clean runner, not just a local machine.

Why does App Store reject about a third of first submissions?

Apple rejects 30–40% of first submissions from new studios. Common reasons:

Practice: before submission, go through the App Store Review Guidelines from start to finish — 2–3 hours, saving 2–3 weeks of resubmission loops.

Google Play is more lenient: typical reasons — outdated targetSdkVersion, excessive permissions, incorrect Data Safety Form.

Deliverables of pre-release preparation

We deliver the following for your game release:

• CI/CD pipeline configured (GameCI + Fastlane, Unity Cloud Build — turnkey)
• Metadata and marketing assets (screenshots, icons, feature graphics)
• Store submission guidance with documentation of all accesses and credentials
• 72‑hour post‑release monitoring (Crashlytics, ANR rate, user reviews)
• Pipeline documentation and team training session (hands‑on)
• Age rating configuration (IARC, ESRB, PEGI, CERO) and localization of store metadata

Pipeline automation replaces the manual work of an entire department. For example, setting up Continuous Integration via GameCI and Fastlane reduces pre‑release preparation time threefold — from 8 working hours to 2.5.

Our pre-release workflow: from audit to store submission

Impact of pipeline automation on timelines and budget

Manual game release incurs significant engineering and testing costs. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Result: we reduce the commit‑to‑publish cycle by 6–8 times. For projects with frequent hotfixes, this is the difference between a week‑long user wait and a one‑day fix. We guarantee the pipeline works reliably after setup. Our engineers hold Unity Certified Professional credentials.

Typical savings: $2,500–$5,000 per month on engineering time eliminated by automation — $30,000–$60,000 annually on a mid‑size project.

Post‑release: monitoring and updates

Crash rate < 1% (Firebase Crashlytics), ANR rate < 0.47% (Play Console) — otherwise visibility restrictions. Phased rollout is mandatory: first 10%, then 50%, then 100% of users.

Our track record: 30+ mobile game releases, 5+ years on the market. CI/CD automation pays for itself within the first two months, reducing release costs by 40–60%.

Timeline

Setup takes from 2 days (simple mobile game with existing Unity project) to 2 weeks (complex multi‑platform project with custom CI runners). We calculate exact hours during a free pipeline audit.

Contact our engineers for a free pipeline audit and a timeline estimate. Submit a request — we will analyze your pipeline and offer a solution within 2 days. Get a consultation from an engineer who has shipped 30+ titles.