The Russian “superprocessor” failed: 32 cores were still not enough for The Witcher 3

A 32-core processor should sound like a serious piece of hardware. In normal PC language, that kind of core count usually belongs to workstations, servers, virtualization hosts, rendering machines, scientific systems, and other heavy-duty platforms. It suggests a processor built for demanding workloads, large amounts of parallel computation, and tasks that would overwhelm an ordinary consumer CPU.

That is why the Irtysh C632 immediately attracts attention. It is not advertised as a modest embedded chip or a low-power office processor. It belongs to a family that includes 16-core, 32-core and 64-core models, which makes it look impressive before any benchmark even begins. On paper, it seems like the kind of processor that should easily handle an older PC game such as The Witcher 3: Wild Hunt.

But the test result told a very different story.

The Russian “superprocessor” failed to impress where ordinary gaming PCs have had no major problem for years. Even with a modern Radeon graphics card beside it, the system reportedly struggled to deliver smooth gameplay. The frame rate stayed roughly in the 20–30 FPS range, and lowering the graphics settings did not produce the kind of dramatic improvement that would normally be expected if the graphics card were the limiting factor.

That detail matters. When a game is GPU-limited, reducing shadows, textures, effects and resolution usually gives a visible performance boost. In this case, the difference between high and low visual settings remained relatively small. That strongly suggests that the GPU was not the main obstacle. The bottleneck was almost certainly located elsewhere: in the CPU, the translation layer, the drivers, the operating system environment, or the architecture itself.

The embarrassing part is the choice of game. The Witcher 3 is not a brand-new technical monster built only for the latest high-end systems. It was originally released in 2015. It has received updates and visual improvements, but it remains a mature, well-known title that modern desktop PCs can run comfortably. If a 32-core processor with a capable graphics card cannot handle it convincingly, the problem is not the age of the game. The problem is the platform.

The processor that looks powerful only on paper

The Irtysh C632 is not an ordinary x86 processor like an AMD Ryzen, AMD EPYC, Intel Core or Intel Xeon. It is based on the Chinese LoongArch ecosystem, which places it outside the mainstream Windows PC gaming world. That single architectural fact changes almost everything.

Most PC games are built around x86-64 processors. Their engines, launchers, libraries, middleware, anti-cheat systems, graphics paths and performance assumptions were created for platforms dominated by Intel and AMD. The whole software chain expects a familiar environment. When a game is forced to run on a different instruction set, the system has to compensate.

That compensation is not free.

A LoongArch-based processor cannot simply run Windows x86 software in the same way a Ryzen or Core chip can. It needs Linux, compatibility layers and instruction translation. The game may start, the graphics may appear, and the controls may work, but every additional layer introduces overhead. The processor is not only running the game. It is also dealing with the cost of making software written for another architecture behave as if it belonged there.

This is where the core count becomes misleading. A 32-core CPU sounds powerful, but gaming does not scale perfectly across dozens of cores. Many parts of a game still depend on fast individual cores, low latency, strong cache behavior, mature drivers, efficient memory access and tight CPU-GPU communication. A processor with many weaker or poorly optimized cores can easily lose to a much smaller desktop CPU with stronger per-core performance.

That appears to be the central weakness of the Irtysh C632 in this test. The Radeon graphics card probably had far more rendering power available than the frame rate suggested. But the CPU side could not feed it quickly enough. The game logic, draw calls, driver communication, operating system scheduling and translation overhead created a bottleneck before the GPU could show its real potential.

Why 32 cores did not save the result

The mistake is assuming that more cores automatically mean more gaming performance. That is not how games usually work.

A game engine contains many different types of work. Some tasks can be distributed across multiple cores, but others remain latency-sensitive and depend heavily on one or a few fast threads. The main game loop, draw-call submission, physics coordination, AI routines, scripting, asset streaming and driver communication all need to happen quickly and predictably. If one of those steps is slow, the whole frame is delayed.

In gaming, frame time is often more important than theoretical throughput. A processor can have many cores and still produce poor frame pacing if the work that matters most is not completed quickly enough. That is why a modern 6-core or 8-core gaming CPU can outperform a much larger server-style processor in games. The smaller CPU may have fewer cores, but each core is faster, better optimized and supported by a far more mature software ecosystem.

