Unity hosted its developer conference, 'Unite Seoul 2026,' today (the 21st) at the Grand Ballroom of COEX in Seoul. Unite Seoul 2026 featured the global debut of Unity Engine 7, while developers from around the world gathered to share their technical expertise.

Among the highlights was 'Arknights: Endfield,' which launched on January 22. The game features dense fields where players build and develop industrial facilities, creating a complex factory system. To achieve this while maintaining high-quality hybrid NPR (Non-Photorealistic Rendering) and PBR (Physically Based Rendering) graphics, the team ensured the game runs smoothly on consoles and PCs, as well as on mobile devices.

How did the Arknights: Endfield development team achieve this? Honghui Fei, Senior Tech Director at Hypergryph, explained the process during his lecture at Unite Seoul 2026.

Cache-Friendly Memory Structure Maximized via ECS

Senior Director Fei categorized the core technologies applied to the rendering of Arknights: Endfield into four pillars: #1 Building a custom ECS, #2 Optimizing culling, sorting, and batching, #3 A C++ render pipeline and render graph, and #4 Low-level device abstraction.

First, the custom data architecture, ECS (Entity Component System), was adopted to rapidly process tens of thousands of rendering targets every frame. In Arknights: Endfield, countless objects are constantly created and destroyed in both the fields and the factories. Without a structure capable of processing all of this rapidly every frame, the system would easily become overloaded.

While ECS is frequently used in Unity to handle large numbers of objects, the Endfield team customized the engine's general-purpose ECS. Standard ECS retains various exception handling for runtime flexibility, but the Endfield team locked these at compile time. By registering runtime types and removing reflection and hash map lookups, they used a 128-bit mask to process offset arithmetic operations in just three cycles.

They also utilized a chunk memory system based on the SoA (Structure of Arrays) approach, placing entities with identical component sets into a single contiguous memory block (Chunk) to maximize CPU cache hit rates. Furthermore, by directly mapping chunks to disk files to eliminate pointer chasing and handling structural changes via a batch 'swap-and-pop' method (swapping the element to be deleted with the last element in the array before removing it), they drastically reduced the computational cost per entity.

"Maximizing Parallel Processing: Culling Should Happen Only Once, Even with 20 Views"

Beyond objects, scene processing was another challenge for Endfield. Because the game uses a hybrid of NPR and PBR, there were over 10 to 20 views per frame, including reflections in shadows, ray tracing, and streaming. Generating visibility lists using traditional methods would have caused memory allocation and copy costs to skyrocket.

To address this, the Endfield team designed a unified culling system. Instead of performing frustum tests for each view individually, they processed them at once and shared the results. They also introduced software occlusion culling, which generates a low-resolution depth buffer on the GPU and uses SIMD operations on the CPU to perform fast occlusion checks through transformation/clipping, tile sorting, and parallel rasterization. This reduced unnecessary views and eliminated locks and atomic operations by separating threads per tile.

In addition, the 16-byte alignment key structure was redesigned as a 64-bit alignment key, allowing both pipeline and mesh batching to be completed with a single standard sort operation. Furthermore, by pointing Vulkan's Descriptor Set 2 to a single large buffer and shifting only the dynamic offset, memory allocation per frame was reduced to zero, thereby securing frame performance.

Utilizing a Native C++ Render Pipeline and Vulkan Structure

Next, Senior Director Fei explained that they utilized a native C++ render pipeline rather than the standard Unity render pipeline. Because the core render loop, which runs thousands of times per frame, suffered from cross-language binding overhead, they adjusted the system by manually implementing the render pipeline in C++.

During this process, they specified the resources read and written by each render pass at the frontend declaration stage using type tags, allowing the graph to identify resource dependencies in advance. This enabled barrier call counts to be adjusted in sync with graph flushes, preventing the driver from conservatively over-allocating barriers. By checking the specified resources, temporary and transition resources with non-overlapping lifecycles shared the same memory allocation, lowering peak VRAM usage without manual management.

Finally, he explained that building a device abstraction layer inspired by Vulkan was key. Instead of letting the driver handle high-level APIs like 'draw mesh' in upper layers, Vulkan exposes explicit concepts like descriptor sets, render passes, and barriers to the developer. While this requires more complex implementation by the developer, it guarantees greater freedom for optimization.

Inspired by this structure, Senior Director Fei and the Endfield team kept the boundary between platform-specific graphics APIs and the engine at a low level. They implemented the system by exposing render passes and barriers directly, requiring the development team to specify them manually. This structure was chosen because high-level abstractions often require additional high-level APIs, which can lead to fallback issues when encountering unexpected scene structures. Furthermore, by utilizing the C++ pipeline, they ensured that optimized data structures were delivered immediately to the GPU backend, achieving zero overhead.

As a result of this design, on a mobile device with a Snapdragon 8 Gen 1 chipset, 500k candidate objects were reduced to tens of thousands required for actual rendering through culling. On PC, 600k objects were compressed to 60k. This powerful culling ratio kept frame calculations very light, with batching taking only 3ms on Android mobile and 1ms on PC.

Senior Director Fei concluded by stating, "By building our own ECS, a unified culling and sorting pass, a C++ render pipeline, and low-level device abstraction on top of Unity's productivity, we were able to run large-scale objects at stable frame rates." He emphasized the need for further research into more diversified analysis and process construction beyond existing object structures.