Xiaomi New CPU Performance

Xiaomi XRING O3: How All-Big-Core CPU Matched Apple and Left Android Behind

Xiaomi’s XRING O3 scored 3,945 in Geekbench 6.5 single-core and 15,221 in multi-core, according to Xiaomi’s launch figures reported by Notebookcheck. By comparison, Notebookcheck’s Apple A19 Pro database lists average of 3,840 single-core and 9,932 multi-core on Geekbench 6.7.1. The single-threaded difference is roughly 3 percent, close enough to call parity. The multi-core difference is about 53 percent. That headline conceals a more interesting story: Xiaomi closed the gap with Apple and outperformed every current Android chip despite using the same licensed Arm cores and the same 3 nm process as the rival that did not come close.

Key Takeaways:

• Xiaomi reports Geekbench 6.5 scores of 3,945 single-core and 15,221 multi-core for XRING O3, versus Apple A19 Pro average of about 3,840 single-core and 9,932 multi-core on Geekbench 6.7.1.
• The ten-core all-big-core CPU uses two C1-Ultra cores at up to 4.35 GHz, four C1-Premium cores at up to 3.68 GHz, and four C1-Pro cores at up to 3.15 GHz, with 44 MB of combined cache.
• Independent dev-board testing from Geekerwan confirms XRING O3 uses the same Arm C1 architecture and TSMC N3P process as MediaTek’s Dimensity 9500, yet leads it by a wide efficiency margin, indicating physical-design improvements rather than new IP.
• Loading all ten CPU cores reaches roughly 20 W, so retail cooling in Xiaomi 18 Fold and Pad 9 Pro Max will determine how much of this performance is sustainable.
• The chip is the first mobile SoC with native LPDDR6 support at 113.8 GB/s, and its 200 TOPS NPU plus GPU NX accelerators make on-device AI a first-class workload.

The launch happened on August 24, 2026, at an event in China. Xiaomi positioned XRING O3, its second in-house smartphone processor, as the fastest smartphone SoC yet, with AnTuTu V11 score of 5,228,014. It will debut in Xiaomi 18 Fold and Xiaomi Pad 9 Pro Max in September 2026. All of these are launch-day claims from the vendor. Independent reviewers have not yet tested the shipping device. That caveat matters more than usual here, because the chip’s headline strength, its ten-core CPU, is also the source of its biggest open question: how much heat the phone can actually dissipate before it throttles.

There is a naming quirk worth noting before getting into details. Xiaomi skipped O2 entirely, moving straight from XRING O1 to O3. The company has not explained the gap, but the jump signals intent. This was not an incremental refresh; it was a deliberate leap built to take on Qualcomm and MediaTek’s new flagships at a moment when both are preparing to move to a smaller process node. Xiaomi chose this generation, on an older node, to stake its claim, which is the most revealing detail in the whole launch.

The headline numbers, and version asterisk

The single-core versus multi-core split is the main reason this chip matters. Xiaomi’s published Geekbench 6.5 numbers put one C1-Ultra core roughly equal to Apple’s A19 Pro performance core, while the ten-core layout produces a multi-core score more than 50 percent higher than the six-core Apple chip. This is the first time a non-Apple smartphone processor has credibly matched Apple’s best single-threaded core while leading it decisively in multi-threaded throughput.

The comparison is not laboratory-grade, and readers should treat exact percentages with caution. Xiaomi measured XRING O3 on Geekbench 6.5, while A19 Pro averages come from shipping iPhones running Geekbench 6.7.1. As we discussed in our earlier breakdown of XRING O3 versus A19 Pro benchmark gap, the version difference is small enough to place both chips in the same broad performance tier, but a controlled head-to-head on a single Geekbench build under matched thermal conditions would be required to determine a precise winner. The multi-core lead is large enough to withstand that noise. The single-core parity is not.

Geekerwan’s independent dev-board testing reproduced the Geekbench multi-core result above 15,000, and the channel described it as Apple M4-class multi-core performance, according to KOCPC’s English report of the test. That detail separates the vendor claim from independent confirmation: a third party put the chip on a board and got a number in the same range. It does not validate the exact 15,221 figure, but it confirms the scale.

