Scaling Subway Surfers City for performance and speed

SYBO built its latest release, Subway Surfers City as the next chapter in the Subway Surfers universe. While the original travels the globe, this installment anchors players in Subway City, introducing distinct districts and more gameplay variety.

Alongside the classic endless runner mode, the game introduces finite experiences like rotating events and a City Tour. These new modes broaden progression and gameplay systems while preserving the responsiveness and flow that define the franchise for millions of players worldwide.

Raising the game’s graphical quality is central to this vision, which features enhanced animations, richer environments, and extended gameplay features. These upgrades, however, cannot come at the expense of clarity or runtime efficiency.

The challenge was to evolve the experience in a way that feels both familiar and fresh to deliver a modern take on the runner genre while maintaining the immediacy that made the original a global success with over 4.5 billion lifetime downloads.

Subway Surfers City: A Unity case study

The team built Subway Surfers City as a scalable live game to support continuous content, new mechanics, and higher fidelity over years without requiring major rewrites. “It had to scale technically at the same pace that design and content scaled creatively,” says Atash Qasim, lead game designer at SYBO.

The team designed the architecture to focus on modularity and performance. They encapsulated and extended systems, letting designers add gameplay elements or environmental variations without destabilizing the core gameplay loop.

At the same time, higher fidelity created performance challenges: detailed environments, high-poly assets, and richer animations can strain mid- and low-tier devices. “We embedded strict mesh and shader complexity budgets, implemented tiered rendering paths with different quality levels and resolution scaling, and continuously profiled across representative devices,” explains Gabriel Lascano, technical director at SYBO. “We also invested heavily into finding the right moment for shader prewarming, balancing fast load times against and shader compilation stutter at runtime.”

Instead of optimizing blindly, they identified real bottlenecks, including excessive micro-triangle density and fragment overdraw on tile-based GPUs. The result is an adaptable, performance-focused foundation capable of evolving in complexity while maintaining stability and broad device compatibility.

The results

• Consistently hit 60 fps
• Increased device support by 5.9 times after the performance optimization phase
• Reduced the skyline from 260,000 to a small number of vertices and cut draw calls from 27 to just a few
• Eliminated a 10 ms delay waiting on GPU completion per frame on low-end devices
• Decreased animation and render bookkeeping overhead by roughly 50–60%, reclaiming around 2 ms of main-thread CPU time on low-end Android devices

Designing levels for rapid iteration

Level design in Subway Surfers City is built for speed and flexibility. To deliver the variety and responsiveness that define the franchise, the team used a chunk-based procedural system, letting designers create, modify, and combine self-contained segments independently in the Unity Editor.

Each chunk includes layered elements and variation rules that preserve consistency while keeping repeated runs engaging. This system enables scalable level expansion, allowing new chunks to be added directly into endless runs or finite modes without redefining entire paths.

Using the Editor, designers simulate obstacle movement, preview interactions, and test dynamic elements in real time. “They can experience exactly how a chunk will feel without playing through the full game,” explains Lascano.

Snappable placement tools and Unity’s collider visualization further streamlined iteration, enabling precise, fast adjustments. For staged modes like City Tour, designers ran specific chunks or stages directly in the Editor, bypassing full project compilation cycles.

The modular structure also supports rapid content variation. “Our levels are very modular,” says Qasim. “We have different prefabs for different variations of level design elements that we can drag and drop into chunks. Each chunk includes multiple layers, so when players run through the same segment, they experience different variations that keep the gameplay fresh.”

The team combined modular level architecture with real-time visualization, which accelerated iteration without compromising quality. As Lascano notes, “This system allows designers to experiment freely, expand content efficiently, and maintain the responsiveness and polish players expect across both endless and finite gameplay modes.”

Managing memory with Addressables

The Addressables system is central to the team’s ability to deliver rich visuals and expansive environments without compromising performance. The team used Addressables to load only the chunks relevant to the player – unloading completed sections and streaming in new ones – which minimized memory usage and enabled rich, dynamic content.

“Chunks are streamed in and out through the Addressables system with strict lifetime control, ensuring the memory footprint scales with active gameplay rather than total content size,” explains Lascano. “Combined with pooling, this minimizes allocation spikes and keeps runtime memory stable even as content scales.”

The Addressables system lets the team decouple content from the base build and treat level chunks as independently loadable units. “This was fundamental to maintaining store compliance by reducing initial download size and controlling runtime memory residency,” says Lascano.

Scaling performance across device segments

Rendering in Subway Surfers City scales across low-, mid-, and high-end devices while maintaining detailed visuals and stable frame rates. The team followed a strict bottleneck-first optimization methodology. Each time a constraint was removed, profiling revealed the next limiting factor. “This iterative process let us expand the supported device range methodically instead of relying on broad, unfocused optimization,” says Lascano.

The team used the Universal Render Pipeline (URP) with the Scriptable Render Pipeline (SRP) batcher to reduce CPU rendering overhead by caching material constant buffers on the GPU and reusing them across objects that share the same shader variant, minimizing per-draw-call state setup on the render thread.