The Irtysh C632 seems to suffer from exactly this problem. Its 32 cores may be useful in certain parallel workloads, but they do not automatically translate into smooth gaming. If the game or translation layer cannot efficiently use all those cores, much of the hardware remains underused. The system may show impressive numbers in a specification table while still feeling slow in an interactive workload.

This is especially visible when lowering graphics settings does not help much. That usually means the GPU is waiting. The processor is failing to prepare frames fast enough. The graphics card is not being pushed to its limit because the platform cannot deliver work to it at the required pace.

The architecture barrier is the real story

The poor result is not just about one chip being slow. It is about the difficulty of escaping the x86 ecosystem.

The x86 world is old, messy and sometimes criticized, but it has one enormous advantage: compatibility. For decades, software developers have built around it. Game studios test on it. Graphics drivers are optimized for it. Windows is deeply tied to it in the gaming market. Steam libraries, launchers, middleware, modding tools, engines and performance profilers all assume that x86-64 hardware is the default.

A non-x86 processor has to fight against that entire history.

Instruction translation can bridge the gap, but it cannot make the gap disappear. The system has to translate code designed for one architecture into something another architecture can execute. It has to handle different instruction behavior, memory models, vector operations, calling conventions and performance characteristics. Even when the translation is technically correct, it may not be fast enough for demanding real-time workloads.

Desktop applications can often tolerate this kind of overhead. A text editor, a browser tab, a file manager or a simple office tool may feel acceptable if the translation layer is competent. Games are less forgiving. They need consistent frame delivery. They need low input latency. They need the CPU, GPU, drivers and operating system to cooperate with minimal delay.

That is why The Witcher 3 becomes a useful stress test. It is not simply asking whether the Irtysh C632 can run software. It is asking whether the whole platform can behave like a practical gaming PC. The answer appears to be no.

Linux helps, but it cannot perform miracles

Linux is one of the main reasons a system like this can run complex desktop software at all. It supports many architectures, it is flexible, and it gives unusual processors a chance to become usable outside closed vendor ecosystems. For LoongArch-based hardware, Linux is not just helpful. It is essential.

But Linux alone does not solve the problem.

To run a Windows game on non-x86 hardware, the system needs a whole stack of software. It needs compatibility layers, graphics API translation, binary translation, usable GPU drivers, audio support, input handling, memory management, scheduler behavior and stable libraries. Each layer has to function correctly. More importantly, each layer has to function efficiently.

A single weak layer can ruin the whole result. If the binary translation is slow, performance collapses. If the graphics driver is immature, the GPU is underused. If the CPU scheduler is not tuned well for the architecture, cores may not be used effectively. If the compiler and libraries are not mature, even native components may perform below expectations.

The fact that The Witcher 3 can run at all is technically interesting. It shows that the software stack is not completely theoretical. But running a game is not the same as running it well. A platform that barely reaches smooth frame rates in an older title is not ready to challenge mainstream gaming hardware.

Server-style hardware can be bad at gaming

There is another important distinction: a processor designed with many cores may be aimed at server or infrastructure workloads, not gaming.

In server environments, high core counts can be very useful. Web servers, databases, virtual machines, storage systems, network services, container platforms and batch processing tasks can benefit from many cores because they often run many independent jobs at the same time. A 32-core CPU can be useful even if each core is not extremely fast, as long as the workload is highly parallel.

Gaming is different.

A game is interactive. It needs quick response, low latency and consistent frame times. It does not merely need the ability to complete a lot of work eventually. It needs to complete the right work before the next frame deadline. That is a much stricter requirement.

This is why even some x86 server processors are not ideal gaming CPUs. They may have many cores, large memory support and serious throughput, but they can lose to desktop chips with higher clocks, lower latency and better gaming-oriented boost behavior. With Irtysh, the situation is even harder because the platform also carries the burden of non-x86 software compatibility.

So the problem is not only that the Irtysh C632 has weak gaming performance. The deeper problem is that its strengths, if it has them, may not align with what a game like The Witcher 3 needs.

The GPU was probably waiting for the rest of the system

Pairing the Irtysh C632 with a Radeon RX 9060 XT makes the result more revealing. A graphics card in that class should not normally struggle with The Witcher 3 in a properly balanced modern system. If the GPU were the main limitation, reducing graphics quality should have produced a major improvement.