The AnTuTu figure requires a separate caution. AnTuTu V11 is a composite score that blends CPU, GPU, memory, storage, and user-interface tests. A total of 5,228,014 is the first time a phone chip has crossed five million, but it does not describe the speed of any single C1-Ultra core. Use it as a platform-level figure, not a CPU result. Xiaomi’s own launch slides show the AnTuTu score alongside Geekbench numbers, and the two should not be confused.

What all-big-core means, and why it wins multi-core

The XRING O3’s CPU is a ten-core, three-cluster design with no traditional efficiency cores. Xiaomi groups two C1-Ultra cores at up to 4.35 GHz and four C1-Premium cores at up to 3.68 GHz as six “super-large” cores, and four C1-Pro cores at up to 3.15 GHz as “large” cores. The CPU complex carries 12 MB of private L2 cache, 16 MB of shared L3 cache, and 16 MB of system-level cache, for 44 MB total, according to Notebookcheck’s analysis of Xiaomi’s slides.

This departs from ARM big.LITTLE convention that has defined mobile CPUs for a decade. Most phone chips pair a few large performance cores with a cluster of small Cortex-A5xx-class efficiency cores that handle background work at minimal power. The XRING O3 abandons small cores entirely. Every one of its ten cores is a large, capable core, differentiated only by clock speed and cache allocation. Memeburn reported that Xiaomi labels the three tiers Prime, Titanium, and Little internally, a deliberate break from ARM’s naming that indicates custom core design rather than off-the-shelf Cortex blueprints.

Apple’s A19 Pro takes the opposite approach: two performance cores at up to 4.26 GHz and four efficiency cores at up to 2.6 GHz, for six threads total because neither chip uses simultaneous multithreading. In benchmarks that can keep every core busy, Xiaomi spreads work across ten relatively large cores while Apple spreads it across two large and four small ones. That explains why the multi-core score is so far apart. The single-core result shows the fastest cores are in the same class, and the multi-core result reflects core count plus the fact that Geekbench includes workloads that scale across them.

Core count does not translate into every app. A browser’s main JavaScript thread, app startup, and many UI operations remain limited by one fast core. Video encoding, photo processing, compilation, file compression, and large numerical workloads can split into independent tasks and actually use extra cores. The three-cluster layout also gives the scheduler a finer set of choices than a simple performance-versus-efficiency split: light work can land on C1-Pro cores, medium work on C1-Premium, and short latency-sensitive bursts on C1-Ultra. Geekerwan described this as a relay where each core type covers a different part of the power curve, with the three clusters handing work off across power ranges rather than duplicating each other.

The cache row requires attention. Xiaomi’s 44 MB total comes from adding the CPU complex’s private L2, shared L3, and system-level cache. Apple’s figures use a different hierarchy and should not be summed into a simple winner. Cache placement, latency, and access rules can matter more than headline capacity, and large streaming workloads that never reuse data will not benefit from cache at all. The memory interface row is similarly nuanced: A19 Pro does not use LPDDR6, but its exact memory configuration is not directly comparable to XRING O3’s four-channel LPDDR6 setup.

The real story: backend engineering, not new cores

One notable finding in independent testing is that XRING O3 does not use new CPU IP or a newer process to reach its numbers. Geekerwan’s dev-board testing, reported by KOCPC, found that the C1-Ultra core uses the same architecture and same TSMC N3P process as the C1-Ultra inside MediaTek’s Dimensity 9500. Yet XRING O3’s prime core led every current Android SoC in energy efficiency and came close to A19 Pro, with floating-point results particularly strong against Snapdragon 8 Elite Gen 5 and Dimensity 9500. Geekerwan said the efficiency gap was “whole dimension ahead” and that the difference in backend design was significant.