“We implemented multiple shader variants per quality tier and controlled them through global keywords and URP settings. Lower-end devices use reduced lighting and simplified fragment paths, while higher segments retain full fidelity, all without changing asset content,” says Lascano.

Artists authored shaders using the Amplify Shader Editor, giving them creative control without needing engineering support. The team tested performance across devices, rewrote complex shaders, and optimized key assets, including the city skyline.

“We replaced a high-vertex 3D animated skyline, approximately 260,000 vertices across 27 draw calls, with a flat mesh and panning textures,” says Lascano. “This change significantly reduced vertex processing and micro-triangle fragmentation to a small number of vertices across a few draw calls, recovering multiple milliseconds of GPU time on low-end Android devices.”

Reducing micro-triangle overdraw on mobile GPUs

Early GPU profiling on Mali GPU devices revealed that the application was submitting far more geometry than meaningfully contributed to visible pixels. Only about 33% of the submitted primitives were visible, while the GPU discarded approximately 25% through sample test culling (ideal less than 5%). In addition, partial coverage from micro-triangles consistently reached 50–80% (ideal less than 10%).

These results indicated that the application was generating excessive micro-triangle density, a known inefficiency on tile-based mobile GPUs, where fragment processing costs increase significantly even when geometry barely covers screen pixels. The team uses a custom adaptive system to monitor CPU and GPU load in real time. It dynamically adjusts quality, asset instantiation, distance culling, and non-essential elements like high-detail props to maintain target performance.

“We responded by aggressively reducing polycount, removing back faces on static geometry, simplifying skyline meshes, and enforcing strict mesh budgets per chunk. This significantly reduced fragment workload and stabilized GPU time on low-end Android devices,” says Lascano. ”Vertex colors, polycount caps, and removing back faces from static geometry further reduced GPU workload without affecting the game’s visual quality.”

Expanding supported devices through profiling

Early in development, only 16% of supported devices could run Subway Surfers City due to graphical complexity. When it came to profiling, the team faced shifting bottlenecks, including GPU fragment cost and shader complexity, as well as CPU submission overhead and memory retention.

To expand device support, the team relied heavily on Project Auditor and Memory Profiler alongside custom profiling tools. Project Auditor helped them identify configuration and asset-level inefficiencies such as excessive shader variants and redundant or faulty settings, while runtime bottlenecks were analyzed using the Unity Profiler and device-level profiling tools such as RenderDoc and Snapdragon Profiler.

The Memory Profiler revealed hotspots in asset memory usage, pinpointing textures, meshes, or objects that caused spikes or unnecessary retention.

“Profiling was integrated into our release gate. Every major build was validated against CPU, GPU, and memory budgets to prevent regression and ensure that improvements on one device tier didn't introduce instability on another,” explains Lascano.

By systematically analyzing these metrics, the team prioritized optimizations, enforced polycount and memory budgets, and ensured stable frame pacing even on lower-end devices.

The team also ran internal Addressables checks to prevent duplicates and conflicts, while the modular chunk system and object pooling minimized memory spikes during gameplay.

Prioritizing frame stability over peak performance

For rendering, the team chose OpenGL over Vulkan to maintain stable frame pacing on low-end devices based on measured performance across their test matrix.

“Although Vulkan performed well on high-end devices, profiling revealed render-thread stalls and unstable frame pacing on low-end Android hardware,” says Lascano. “OpenGL produced more consistent frame times across our target device matrix, so we prioritized device inclusion and frame stability over peak theoretical performance.”

Combined with adaptive performance, tiered shaders, SRP batching, and asset-aware optimizations, this profiling approach helped rich, detailed visuals to run smoothly across 95% of supported devices.

“Collaboration with Unity’s Integrated Success team helped validate and accelerate decisions we were already investigating and evaluating optimizations by return on investment (ROI),” says Lascano. “The biggest gains came from systematically eliminating real bottlenecks, whether CPU bounding volume updates, mesh skinning overlap, or GPU fragment cost, rather than applying generic best practices.”

Sharing key performance learnings

When it comes to performance optimization, Lascano emphasizes treating best practices – like level of detail (LOD) systems or Vulkan – as hypotheses, testing them against your game’s context.

For live games, he recommends building an architecture that is ready for iteration, with safeguards like polycount limits, shader complexity budgets, memory management, and continuous profiling. He also suggests considering device reach early to help avoid costly rework later in production.

“Average fps can be misleading. What players notice most in a game like this is frame pacing stability. Eliminating spikes and render-thread stalls had a greater impact on player experience than increasing peak frame rate,” says Lascano. “Choosing the right render pipeline with the right batching strategy to optimize frame pacing can be a game changer.”

He also stresses that “performance optimization is an iterative bottleneck elimination process. Each fix shifts the constraint elsewhere, between GPU, CPU, memory, and memory bandwidth. The key is disciplined profiling, measured trade-offs, and aligning technical decisions with the weakest devices you intend to support.”

Download Unity Pro today

Start creating games that compete with, and surpass the quality and success of big studio releases with help from powerful tools, support, verified partners, and a vibrant community.