Instead, the performance pattern suggests that the GPU was underfed.

A graphics card cannot render frames efficiently if the CPU side cannot prepare them quickly enough. Before the GPU can do its work, the CPU has to process game logic, prepare draw calls, handle scene management, coordinate assets, communicate through the driver and manage the operating system side of the workload. If those tasks arrive too slowly, the GPU sits partially idle.

This kind of bottleneck can make a powerful graphics card look weak. The problem is not the GPU’s raw rendering power. The problem is that the rest of the platform cannot keep up with it.

That seems to be exactly what happened here. The Irtysh system had enough graphics hardware to do better, but the processor and software stack created a ceiling that the GPU could not break through.

The bigger problem: ecosystem maturity

A modern processor platform is not just a chip. It is an ecosystem.

This is the part that specification sheets often hide. A CPU needs firmware, motherboard support, kernel support, compilers, optimized libraries, drivers, debugging tools, documentation, developer adoption, application support and long-term maintenance. Without those elements, the silicon alone does not matter very much.

Intel and AMD have decades of advantage here. Their processors are not only fast because the hardware is advanced. They are fast because operating systems, drivers, engines, compilers and applications have been tuned around them for many years. Game developers know how those platforms behave. GPU vendors optimize for them. Toolmakers support them. Users trust them because the software usually works.

Irtysh does not have that advantage.

Even if the hardware is technically capable in certain scenarios, the wider platform remains immature compared with x86. That immaturity becomes visible in exactly the kind of test users understand: a familiar game running badly.

This is why the story matters beyond one benchmark. It shows that building a CPU is only the first step. Building a credible computing ecosystem is much harder.

The Russian technology angle

The Irtysh processor family also has a political and industrial background. Russia has clear reasons to reduce dependence on Western processor technologies, especially under sanctions and export restrictions. If access to x86 technology, advanced manufacturing channels or Western intellectual property is limited, alternative architectures become strategically attractive.

In that context, turning toward Chinese technology is understandable. LoongArch-based systems offer a route toward computing platforms that are less dependent on Intel, AMD or Western licensing. For government, industrial, educational or infrastructure use, that can have strategic value even when consumer performance is not competitive.

But strategic value and market competitiveness are not the same thing.

A processor can be politically useful and technically interesting while still being a poor replacement for a mainstream desktop CPU. It can serve controlled internal systems and still fail as a gaming platform. It can represent technological independence and still deliver weak performance in software designed for another ecosystem.

The Witcher 3 test makes that distinction very clear. Irtysh may be part of a broader industrial strategy, but that does not mean it is ready to compete with ordinary gaming PCs.

The symbolic failure is hard to avoid

The reason this story is so easy to understand is that the contrast is obvious. On one side, there is a 32-core “superprocessor.” On the other side, there is an older game running at unimpressive frame rates. The result almost writes its own headline.

Technically, the situation is more nuanced. The poor performance likely comes from a combination of factors: limited per-core performance, translation overhead, immature optimization, driver issues, software compatibility problems and platform immaturity. It would be too simplistic to blame only the chip itself.

But public perception does not work that way.

For most readers, the visible result is enough. A processor with 32 cores was paired with a capable GPU and still struggled in The Witcher 3. That makes the “superprocessor” label look inflated. It turns the core count from a strength into a punchline.

This is the danger of marketing hardware through headline specifications. If the real-world experience does not match the numbers, the numbers become embarrassing.

Why Apple Silicon succeeded where Irtysh struggles

Apple Silicon is often used as proof that non-x86 processors can succeed. That comparison is useful, but it also shows why Irtysh faces such a difficult road.

Apple did not simply release a new CPU and hope the market would adapt. It controlled the hardware, the operating system, the development tools, the application transition, the translation layer and the user experience. Rosetta 2 worked as well as it did because Apple could coordinate the entire platform. Developers had clear incentives to support the new architecture, and users received polished hardware with strong software support from day one.

Irtysh does not appear to have that kind of unified environment.

It is trying to work against an existing PC software world that was not built for it. It does not control Windows gaming. It does not control major game engines. It does not control the Steam ecosystem. It does not have decades of driver maturity or consumer application optimization behind it.