This changes the story from “Xiaomi bought better parts” to “Xiaomi implemented the same parts better.” The XRING O3’s die measures 133 mm² and contains 24 billion transistors, up from 19 billion in XRING O1, according to Xiaomi’s figures reported by Notebookcheck. Geekerwan’s die analysis found Xiaomi used metal-layer optimization to tighten gaps between final blocks and built more than 2,400 custom cells beyond standard cells TSMC provides. Notably, Geekerwan observed that XRING O3’s C1-Ultra core is actually smaller in area than the C1-Ultra inside Dimensity 9500, while still outperforming it. That is physical-design work: routing, clocking, voltage, and floorplanning, the kind of engineering that is invisible in spec sheets but determines how efficiently a licensed core actually runs.

The SPEC CPU 2026 testing adds another layer. Geekerwan adopted the new SPEC CPU 2026 suite, the first major release in nine years, as its standard for measuring performance, power, and IPC. The energy-efficiency curve for the C1-Ultra prime core placed XRING O3 at the top of all currently released Android SoCs, coming in only slightly behind Apple A19 Pro’s prime core. In integer tests, the gap with Snapdragon 8 Elite Gen 5’s prime core was limited, but in floating-point tests, which depend more heavily on memory and cache performance, XRING O3 was significantly stronger than both 8 Elite Gen 5 and Dimensity 9500. The comparison with Dimensity 9500 is most instructive because both processors use Arm C1-series CPU IP and TSMC’s N3P process. A large efficiency difference between two chips built from the same IP on the same node points directly at physical design, cache choices, and frequency selection, not newer instruction-set architecture.

The C1-Pro mid core drew particular attention from Geekerwan. The channel had previously criticized the C1-Premium core in Dimensity 9500 for poor energy efficiency, saying it fell short compared to both the ultra-large core above it and the mid core below it. On XRING O3, that same C1-Premium core delivers strong efficiency in both integer and floating-point workloads, and the C1-Pro mid core needs only half the power of Dimensity 9500’s equivalent to reach the same peak performance. Geekerwan said C1-Pro even holds its own against the efficiency core of Apple’s A19 Pro. The result is a three-cluster relay where each core type genuinely covers a different power segment, which is the whole point of having multiple core types in the first place.

Cache, memory latency, and LPDDR6 first

The memory path is where backend engineering appears most clearly, and it explains why floating-point results are so strong. Geekerwan measured the C1-Ultra core at 85 ns memory latency at 128 MB test depth, beating both Dimensity 9500 and Snapdragon 8 Elite Gen 5, and even Apple A19 Pro. Under a dynamic test where other cores generate bandwidth pressure, XRING O3 reached about 180 ns at 256 MB depth versus roughly 200 ns for A19 Pro. Even the C1-Pro mid core posted lower memory latency than Dimensity 9500’s C1-Ultra ultra-large core, which is a striking result: Xiaomi’s mid-tier core has a faster memory path than MediaTek’s flagship core.

Inter-core latency is also top-tier. Geekerwan found all cores stay under 80 ns of inter-core latency, placing XRING O3 among the best mobile processors in that metric. Xiaomi quotes memory access latency of 82 ns, enabled by its unified fusion bus, high-level metal routing, and prefetch technology, according to Notebookcheck. A fast, low-latency memory path is exactly what a ten-core CPU needs, because ten cores generate far more concurrent memory traffic than six, and any latency in interconnect would multiply across ten competing request streams.

The other first is memory bandwidth. The XRING O3 is the first mobile chip with native LPDDR6 support, running at 10,667 MT/s across four 24-bit channels for a claimed maximum of 113.8 GB/s. That is a generational leap over LPDDR5X that current flagships use, and it supplies CPU, GPU, and NPU simultaneously, all of which can generate substantial concurrent traffic. Bandwidth and latency solve different problems: bandwidth measures how much data moves per unit time under load, while latency measures how long a single access takes. A large GPU kernel wants bandwidth; pointer-heavy CPU workloads want latency. Xiaomi’s expanded cache hierarchy reduces external accesses to cut latency sensitivity, while LPDDR6 raises throughput when data must leave the chip.

Wide execution hardware is part of the picture too. Software performance researcher Daniel Lemire analyzed the C1-Ultra core and described roughly 21 execution ports, including six SIMD-capable ports at 128-bit width, alongside SVE2 and SME2 support. Wider execution allows more independent operations per cycle, but only when the instruction stream contains enough parallel work and data is available. Unmodified scalar loops do not become SME2 matrix kernels just because hardware supports the extension. Compilers and runtime libraries must issue instructions, which is why real-world gains will depend on software enablement as much as silicon. The CPU includes two SME units, and the presence of SME2 and SVE2 gives developers vector and matrix paths that were previously reserved for Apple’s and Qualcomm’s higher-end parts.

The 20 W reality: power, thermal, and throttling

The gap between benchmark score and daily use is thermal headroom. Geekerwan’s dev-board testing found that loading all ten XRING O3 CPU cores reaches about 20 W. That is laptop territory for a smartphone, and no phone can sustain it indefinitely. A short benchmark run starts from a cool device; sustained workloads build heat in the package, memory, and frame until firmware lowers voltage and frequency.

Xiaomi claims up to 25 percent power reduction under low-to-medium loads relative to XRING O1, which is useful for everyday interactive use, and the company says the GPU can match O1’s peak performance while using 64 percent less power. But those claims do not reveal how the 20 W all-core burst behaves after repeated benchmark loops, long game sessions, or video exports. Geekerwan’s efficiency curve tells a more encouraging story at matched performance: XRING O3 could reproduce Snapdragon 8 Elite Gen 5’s roughly 12,000-point peak Geekbench result while drawing less than half the power in the tested configuration. That is a stronger statement about efficiency than comparing two unrestricted peak scores, because it holds performance constant and measures power cost.

The packaging is a known limitation. Geekerwan noted XRING O3 uses traditional package-on-package construction without enhanced heat-dissipation packaging some competing designs use. Package-on-package places memory close to the processor and saves board space, but the thermal path can limit sustained high-power operation. That is not a problem for everyday use, but it matters for all-core workloads where the ten-core design is supposed to excel. A chip that can hit 20 W briefly but must throttle quickly delivers less sustained multi-core throughput than the headline score implies.

The first products test this in different ways. The Xiaomi 18 Fold and Pad 9 Pro Max both ship in September 2026. A tablet offers more surface area and battery capacity than a phone, so the same processor could sustain different clocks in the two devices. The foldable’s hinge, split battery, and display layers make its cooling behavior especially hard to predict from a dev board. The retail tests that matter will run the same Geekbench build on both devices, publish several runs, and report scores after repeated loops, not just the opening peak. A device that preserves most of its opening throughput is more useful for long exports and local processing than one that posts a higher first run and then drops sharply.

The GPU and NPU: rest of SoC

The CPU results should not overshadow the scale of the full system-on-chip. The XRING O3 combines a ten-core CPU with a 16-core Arm Mali-G2 Ultra NX GPU, four-core NPU, LPDDR6 support, fifth-generation Xiaomi ISP, RISC-V security core, media engines, and interconnect that moves data among them. The GPU has 16 compute units and 4 MB of dedicated L2 cache, with eight compute units integrating NX tensor accelerators and eight not, a distinction visible in the die shot, according to Notebookcheck.

Xiaomi claims the GPU is 85 percent faster than XRING O1’s in raster tests and 182 percent faster in ray tracing, with 3DMark Steel Nomad Lite score around 4,567 and Solar Bay Extreme score of 3,628. The company says the Solar Bay Extreme result is 63 percent higher than A19 Pro’s. Geekerwan’s independent testing put the GPU’s Steel Nomad Lite peak above 4,700 points and provided striking context: laptop Lunar Lake chip scores around 3,200 points, desktop GTX 1060 6G just over 4,000, and Apple’s M5 just over 5,000. In other words, XRING O3’s GPU peak has already surpassed GTX 1060 6G and is approaching Apple M5, according to Geekerwan’s comparison. Its efficiency is equally strong: it reaches 2,500 points at just 4.5 W, already surpassing XRING O1’s peak.