That does not mean improvement is impossible. But it means the path is long. A non-x86 CPU can compete only if the surrounding ecosystem is strong enough. Without that, even many-core hardware can feel slow.

Could performance improve in the future?

Yes, but not overnight.

Better compilers could improve native performance. Better binary translation could reduce overhead. More mature Linux support could improve scheduling and stability. Better GPU drivers could raise utilization. More optimized libraries could improve general responsiveness. Game-specific patches could make some titles run better.

All of that is possible.

However, there are limits. Translation overhead can be reduced, but not completely removed. Driver maturity takes years. Developer support depends on user adoption. User adoption depends on software availability. Software availability depends on developer interest. This creates the classic chicken-and-egg problem that every alternative platform faces.

Users do not want hardware without software. Developers do not want to optimize for hardware without users. Hardware vendors cannot attract users without software.

That loop is difficult to break.

For Irtysh, the challenge is even greater because it is not merely competing with another new processor. It is competing with the entire x86 PC legacy.

What ordinary users should take from this

For ordinary PC users, the conclusion is simple: this is not a practical gaming platform.

That does not mean the Irtysh C632 is useless. It may have value in controlled environments, infrastructure projects, government systems or specialized workloads where software can be selected or developed specifically for the architecture. It may also be important as part of a long-term domestic technology strategy.

But for gaming, the result is poor.

A user who wants to play PC games expects compatibility, performance and predictable behavior. They do not want to rely on complicated translation stacks, uncertain driver maturity and architecture-specific limitations. They want the game to run well. In this test, the Irtysh platform did not deliver that.

For developers, the lesson is also clear. Alternative architectures need more than hardware announcements. They need toolchains, documentation, native software, performance profiling, driver work and real application support. Without those, the hardware remains a curiosity.

Why x86 remains so difficult to replace

The Irtysh C632 test also explains why x86 remains so dominant in desktop gaming despite years of predictions about its decline.

x86 is not necessarily elegant. It is old, complex and full of historical baggage. But it has one decisive advantage: everything supports it. Operating systems, games, drivers, utilities, engines, professional applications and user expectations all revolve around it.

Replacing that is not just a technical problem. It is an economic and cultural problem as well. Developers go where users are. Users go where software works. Hardware vendors optimize for the platforms with the largest market. That reinforces the existing ecosystem.

Any challenger has to offer enough advantages to overcome that inertia. It must not only be different. It must be good enough, compatible enough and reliable enough to justify switching.

The Irtysh C632 does not appear to be anywhere near that point for gaming.

The lesson for hardware marketing

The Irtysh test is a reminder that core count is only one part of processor performance. It is useful, but it can be deceptive when treated as the main indicator of speed. A good gaming CPU needs strong per-core performance, low latency, efficient cache architecture, mature drivers, good memory behavior, stable scheduling and optimized software support. It also needs to work well with the GPU. If those conditions are not met, more cores will not solve the problem. A 32-core processor can be powerful in the right workload and weak in the wrong one. It can look impressive in a server specification and disappointing in a game. It can deliver theoretical throughput while failing to provide smooth frame times. That is exactly why real-world tests matter. They expose the gap between what hardware claims and what users actually experience. The Russian Irtysh C632 is interesting, but not because it threatens Intel or AMD in gaming. It is interesting because it shows both the ambition and the weakness of alternative CPU ecosystems.

On paper, the 32-core specification looks strong. In practice, The Witcher 3 exposed the limits of the platform. The weak frame rate, the limited improvement at lower graphics settings and the likely CPU-side bottleneck all point in the same direction: the hardware and software stack are not mature enough for mainstream gaming. The issue is not only one processor. It is the architecture, the translation overhead, the lack of native optimization, the immature ecosystem and the difficulty of escaping decades of x86 dominance. The Irtysh C632 may have a role in strategic computing, controlled infrastructure or experimental non-Western platforms. But as a desktop gaming CPU, it failed to make a convincing case. For now, the Russian “superprocessor” looks far stronger in a specification table than it does in a real game. Its 32 cores could not hide the weakness of the platform around them, and The Witcher 3 turned what should have been a technical demonstration into an uncomfortable reminder: real performance is not measured by core count alone.