The NX accelerators enable a feature that matters for real gaming. Because the GPU hosts dedicated neural cores, Xiaomi can perform upscaling and frame generation on the GPU itself without transferring data to the system-level NPU. Frame data flows directly from shading cores into the internal NX accelerator for spatial and temporal AI upscaling before post-processing. Because image data never leaves the GPU cache hierarchy, this inline execution avoids round trips to main memory, eliminating bandwidth bottlenecks and reducing frame latency. Xiaomi claims a 20 percent power reduction when rendering at 540p and upscaling to 1080p versus native 1080p rendering, and supports upscaling from 1080p to 3.4K and frame generation from 60 fps to 120 fps. Image quality, latency, and artifact behavior will determine whether this is a real advantage or marketing, but the architecture is sound: keeping upscaling on-die avoids memory round trips that would otherwise reduce savings.

The NPU is rated at 200 TOPS using A8W4 precision, meaning 8-bit activations and 4-bit weights, with 3.13 TFLOPS of vector throughput, according to Xiaomi’s specifications reported by Notebookcheck. It uses SIMT architecture optimized for transposed matrix multiplication, SiLU activation, and W4 matrix multiplication. Xiaomi also developed a five-value quantization model with its MiMo model team, optimized for XRING NPU. The TOPS figure carries the usual caveat: it depends on precision, so it should not be compared with differently defined numbers without checking operand format. The CPU’s SME units, GPU’s NX blocks, and dedicated NPU give developers several execution targets, but that flexibility is also a software burden. A workload can perform well on one accelerator and poorly on another because of conversion costs, unsupported operators, memory transfers, or quantization differences. End-to-end latency matters more than isolated accelerator rating.

What developers should actually expect from ten cores

For developers deciding whether XRING O3 changes anything, the useful question is not “is it faster” but “which of my workloads can use ten cores.” The answer depends on how work divides. Serial and latency-sensitive tasks, like app startup and main-thread JavaScript, are limited by one fast core, and single-core parity with A19 Pro is what matters there. The other eight cores do not remove dependency chains. Parallel CPU work, like compilation, file compression, media encoding, and batch image processing, can divide among independent workers and is where the ten-core layout pays off. Memory-bound work gains less, because ten threads that all wait on memory still wait, and the LPDDR6 interface plus 44 MB of cache only help when access patterns reuse data.

On-device machine learning is a separate case. The NPU, GPU NX units, CPU SME2 blocks, and CPU SVE2 instructions all target different operations, and developers need to measure full model execution, including input conversion, tensor movement, unsupported-operation fallbacks, and output processing. A model that repeatedly moves data between CPU and NPU can lose time even when the accelerator itself is fast. Keeping a connected group of operations on one execution target often works better than selecting the fastest unit for each isolated operation. The 200 TOPS NPU rating uses A8W4 precision, so the model must maintain acceptable output quality at that precision for the number to mean anything.

Android and Xiaomi’s firmware need accurate energy models, fast migration decisions, and sensible thermal limits for the three-cluster scheduler to work as intended. Poor scheduling can activate an unnecessarily large core for background work, or leave a foreground task on a smaller core after load increases. The hardware provides options; the scheduler decides whether users get the intended balance. For more on platform constraints that shape how developers deploy and profile on Android, see Sesame Disk’s analysis of Android ADB restrictions and their effect on developers.

Runnable benchmarks to measure difference

When Xiaomi 18 Fold and Pad 9 Pro Max ship, developers can measure the multi-core advantage directly with a few standard-library scripts. These do not reproduce Geekbench, but they isolate specific behavior XRING O3 is built for: parallelizable CPU work and sustained throughput under thermal load.

The first script compares serial workload against a bounded worker pool, which is a pattern that separates a ten-core chip from a six-core one. The job list represents independent chunks of an offline document-indexing task.

Note: The following code is an illustrative example and has not been verified against official documentation. Please refer to the official docs for production-ready code.

import time
from concurrent.futures import ProcessPoolExecutor

def index_chunk(chunk_id):
 # Simulate CPU-bound work on independent document shard
 total = 0
 for i in range(4_000_000):
 total += (i * 31) % 997
 return chunk_id, total

jobs = list(range(20))

# Serial baseline
start = time.perf_counter()
serial_results = [index_chunk(j) for j in jobs]
serial_time = time.perf_counter() - start

# Bounded worker pool (start at 4, tune to device)
start = time.perf_counter()
with ProcessPoolExecutor(max_workers=4) as pool:
 pool_results = list(pool.map(index_chunk, jobs))
pool_time = time.perf_counter() - start

print(f"serial: {serial_time:.2f}s")
print(f"4 workers: {pool_time:.2f}s")
print(f"speedup: {serial_time / pool_time:.2f}x")
# Note: process startup and result collection eat into speedup on short
# jobs. A 10-worker pool can even be slower if setup cost dominates.

The measured speedup will be smaller than the worker count on most devices. Process startup, task dispatch, result collection, frequency changes, and thermal behavior all consume time. Increasing the pool from four workers to ten can make a short job slower if setup cost dominates, which corrects the assumption that more cores always help.

The second script measures sustained throughput across repeated runs, which is the real test of whether a device can hold its peak under thermal load. The XRING O3’s 20 W all-core figure makes this the most important measurement for the ten-core design.

Note: The following code is an illustrative example and has not been verified against official documentation. Please refer to the official docs for production-ready code.

import time

def crunch():
 acc = 0.0
 for i in range(3_000_000):
 acc += (i * 0.5) ** 0.5
 return acc

rounds = 12
times = []
for r in range(rounds):
 start = time.perf_counter()
 crunch()
 times.append(time.perf_counter() - start)

first = times[0]
last_three = times[-3:]
avg_last = sum(last_three) / len(last_three)
retained = first / avg_last * 100

print(f"opening round: {first:.3f}s")
print(f"avg last 3 rounds: {avg_last:.3f}s")
print(f"retained throughput: {retained:.1f}%")
# Note: device that holds most of its opening throughput is better for long
# exports than one that posts high first run and then drops sharply.

The retained-throughput percentage also makes comparisons easier across devices with different absolute speeds, which is how reviewers should compare the foldable against the tablet.

The third script isolates cache-friendly versus streaming access, which tests whether the 44 MB cache claim actually helps given the workload. The XRING O3’s large cache matters only when access patterns reuse data.

Note: The following code is an illustrative example and has not been verified against official documentation. Please refer to the official docs for production-ready code.

import time

small = [0] * (4 * 1024 * 1024) # ~32 MB, fits in L3 + SLC
large = [0] * (256 * 1024 * 1024) # 256 MB, streams past cache

def sum_buffer(buf, passes):
 total = 0
 for _ in range(passes):
 for i in range(0, len(buf), 64):
 total += buf[i]
 return total

# Repeated passes over cache-resident buffer
start = time.perf_counter()
sum_buffer(small, 8)
reused_time = time.perf_counter() - start

# Single pass over buffer too large for cache
start = time.perf_counter()
sum_buffer(large, 1)
stream_time = time.perf_counter() - start

print(f"cache-reused: {reused_time:.3f}s")
print(f"streaming: {stream_time:.3f}s")
# Note: interpreter overhead dominates each loop iteration, so this compares
# same Python runtime across devices, not raw cache latency.

This program is useful for comparing the same Python runtime across devices, but it is not a direct cache benchmark.

Related Reading

More in-depth coverage from this blog on closely related topics:

• What is Nostr? Benefits of Nostr Network
• Latest Chip News and AI Infrastructure
• How to Fix Claude API Problems
• GLM-5.3 Review: Best AI Model for Tablets
• Best Open Source Tools for Lightweight Software Development

Sources and References

Sources cited while researching and writing this article:

• Xiaomi launches XRing O3, claims it is the fastest smartphone SoC with an AnTuTu score of over 5 million – Notebookcheck News
• Notebookcheck’s Apple A19 Pro database
• Geekerwan's In-Depth Test of Xiaomi's XRING O3: Energy Efficiency Crushes All Current Android Flagships, Performance Hailed as “Alien Technology” – King of Computer Media
• Xiaomi 18 Fold is officially coming in September with the monstrous Xring O3 chipset
• Xiaomi’s XRING O3 Chip Just Broke the 4GHz Barrier and That Changes the Custom Silicon Race