This article is like our research/whitepaper piece that presents some experiments and possible representations for animation error in benchmarks

The Highlights

• Benchmarking has long had a problem of ensuring numbers relate back to the reality of what players feel when gaming
• Game stutters have sometimes been misattributed to frametime pacing issues rather than the actual problem, which was animation error, aka simulation time error
• The issue mostly comes to explaining precisely why stutters and hitching are happening in games, not just that they exist

Table of Contents

• AutoTOC

Intro

We have a new benchmark metric that exposes a limitation with current GPU and CPU game testing.

Editor's note: This was originally published on October 13, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Testing, Writing, Research

Patrick Lathan

Camera, Video Editing

Vitalii Makhnovets

Video Editing

Tim Phetdara

3D Animation, Editing

Andrew Coleman

Writing, Web Editing

Jimmy Thang

This is that limitation: Frames are displayed at an even pace in this example, but something is still wrong with it. The thing that’s wrong is why we have the new measurement methodology that we’re debuting today: Animation error.

Animation error is the difference between the pacing of animation and display. Putting "animation" in the name might be confusing: Intel called it Simulation Time Error at one point. 

And this is a sample chart illustrating what we’re talking about, where you can see the animation error timing sometimes in alignment with frametime spikes, sometimes out of alignment with it, showing that it’s a different thing. 

Here’s another chart showing the percent animation error during a test pass. 

Or this one, where we show the CPUStartTime versus animation time delta.

These are all new types of benchmark charts that haven’t been shown before. Tom Petersen first pitched the idea of animation error a couple years ago, something he arguably began on about 14 years ago.

The problem with GPU, CPU, and new game benchmarks has always been that it’s tough to accurately capture the actual player experience. Framerate was a good start, and frame-to-frame interval testing (or "frametime testing") was a great expansion on that -- but neither perfectly captures the real experience.

This is what we’re unveiling and detailing today. Consider this a whitepaper, like a research piece that’s intended to put information out to the community for people to start trying to experiment with. None of this is perfect yet, but we think we have a good foundation for viewers and other reviewers to build upon and advance our understanding of game behavior. If you’re a reviewer and this is useful, please point back to this story as it was over a month of work for us to wrap our heads around.

Let’s get into it.

This methodological deep-dive lays the foundation for new testing. It’s exploratory.

We rolled-out 1% low and 0.1% lows in our testing back in 2014, eventually popularizing their presentation on bar charts alongside average framerate. These are the metrics we use today to point us toward a problem with frametime pacing. The industry has relied on frametimes, 1%, and 0.1% averages for over a decade now with few new metrics in between. 

The history to that is all important, and it’s important that those who did the groundwork before us are known: Tom Petersen, PC Per’s Ryan Shrout, and Tech Report’s Scott Wasson all advanced this metric, with Petersen doing heavy lifting on providing software tools and early insights to frametime analysis. His engineering work has continued with the open source tool PresentMon, which gets us to animation error today.

Animation Error should be thought of in a more traditional sense: Like a flipbook with perfectly animated drawings, but without the execution of flipping through the pages at a constant tempo. That's just one specific scenario for animation error; you could extend the metaphor, like flipping through the pages perfectly but messing up the drawing (or you could do a combination of both).

We're talking about animation in the dictionary sense, "a movie, scene, or sequence that simulates movement from a series of still frames," so animation error applies to entire frames. Think of it like frames of drawings on an animation lamp, in a flipbook, or on a reel of film. We're NOT talking about errors in animation of individual models, objects, NPCs, or sprites within the frames, and we’re also not talking about games that just have bad animation from the artists. 

You could technically have animation error even staring at a blank wall in-game without any movement whatsoever, though it might be impossible to notice.

This all comes down to two things: Smoothness and acceleration. When we were talking to Tom Petersen about this concept, he made some good points about this. Showing frames faster allows the brain to interpolate and generate an illusion of smooth motion, which is the illusion of TV and movies. But the brain also knows how to identify acceleration, something Tom equated back to “monkey times like running away from lions and shit.”

This is an example of animation error that we created in 3D space. It’s very smooth and accurate as a rate, but it’s slow. Every now and then, you’ll see an error in it despite the smoothness of the frames, and that’s stutter. When the brain sees even subtle acceleration or deceleration, we pick it up quick. That’s what makes it feel so bad when we see stutter in gaming. Stutter is what you’re seeing here: Something accelerates or decelerates quickly and the body is overreacting because, to quote Tom, “we don’t want to be eaten by a lion, or some shit like that.” He really has a gift with words.

But it would be great if we could measure smoothness and acceleration separately, because they’re different problems: Framerate and frame-to-frame interval evaluate smoothness, but acceleration is something we haven’t done a good job at quantifying in this industry. That’s characterized by animation error, which we’re introducing with its first full charts today.

This chart is from our Dragon’s Dogma 2 testing at launch, where we were quietly beginning to farm data for this eventual piece. You can see where the animation error blips often align with the frametime spikes, but not always.

AnimationError can also be positive or negative. When a frame is displayed "too late" (relative to its correct placement) that's a negative error, and when it's shown "too soon" that's a positive error. Neither is good. At a macro level, it doesn't matter which is which: further away from 0 is always worse. 

The idea is that if frames are created at a certain pace, you should see those frames displayed at the same pace. There are differences between animation error and frametime pacing, though. 

If there's a mismatch, that's where the animation part comes in: movement depicted in the frames will appear jerky and wrong, even if frametimes are perfectly consistent. 

For a real-world demonstration, the simplest, most reliable way we found to directly induce animation error was with SLI. 

Yeah, we know.

We can take one card and get a normal result, then add a second and get a result with higher animation error. 

That limits us to older hardware, and it also limits us to GPUs that we own in pairs. We selected two 1080 Tis (read our revisit) since they're our newest cards that still use regular old SLI, and (as of now) they're still supported in the most recent NVIDIA driver package. We also had to select a game that supported SLI.

We’re getting into benchmarks. We’ll break these down starting at the most abstracted metric, which is this chart. 

This is framerate represented as bars, abstracting away from time. Next, we’ll look at the frametimes that create this framerate average, and last, we’ll look at the new animation error metric.

These are averaged results for 30 second logs of Far Cry 5's baked-in benchmark, one using a single 1080 Ti and one using two 1080 Tis in SLI. The 1% and 0.1% lows indicate that there weren't huge frametime spikes, and it’s these metrics that tell us when we should inspect a frametime plot closer for major problems. Average FPS smooths over problems, 1% and 0.1% are still averages and can still smooth over them, but are more likely to draw our attention toward a problem because they’re averaging the worst 1% and worst .1% of data.

As a reminder, we aren't using percentiles, which is a different way of approaching this. We explained that in our video where we did JayztwoCents' lab overhaul.

The average with SLI is higher, as expected; however, beyond that, there’s no dramatic change between how these numbers manifest. The single GTX 1080 Ti appears to have closer frametime pacing to its average, which is what we’ve been preaching for years as a good result, but the dual 1080 Tis still look good overall.

Data Presentation: Frametimes

The frametime plot helps us see deeper into those bars. 

This still isn’t animation error, though, and it’s still not new.

This plot of frametimes is for two individual passes. As we know based on the last chart, the SLI run’s gap between the average and its 1% and 0.1% metrics is wider. Here, that materializes in the form of spiky behavior (particularly in the 500-1000 frame range) for the SLI configuration. The experience is far less consistent, with more sporadic frametime excursions from baseline. Most users begin to notice these around 8ms, according to an interview we conducted with Scott Wasson years ago, but only if they frequently occur. 

The single-card run has more consistent frametimes, despite its lower average. It’s not so bad that it’s a ruinous experience, as the SLI configuration is ultimately still within the range of 2-4 ms of the baseline, but the relative distance from baseline is larger. It’s not like we’re seeing 100ms spikes where you’d stare at one frame for 1/10 of a second, as we’ve seen in other tests on modern single cards.

Data Presentation: Animation Error

Here’s the new stuff.

The left axis shows animation error in ms, with deviations away from zero depending on whether frames showed up too soon or too late. 0 is perfect and 0 does occur. The X-axis represents frames, the same as the frametime plot we just showed. The animation errors could also be taken as absolute values for a lower-is-better representation, but this is a plot of the raw data as logged by PresentMon. 

There are many ways this data could be plotted. A scatterplot lets us judge the data points individually, but still keeps the points in order so we can see how behavior changes over the course of the test. Lines between the points wouldn't mean much here.

By plotting the animation error, we can get rid of frametimes as a variable and just compare that relative spikeyness as a player would truly feel it interacting with the game itself. This is closer to the real experience, in the same way end-to-end latency can be but for different reasons. The further the deviation from zero in either direction, the worse. The cards in SLI frequently had 2-3ms of animation error per frame, while the single card typically had well under 1ms animation error. The SLI configuration is significantly worse for animation error in a relative sense, despite even the frametime data looking not that dramatic.

The single card is clearly far better in terms of animation error, although we need more data to judge whether the SLI result is "bad."

Strange Brigade Animation Error

This is another test. This time, we’re using Strange Brigade. Our goal today is exploratory, so we’re choosing games based on usefulness to explore the concept, not on their popularity. That’ll come later.

The main advantage of a plot like this is that we don't have to insert our own calculations or conclusions: we can simply show the data. The single 1080 Ti sticks even closer to zero animation error per frame than it did in Far Cry, while the SLI 1080 Tis continue to generate 2-3ms of positive or negative error on nearly every frame, only rarely approaching zero. 

SLI outperforms the single-card so heavily in this title that the red line is significantly shorter, which is a downside of using frames as an X-axis. Even though both its average framerate and its 1% and 0.1% lows are overall good here, the animation error is far superior on the single GPU. There is a possibility that it feels better to a player, but not for the reasons everyone in this community has said for years: It’s not due to frametimes, on a technicality, but animation error, which is a metric that has been under the surface this whole time.

Animation Error Bar Chart

This is an “Error Per Frame” chart we attempted, which puts the data back into bars for denser comparison of more cards. Maybe this could work better as a visualization: for those two individual passes in Far Cry from earlier, the total animation error (taken as absolute values) divided by the total number of frames was 0.13ms per frame for the single 1080 Ti and 2.31ms per frame for the SLI 1080 Tis. These are basically single-number summaries for the plots we just showed. But now we’re doing the bad thing again: We’re abstracting away from the base metric over time (shown as frames) and converting it into a bar, because that’s easier to read. This isn’t ideal for a lot of reasons.

First of all, this could obscure individual big error spikes (if that's something we want to track), and secondly, it also adds framerate back in as a variable. The SLI setup generates more frames, which lowers the end result for this calculation, arguably making the SLI cards look unfairly good; then again, maybe it’s not “unfairly” because more frames going by quicker could help disguise animation error.

This is getting complicated, but you can see why we’ve had to think about this for weeks.

Far Cry 5 Animation Error Percent

So we don’t like the prior chart for those reasons, and the scatter plot doesn’t accommodate more than two or three GPUs before it’s illegible. Maybe this will help.

This alternative was suggested by Tom last year. It divides the total animation error absolute values by the total frametimes (the length of the test run) to get a ratio or percentage. 

This is equivalent to comparing those average error-per-frame numbers from the last chart to average frametimes. 

However, in order to make this chart we’re showing accurate and not misleading, we had to use two times the total frametimes for the calculation because otherwise, the implication is that 100% is the maximum value, and it wouldn’t be if we hadn’t corrected for that, and that’s because in the absolute worst case scenario and assuming that latency doesn't accumulate over the course of the test run (which is a different subject entirely), the maximum total animation error would be twice total frametime. 

THIS diagram makes that abundantly clear by showing that alternating between infinitely small frametimes rounded to zero and 10ms frametimes, and inversing the display times, we can get 10ms or -10ms of animation error per frame, where adding up all frametimes gives us 30ms yet adding up absolute values of the animation error gives us 60ms.

OK, this graphic really isn’t helping make it less confusing. The point is, we already corrected for this in our percent chart and any other reviewers planning to use such a chart will need to do the same.

We used the same two Far Cry passes for this example: for the single 1080 Ti, the result is 0.7%, and for the SLI setup the result is 17.3%. This potentially cancels out or reverses the high-framerate advantage from the last chart: more frames equals more (total) error.

Real-World Uses

Let’s talk potential real-world use cases. Maybe this will give other reviewers some ideas.

Animation error is theoretically decoupled from framerate and frametime consistency, although in reality poor performance correlates across all of those categories. 

In this mockup from Intel, the bar marked "CPU Stutter" marks a frametime spike, while the mismatch between the sizes of the bars in the top and bottom rows is the animation error (F1 versus F1 = error for F2, F2 versus F2 = error for F3), so we'd see similar spikes in both metrics.

Animation error is also separate from latency: it's about how the frames are spaced, not whether they're all showing up ten seconds late.

Frame generation has interesting implications for animation error, but unfortunately there's no animation time for fake frames, so there's no reference point for calculating error. That makes this whole thing even more challenging to quantify.

We'd like to check on NVIDIA MFG in particular, since that comes along with flip metering that shuffles frame timings around at the end of the pipeline, which has the potential to actually induce animation error (as we mentioned with the SLI example).

Animation error could shine a light on shortcomings of flip metered frame generation that are currently masked with existing testing methods, but we won’t know until the software works on it, which may at least partially rely on NVIDIA’s willingness to play ball.

Dragon’s Dogma 2 Animation Error

Because we expect AnimationError to correlate with frametime spikes most of the time, its most common usages for us will be similar to 0.1% lows and frametime plots, but with a more direct representation of how the game feels. 

For example, this is a chart that Tom helped us generate during the early stages of troubleshooting Dragon's Dogma 2's performance back when it launched -- that’s how long we’ve been thinking about this data. 

The spikes in both metrics line up exactly, but animation error adds depth by telling us why the stuttering was so noticeable and unpleasant. The positive and negative animation error dots that correspond to the frametime spike toward 60ms around frame 500 shows a potential for 45ms of animation error. That’s potentially a lot more noticeable than even the already noticeable frametime hitch of 58ms.

Borderlands 2 Animation Error

Here’s Borderlands 2. Yes, we know there are newer ones. But this is a better demonstration.

Since animation error effectively cancels out framerate differences, we can use it to compare two completely different pieces of hardware and get more nuance out of it.

These two results are from our piece about the death of 32-bit PhysX. These two particular results were fairly close together both in terms of average FPS and lows: the GTX 980 with GPU PhysX averaged 101 FPS across multiple passes and the RTX 5080 (read our review) with CPU PhysX averaged 95 FPS. These are real results and we explained them in our piece about NVIDIA killing 32-bit PhysX support this year.

In spite of that, there's a clear difference in behavior, and animation error is much higher with the GTX 980. Using the percentage math we mentioned earlier, that's an error-to-frametime ratio of 11.9% for the 980 and 1.8% for the 5080, which allows us to identify a problem without having to generate frametime plots for every single result.

Percentile Limitations

We probably wouldn't use a test scene that resulted in a graph like the GDC 2015 one shown above by NVIDIA, but as it points out, there are scenarios like this where frametime spikes could be artificially masked and not show up in 1% and 0.1% low calculations. 

NVIDIA is using percentiles here instead, which we don’t use, but the idea is similar. 

Assuming these frametime spikes were accompanied by animation error, calculating animation error would do a much better job of summarizing the problem (in this instance). That said, our approach to lows already helps to control for some of this, but it still requires knowledgeable testers to know when to look into the 0.1% and 1% low results. 

Microstutter & Multi-GPU

Animation error has been associated with microstutter in the past, but it's not quite the same thing. If anything, animation error is a way to measure microstutter, but not microstutter itself, depending on the definition. Microstuttering was frequently brought up in the context of multi-GPU rendering, so we'll go back in time and start there by referencing materials from GDC 2015.

This simplified timeline establishes our foundation: each block is a frame, and frame N gets displayed while the computer works on frame N + 1 behind the scenes. CPU work isn't represented here, but we'll ignore that for now. The frame times are perfectly consistent, which is ideal. 

This next slide shows how Alternate Frame Rendering (AFR) multi-GPU operates, or at least operated back when anyone actually supported it. Each of the GPUs takes turns rendering frames, and the output is combined and displayed in order. The blue boxes are still uniform sizes, indicating consistent display times, and they're smaller than the previous diagram, indicating a higher framerate.

One of the major difficulties with AFR is trying to synchronize GPUs. Here, GPU0 and GPU1 are taking the same amount of time to complete individual frames, but they're poorly synced so that some frames get little display time and are effectively wasted. 

These are also known as “runt frames,” where fractions of frames are shown in a way that elevates the average FPS, but creates an awful experience with bad tearing. The average framerate is higher because more frames were technically shown, but the additional frame is useless and the actual experience can look lower in framerate, which is one definition of microstutter.

Again, we can't see the CPU stage of the pipeline here, but we'll assume it's being completely consistent. 

In this example, the rhythm of animation matches the rhythm of display, so there is no animation error. The framerate is stuttery, but all the moving stuff in the frames shows up in the right place at the right time. After each short frametime, objects move a little; after each long frametime, objects move a lot.

You can avoid that microstutter by forcing the pacing into alignment. Ideally this happens by manipulating delays early in the pipeline (on the CPU), in which case you return to a clean result like this one.

However, if you were to meter those frames out at the END of the pipeline, that would directly contribute to animation error (or "animation stutter," as NVIDIA put it back then). We've created and rendered an edited diagram to show what that would look like. If you just take the "short" frames and hold onto them longer before flipping, then there's a mismatch between the pacing of the frames as they're displayed versus the animations depicted in those frames. That leads to perceived stuttering and rubberbanding.

Back to our earlier animation, that’s seen when comparing the red and green indicators below the scene, where the imperfect ball stalls and then gets dragged forward in uneven intervals.

We aren't exploring which method NVIDIA or AMD used to deal with microstutter; that's a subject for another time, and that time was 12 years ago. Today, we're just showing a real world example of a situation where animation error was a risk.

Animated Examples

Andrew on the team made some 3D mockups of simulated animation error. We started by rendering out a scene at 120 frames per second. This could have been any arbitrary number, but picking a high framerate allowed us to downsample and play around with the spare frames.

Here's what that looks like. The top row of squares represents our 120 FPS source video, and we'll pretend that our simulated game has an impossibly low latency of zero, meaning that this row represents in-game reality. The bottom row of squares represents frames that we pulled out of the original sequence to create our 60 FPS video. Because we pulled exactly every other frame, we still have smooth playback with zero frametime spikes and zero animation error. Because we display the frames in sync with their original placement, we have zero latency as well.

Since we're pulling frames every 16.67ms from the source video, our AnimationTimes are always 16.67ms. And since we're also displaying those frames every 16.67ms, our DisplayedTimes are always 16.67ms. Therefore, AnimationError is always zero.

The green circle represents "reality" as determined by our source video, while the red circle represents what we're actually seeing. Again, these match perfectly in this control example.

By taking some of the spare frames from the source video, we can create animation error, but we need to be specific. The diagonal lines mean that we're taking the original frames and displaying them later than "reality," which introduces latency. Latency itself is not animation error. That’s a different problem. 

As we play through the big lump of diagonal lines at the start of this clip, the red circle falls behind the green circle, but the animation of the video remains smooth. Animation error is when the red circle jerks around, skipping to catch up with the green circle at an uneven pace. If you watch the video clip when this happens, you can see the interruptions. This is what we mean when we say animation error is a measurement of jitteryness.

Here's an extreme example of our point about latency: we're displaying every frame 41.67ms "late," so the red circle lags behind the green, but the resulting video is identical to the control. AnimationTimes and DisplayedTimes are still perfectly matched 16.67ms intervals every time, so there's zero animation error.

We can do this multiple times during the clip to intensify that feeling of rubber-banding. We're creating a lot of variation in our simulated AnimationTimes here: if we take two back-to-back frames from the 120 FPS source video, that's an 8.33ms AnimationTime. If we pull two frames that were spaced four apart in the original video, that's a 33.3ms AnimationTime. Meanwhile, our DisplayedTimes remain constant, because we're still displaying fresh new frames exactly 16.67ms apart. That's the mismatch in pacing that animation error quantifies.

As Tom told us before, our challenge is to "make people understand that you can take frames and show them with an even cadence on display and still have it look like shit." He has a real way with words. It’s like poetry.

We can also create an inverse example. Think about a flip book. Here we've pulled frames from the source video at even intervals for constant simulated AnimationTimes of 33.33ms, but by displaying those frames at uneven intervals, we still create animation error. This is like drawing a perfect flipbook animation and then failing to flip through the pages at a constant tempo. This is a weird theoretical example, because if we assume this is a case where frametimes equal animation times, PresentMon would report a completely steady 30FPS based on MsBetweenAppStart.

That's not the only way for animation error to manifest, though—in fact, it's pretty unlikely that you'd naturally encounter perfectly consistent DisplayedTimes with inconsistent AnimationTimes, or vice versa. A more realistic scenario is this one, which simulates CPU-based stuttering, like the diagram Intel shared with us.

Here, rather than displaying a unique frame every 16.67ms, we freeze on individual frames. These are DisplayedTime spikes, which usually correlate to FrameTime spikes under the hood.

For each spike, we get two animation errors: after a frozen frame, the next frame is judged to be too late, and the frame after that is judged to be too soon.

This is closer to what we've observed in games, but just like with latency, it's important to remember that the frametime spikes are not the same thing as animation error: you could theoretically keep freezing on frames while maintaining zero animation error. 

To help explain, let's cover a real-world example.

Capture Demonstrations

For easier discussion, we're mostly ignoring VSYNC and variable refresh so that the monitor is not a factor in any way. 

When we say frames are "displayed," we mean that a flip has been signalled to the operating system, and without VSYNC, that flip can happen even if the monitor is in the middle of a refresh (leading to tearing). 

That pushes numbers logged without VSYNC towards the theoretical realm, but no more so than usual: for example, in our launch review, the RTX 5090 averaged a ridiculous 407 FPS in the Dawntrail benchmark at 1080p. That's a comparable performance number, independent of whatever monitor we used, and in that context, that's what we wanted because we want percent scaling between devices.

Separately, higher framerates do correlate with lower latency, so there’s value from that side as well. Today though, we’re also ignoring latency for purposes of focusing discussion.

All of that said, the easiest way to actually show animation error in captured footage is with VSYNC to avoid tearing. If you ignore the overall drops in framerate and focus on the movement of objects that should be smoothly traveling across the screen, you'll see them appear to change speed and jump around: that's animation error.

It's most noticeable in fast panning shots with smooth tracking: the camera should be moving at a steady rate even when the framerate drops, but it appears to hitch and rubber-band, especially when played back at half speed. Animation error is separate from frametime spikes, but the two things are frequently associated, and they're both bad.

We want to be careful here, because animation error is uniquely bad when VSYNC is enabled, and this footage isn't representative of the non-VSYNCed test passes that we're about to discuss.

One of the only ways we can represent those test passes in fixed-framerate capture is with an FCAT-style overlay, which adds a visual indicator of where torn frames begin and end. This helps illustrate runt frames as well, and was used in VirtualDub back in the day. That gives us an indicator of each individual frame that we're discussing without adding the complication of VSYNC, but it does also mean that frames may only show up as a tiny sliver of pixels.

If we play back this footage slowly, you can frequently see the pattern of tearing: a new color shows up at the bottom of the bar in one frame of the capture, then it continues from the top of the bar in the next frame of capture. It's kind of a mess, and it's difficult to focus on one sliver of frame at a time, hence using VSYNC for visualization in spite of the downsides. The FCAT functionality would be more useful as part of the PresentMon overlay, which can simultaneously show a live graph of animation error.

Advanced Definitions

Here are the PresentMon CPU metrics.

PresentMon CPU Metrics:

CPUStartTimeInMs: The moment where a new frame is born, expressed as a timestamp (relative to the beginning of the PresentMon session).

AnimationTime: This is PresentMon's best estimate of the frozen moment in game time that's depicted by a frame. As a player, you're always seeing rendered images of a game several milliseconds after the in-game reality that they depict. AnimationTime is the timestamp for that reality. 

According to Tom Petersen last year, "Today people are mostly using CPUStart as the AnimationTime, which is a pretty good proxy, and that's what we're going to be doing initially. There are explicit APIs, both from NVIDIA and from us [Intel] and others that are allowing game engines or games to tell you that AnimationTime. And so as that becomes more available, we'll be building that into PresentMon." 

Logically, AnimationTime should be the same as the moment the frame was born (CPUStartTimeInMs), but games can pull tricks to smooth animations so that AnimationTime for a frame doesn't line up with wall-clock time. Under normal circumstances it should be close enough, though.

As an example of an exception, PresentMon can monitor SimStart events when using Intel XeLL (and soon NVIDIA Reflex) and base AnimationTime on that instead. That's valuable because Reflex and XeLL clear the render queue and keep the CPU sitting around waiting for input until the last possible second, so there's a higher potential for differences between CPUStart and the true animation time.

Here we have a PresentMon capture of Cyberpunk 2077. The X-axis shows individual, logged frames, and the Y-axis is the delta between CPUStartTimeInMs and AnimationTime for each frame. Normally, this would result in a perfectly flat line at zero, but since we have XeLL enabled, AnimationTime is based on SimStart instead. With XeLL there's a significant delta between the two values on nearly every frame, which shows that AnimationError would be incorrect if it were based on CPUStartTimeInMs when low-latency modes like XeLL, Reflex, and Anti-Lag 2 are enabled. AMD's Anti-Lag 2 doesn't generate SimStart events that PresentMon can grab, so (for now) we won't be able to accurately score AnimationError with that feature enabled.

MsCPUBusy: This period begins at CPUStartTimeInMS and includes steps that Intel labels as Game and Render. "Game" is the time spent handling game logic and calculations for the frame, and "Render" is the time spent converting the results into API calls (DirectX, Vulkan, etc.).

The end of these CPU-specific tasks is marked by the Present() call, which signals to the GPU that it has everything it needs for rendering. Future versions of PresentMon may break this down further because CPU work is complex.

TimeInMs: This is the timestamp of the Present() call we just mentioned. It's important to remember that this call doesn't mark the beginning of the GPU rendering step, because the GPU can get a head start before the CPU is done generating API calls. 

Usually the end of the Present() call is the CPUStartTimeInMS of the next frame.

MsBetweenPresents: The delta between this frame's Present() call (TimeInMs) and the previous frame's. In the old days, time between Present() calls was used as a (fairly good) approximation for frametimes, but it's technically a different thing. For that reason, MsBetweenPresents is unusable for per-frame calculations like animation error.

MsInPresentAPI: This is the same as MsCPUWait. This is the period between the Present() call and the moment when the CPU begins working on a new frame, meaning that there's nothing blocking further CPU work. 

MsBetweenAppStart: PresentMon's best representation of the literal time taken to create an individual frame start-to-finish (an improvement over MsBetweenPresents). It's the delta between the CPU starting work on one frame and the next, so the difference between CPUStartTimeInMs for the current frame and CPUStartTimeInMs for the next frame (or MsCPUBusy plus MsCPUWait).

MsBetweenSimulationStart: This column would depend on SimStart events from Reflex or XeLL. In the current version of PresentMon, MsBetweenSimulationStart is "disabled until underlying event support is enabled."

PresentMon GPU Metrics: We don't need these numbers in order to calculate AnimationError, but we'll go over them briefly. They include:

MsGPUTime: The total GPU render period, comprising GPUBusy and GPUWait periods. This was formerly called msGPUActive.

MsGPUBusy: The portion of the render period "during which at least one GPU engine is executing work from the target process."

MsGPUWait: The portion of the GPU render period where the GPU was idle, potentially due to some codependency on CPU resources.

PresentMon Display Metrics: 

MsUntilDisplayed: The time between the Present() call for the frame (TimeInMs) and the time at which the frame is displayed. You can calculate the timestamp at which the frame is displayed by adding these numbers, but it isn't logged directly. "Displayed" here means that a flip (pointing to a new frame buffer) is signalled to the operating system. This is different from new pixels literally showing up on the physical monitor, although the timing should be very close.

MsBetweenDisplayChange: How long the previous frame was displayed before the current frame started to be displayed. There's an argument to be made that this reflects the user experience more directly than MsBetweenAppStart, but MsBetweenAppStart is directly tied to performance, so that metric is still better for testing hardware. However, since display happens at the end of the pipeline, MsBetweenDisplayChange is the only way to include post-processing stuff like generated frames and RTX 5000 frame metering in results (if you want that). 

Combined Metrics:

MsGPULatency: The period between the absolute start of work on the frame (CPUStartTimeInMs) and the point at which the GPU started working on it. The start of the GPU render period can be inferred from this.

MsRenderPresentLatency: This is the period from the Present() call at the end of CPU rendering to the end of GPU rendering. This is equal to MsUntilDisplayed unless VSYNC is enabled.

MsAnimationError: Here's how Intel represents the animation error formula for frame N:

(AnimationTime_N – AnimationTime_N-1) – MsBetweenDisplayChange_N

Again, the result of the formula can be positive or negative, but further away from zero is always worse. Adding together all the positive and negative animation errors for a logging period will typically cancel out, so to get a useful total we need to take absolute values.

In the words of Tom Petersen, "The animation step is basically equal to the frametime, mostly. There's some times where it's a little different. But what you need that for is to be correlated with the DisplayedTime step. Because if the DisplayedTime step is different from the animation time step, you'll get a simulation time error, which is measuring stutter directly for the first time."

We've established that AnimationTime is the in-game point in time that a given frame depicts. The delta between animation times for consecutive frames is the amount of in-game time that has passed between them.

We've also established that MsBetweenDisplayChange is the time that a frame is displayed before the next one shows up.

If a long time passes between taking snapshots of the game state, a long time should pass between displaying the snapshots. Even if the AnimationTimes are spiky and uneven, the DisplayedTimes should be matched exactly, or else you get AnimationError.

Conclusion

This doesn’t replace current testing or run instead of it. It’s another tool -- similar to frametime charts -- to help better understand what’s happening in a game. There’s also a lot of theoretical situations here, so it isn’t always practical.

1% and 0.1% lows as bars on a chart took on a life of their own over the last decade. They are still the fastest “glanceability,” and we’re glad we introduced them to our charts now 11 years ago, and we’re going to continue to use them. But it’s time to try and find new metrics, and we hope animation error can supplement the 1% and 0.1% average bar representations of frametime pacing as another means to determine why a game just feels bad sometimes.

But we don't want to oversell what this number actually means. In Tom Petersen’s words: this is a "how jittery am I" metric. Our work here on and off over the past couple years, and more seriously over the past month, has been trying to prove the concept and find a way to put it on a chart that makes sense to anybody. 

We devoted a lot of time to explaining how and why it's different from the numbers that we already measure, but in practice and in most cases, we expect it to complement those numbers, not contradict them. 

That also means we aren't necessarily expecting any huge upsets versus what we've already concluded in existing reviews.

That said, this is a valuable new tool that can do several other things for us: it can show us when we need to make a frametime plot more easily, it can show us when stuttering happens independently from frametime spikes (although that may be unlikely), it can (sort of) normalize for frametimes in a way that makes comparisons between different hardware easier, and it can deal with up-and-down frametime trends across test passes effectively.

Most importantly, animation error forces us to think about why we measure the things we do. We're now closer to discussing why stuttering feels bad, not just the fact that it exists. 

We're still experimenting with ways to make it useful. 

If you want to try it out for yourself, PresentMon is free and open-source, and it now has a GUI version available as well. If you’re a reviewer and you find this useful in developing your own methods, we’d appreciate you pointing back here.

We’ve been using PresentMon for years, and actually, most people who’ve tested game performance have -- they just often don’t know it. 

PresentMon is wrapped by half a dozen other tools that reskin it or use it in some capacity and it’s an open source project with contributions from around the hardware community.

We use the command line version, but there’s also a user interface tool that you can see in our video where we introduced Jay to it previously. They sometimes have different features.

Because of that, a quick security warning first: do not visit PresentMon dot com or download anything from that site. PresentMon is hosted on GitHub and Intel.com and is an open source utility. Usually when someone pretends PresentMon is their own project and reskins it with an interface, they at least come up with a new name. For security purposes, we’d advise only downloading PresentMon itself from GitHub or the Intel site.

Testing animation error like this is exciting because we can finally directly score stuttering instead of simply deducing it. Big picture, this is similar to when PresentMon moved away from MsBetweenPresents: the numbers and conclusions may not change much, but the measurements are closer to what we're really talking about. 

This isn’t the endgame of benchmarking. Hopefully there won’t be one, because that’d be boring. There’s a lot more to learn and this is exploratory and just us putting research out to the internet to experiment with. It’s also up to the vendors to play ball with open source tools like PresentMon. Experiment with the new ideas and point back to us if you find our work helpful as a foundation, and credit to Tom Petersen for opening up the tools to measure these metrics.

The 5500X3D likely takes fallout from the manufacturing process and then re-spins it as a new model, allowing AMD to salvage silicon

The Highlights

• The AMD Ryzen 5 5500X3D CPU is for the Latin America market and builds upon the AM4 X3D CPU lineage and is a 6-core, 12-thread part
• The 5500X3D isn’t a particularly good performer in things like production applications, compression, and decompression
• AMD is still launching AM4 CPUs, which is awesome since the socket is now nearly 10 years old
• Original MSRP: $240-$250 (approximately)
• Release Date: June 2025

Table of Contents

• AutoTOC

Intro

AM4 is the GOAT of motherboard sockets at this point. The socket launched in 2016 and was used for AMD’s first Ryzen CPUs in 2017, and AMD is still launching CPUs for it in 2025. The newest one is the Ryzen 5 5500X3D CPU, a 6-core, 12-thread part that follows other unexpected launches.
AMD launched the R7 5700X3D (read our review) in 2024 and the R5 5600X3D (exclusive to Micro Center) in 2023. The R5 5500X3D has a lower frequency than the 5600X3D and is exclusive to Latin America. Our viewer Leo in Brazil helped us buy one to review, and it’s currently priced at about $204 converted to USD and launched at around $240-$250 USD a couple months ago.

Editor's note: This was originally published on August 29, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Testing

Patrick Lathan

Testing, Video Editing

Mike Gaglione

Camera

Tim Phetdara

Writing, Web Editing

Jimmy Thang

Today, we’re benchmarking the R5 5500X3D. We’re going to keep this set of benchmarks relatively simple and straight-forward: We’ll look primarily at gaming, frequency validation, and we’ll add some production benchmarks. We’re currently revamping and overhauling our efficiency testing as part of our regular bench suite update interval, so we won’t be running those numbers today.

Overview

We’ll start with a quick price comparison.

CPU Market Pricing Update

So again, the 5500X3D was about $240-$250 for our viewer, as seen in the screenshot above from the retailer who sold it. 

About a month or two later, it went down to $204. That’s still pretty expensive by US market standards, but we’re admittedly not very familiar with the Brazilian or South American markets where this is sold. 

Starting with some pricing updates from the market we do know in the US, here’s what it looks like:

Currently, the Intel 265KF without IGP is $283 (apparently marked down from $300), the 9600X is $205, the 14600K (watch our review) is $190, the R7 7700 (watch our review) is $285, and the Ultra 5 225 from Intel is $212 (we haven’t tested this one). The 5800X3D (watch our review) is mostly gone from retailers in any reasonably priced capacity and the 5700X3D is also only available at higher prices and from third-party sellers now. To set the price for the high-end, a 9800X3D (read our review) is about $480.

These are US prices though. Checking the same website our viewer used, we found the 5600X for about the same price as the current 5500X3D price, the Intel 245K for almost exactly twice the current price of the 5500X3D, and the AMD R5 9600X for $270. Given these prices, the 5500X3D at its current $204 is one of the better prices on this particular website. But again, don’t take us as experts for this space. We only learned of this site a month ago. 

Specs & Price

The AMD R5 5500 non-X3D (watch our review) had a major downside from the R5 5600, which was the cache: The 5500 had just 16 MB of L3 Cache, down from 32 MB on the R5 5600. This was a huge change. Despite having the same core and thread count, same 65W TDP, and frequencies which are overall close enough to be comparable, this loss of cache materialized heavily in gaming performance right away in most cases.

The 5500X3D has 96MB of L3 Cache, as we’ve come to expect from its class of CPU. It also has a 105W TDP, which increases its power budget; however, the 5500X3D’s clock speed is significantly lower than that of the 5600 (watch our review) and even 5500, at 3 GHz base and 4.0 GHz boost. This will be its biggest potential downside, but we’ve often seen that cache can make up for lower frequencies in gaming. If the CPU is a downbin or cobbled together from low-performing silicon, then these frequencies make sense as it might be comprised of chips that couldn’t hit higher targets. Likewise, it's possible if it's lower quality silicon that it could require more power to drive the frequencies it is maintaining.

The rest of the specs are familiar: The 5500X3D uses a 7nm FinFET process from TSMC, like the 5500/5600, uses the AM4 socket that’s been GOATed at this point, and is a 6-core, 12-thread part.

Frequency Validation - All-Core

We’ll start with frequency validation in Blender rendering to ensure the CPU is working as advertised.

AMD’s spec sheet defines a 4GHz max boost and 3GHz base clock.

This all-core workload in Blender has the 5500X3D at 3950MHz, falling below the max advertised boost. This is expected for an all-core workload, as long as the CPU can hit the maximum advertised boost in a single-core workload.

The non-X3D R5 5500 CPU ran at 4250MHz, so it has a frequency advantage. The 5600X3D held a frequency of 4350MHz, making it the fastest of these 3 CPUs by frequency. All 3 of these are 6-core, 12-thread CPUs.

Frequency Validation - Single-Core

This next chart shows the maximum single core frequency per interval across a Cinebench 1T benchmark. The 5500X3D had a maximum frequency of 3950MHz, which means it falls short of AMD’s target of 4000 MHz maximum advertised boost. Technically, the spec sheet says “up to,” but that’s bullshit. AMD has done well since the 3000 series to ensure that its CPUs hit this advertised frequency in one of these two workloads for every other CPU we’ve tested for years, making this the first to fail in a long time. 50 MHz short of the target is disappointing. There are a few blips later in the test as tiles change, but the bulk of the test does not meet this target.

The 5500 non-X3D hit 4250 MHz again, with the 5600X3D at 4350 MHz.

5500X3D Gaming Benchmarks

Stellaris Simulation Time Benchmark

Stellaris simulation time is up first. This benchmark is CPU-intensive and also a gaming benchmark, but it’s useful for its real-world representation of something beyond framerate. This lets us look at the actual time required to simulate change in the game, meaning the impacts are felt in real time.

X3D stacks up like this: The 5800X3D is at 50 seconds required, the 5700X3D is at 55 seconds, the 5600X3D required 55.6 seconds, and the 5500X3D required about 61 seconds. The best performer is the 9800X3D at 37.1 seconds, illustrating significant scaling headroom.

Compared to the 5500X3D, the 5800X3D required 17% less time to complete the work. The 5700X3D required about 10% less time to complete the work, with the 5600X3D at about 8% required time reduced.

Intel’s 12600K (watch our review) has about the same performance as the 5500X3D. The 12700KF is a bit better, with the 245K (read our review) improved somewhat notably to 52 seconds, though we still don’t recommend the 200 series of CPUs.

Dragon’s Dogma 2 Benchmarks

Dragon’s Dogma 2 is up next. This is a relatively CPU-intensive benchmark.

The 5500X3D ran at 95 FPS AVG here, with lows well-paced and frametimes in step with the average frametime. This has it around the same level as the 12600K, matching our Stellaris lineup. The 9800X3D shows clear room for scaling at 132 FPS AVG, or a 40% improvement over the 5500X3D, but would also require a new platform with a higher cost. The 5800X3D shows the best gaming capabilities of the AM4 socket with its 108 FPS AVG result, a 14% uplift over the new X3D part. The 5700X3D is closer to the 5500X3D, with the 5600X3D outperforming it. This isn’t abnormal and we’ve explained this over the years: The 5600X3D has a higher 4.4GHz turbo clock, with the 5700X3D at 4.1GHz due to the same 105W power budget being spread across more cores.

The 5500X3D is comparable to the 5700X3D, 245K, and 12600K in terms of performance. The 5700X3D still retains the benefit of more cores in situations where that’s useful.

Baldur’s Gate 3 Benchmarks

Baldur’s Gate 3 is up now. This one is lightweight on GPUs, but can be surprisingly good for showing CPU scaling. The 9950X3D (read our review), 9800X3D, and everything below them prove that. We’re still scaling all the way up to the best two CPUs on the market.

The 5500X3D held a framerate of 102 FPS AVG; however, these are slightly worse than the lows from the neighboring two Intel CPUs. The 265K and 12700KF both are better in frametime consistency, despite the 5500X3D not being bad.

The 5800X3D leads the 5500X3D by 19%. The 5600X3D and 5700X3D are similarly ahead of the 5500X3D, both at about 9% ahead of the new CPU. The 4GHz clock and 6 cores of the 5500X3D are limiting it here, despite overall fine performance.

Final Fantasy XIV: Dawntrail 1080p

Final Fantasy 14: Dawntrail is up next, tested at 1080p first. The 5500X3D ran at 297 FPS AVG, so nothing to be upset about. Frametime pacing is overall good. The 5700X3D is technically better, but not by much; its 302 FPS AVG is an uplift of 1.7%, with the 5600X3D benefitting from the higher frequency. We’ve seen this behavior in Final Fantasy for years now, where the higher frequency helps more than an extra 2 cores.

The 9800X3D helps establish a ceiling around 370 FPS AVG, with the 9950X3D pushing close to 400 FPS. There’s room to scale here.

The 5500X3D manages to outperform the 14900K (read our review) and Intel 285K (read our review). We’ve talked about this before, but Final Fantasy’s chart flipped from an update a couple years ago now: It used to be that Intel held the entire top half of the chart, and now it’s AMD. That remains true with the X3D AM4 parts while the non-X3D AM4 variants fall below some of the Intel CPUs.

FFXIV 1440p

1440p is more or less the same, but we’re including it just to show scaling. Everything is a little bit truncated by the imposition of more GPU load, but particularly the 9800X3D and 9950X3D. These two CPUs are now about tied, with everything down to the 7600 (watch our review) at least occasionally glancing off of the GPU limit, even if rarely.

F1 24 1080p Benchmarks

F1 24 is next. 

In this one, the 5500X3D ran at 329 FPS AVG and slightly outperformed the AMD R5 7600 while roughly tying the Intel Ultra 5 245K. Intel manages better 1% lows than the 5500X3D.

The 9800X3D holds a 500 FPS AVG result, a 53% improvement on the 5500X3D. Clearly there’s room to be better, but the last-gen 5700X3D and 5600X3D would be closer comparisons here. The 5600X3D outperformed the 5700X3D marginally from its frequency advantage, whereas the 5700X3D will be benefitted in more thread-intensive tasks. Both of them outdid the 5500X3D, with the 5600X3D improved by 11%.

Cyberpunk 2077 Phantom Liberty Benchmarks

Cyberpunk 2077: Phantom Liberty is up next.

The 5500X3D ran at 164 FPS AVG, leaving the normal 5500 in the dust at 123 FPS AVG. The 5500X3D’s frametime pacing is also overall consistent and tied with the Intel 245K. The 265K is basically the same performance as the 5500X3D.

AMD’s 5600X3D outperforms the 5500X3D by around 9%, the 5700X3D is almost 10% higher framerate, and the 5800X3D outdoes the 5500X3D by 17% for average framerate. The 9800X3D is 37% ahead, bouncing off of a GPU limit alongside the 9950X3D.

The 5500X3D still outperforms the 14th generation and the non-X3D CPUs of multiple AMD generations, including the 9700X. X3D does well here and holds the entire top quarter of results.

Starfield Benchmarks

The 5500X3D does fine in Starfield as an objective measure, but isn’t competitive. The CPU runs at about 119 FPS AVG with unimpressive lows, although that’s mostly from the game.

The CPU is at least significantly better than the R5 5500’s 88 FPS AVG and the 5600X’s 99 FPS AVG, despite allowing the 5600X3D a 10-11% lead. The 5700X3D pushes past the 5600X3D in this one, illustrating a benefit from the extra 2 cores even with the lower clock speed. The ceiling in this test is around 200 FPS AVG, with the 5800X3D being AM4’s closest CPU to that result at 148 FPS AVG, leading the 5500X3D by 24%.

5500X3D Production Benchmarks

Blender

We’ll look at some production tests now. This won’t be as extensive as our Threadripper review, but will at least give us an idea as to the performance in non-gaming tasks. X3D doesn’t tend to help here, and in the AM4 generation, the configurations are often worse than non-X3D variants due to lower clocks.

In Blender rendering of a 3D GN logo, the 5500X3D required about 30 minutes to complete the render of one frame from our intro animation. That has it slightly behind the 5500 non-X3D, although they’re about the same. The 5600X (watch our review) sees a reduction in time required of 9% thanks to its higher frequency. The 3700X outperforms all of these as a result of the 8-core configuration, which offers more in this workload than just frequency at lower core counts can. Overall, the 5500X3D performs like a low power 6-core CPU, which is what it is when the extra cache can’t be leveraged. The 12600K that it ranked alongside in several gaming tests is significantly and noticeably better here, up at 18 minutes for the same test. That’s a reduction in time required of 39%.

7-Zip Compression

In 7-Zip compression testing, the 5500X3D ran at about the same performance level as the 5600X3D. Results are in millions of instructions per second, with the 5500X3D completing 65K MIPS, the 5600X3D at about 70K MIPS, the regular 5500 at 64K MIPS, and the venerable 5800X3D completing 90K MIPS. The 5800X3D and 5700X3D both benefit from a higher core count, with the 5800X3D in particular at 38% ahead of the 5500X3D CPU. The 12600K is similar to the 5800X3D in this test.

The 5500X3D isn’t impressive here in any capacity. There are better options for this kind of task, but if you had to do stuff like this in addition to budget gaming, it’d be workable.

7-Zip Decompression

Decompression is next. This test has the 5500X3D at 80K MIPS, landing just below the R5 5500, which benefits from the higher frequency that we showed earlier.

The 12600K leads the 5500X3D by 18%, so where they were similar in a few games, the 12600K definitely has an advantage in these more core-intensive tasks.

The 5500X3D is not a good CPU for this kind of work. It can get it done, but it’s not competitive. This is primarily a budget, cut-down gaming CPU.

Chromium

Chromium code compile is next. This test is extremely core-intensive and beats up the 5500X3D. It required 337 minutes to complete the code compile. That’s faster than the 355 minutes of the 5500 non-X3D, but still far down the chart. The 5600X and 5600X3D show similar rankings, with the 5700X3D also benefitted over the 5700X non-3D. There’s at least a clear trend in these AM4 CPUs of the extra cache helping versus their non-X3D counterparts.

Adobe Photoshop

In Adobe Photoshop with the Puget suite, the 5500X3D lands again at the bottom of the chart. It’s ahead of the 5500 non-3D but behind almost everything else, including the gaming neighbor 12600K.

Adobe Premiere

Adobe Premiere video editing and rendering tasks via the Puget suite have the 5500X3D at 6760 points extended, which plants it between the 5500 and 5600X again. The 3700X isn’t far off from the 5500X3D’s performance, mostly thanks to its extra 2 cores.

The 12600K is significantly better than the 5500X3D here, as are basically any options from the AMD 7000 series and beyond. The generational uplift was particularly large in this test.

DaVinci Resolve

In DaVinci Resolve, which is experimental for us right now, the ranking is similar: The Puget suite keeps it down toward the bottom of the chart, just behind the 3700X, 5600X, and ahead of the 5500 non-X3D.

Conclusion

The CPU market is still relatively sane compared to the utter chaos that is the GPU market right now. CPUs are, for the most part, pretty stable—pricing is predictable, availability is decent, and while you might not agree with the price of a specific model, at least you know what you’re getting into. 

One of the most impressive things here is AM4. It’s still kicking, even with AM5 taking over. We’ve talked to motherboard vendors, and they’ve told us that older boards from past generations often get rerouted to markets outside the U.S., like South America and parts of Asia, where there is still demand. This helps keep prices a little lower and ensures that those boards don’t just end up in a landfill. And for folks looking to buy in, it means that entry costs for things like the 5500X3D are more reasonable. 

Speaking of the 5500X3D, it’s a noticeable improvement over the non-X3D 5500. The biggest problem with that old chip was its tiny cache. 

Performance-wise, the 5500X3D is fine overall and didn’t really fail in any of the games we tested. It isn’t a particularly good performer in things like production applications, compression, and decompression. It can do them, but it's not good if you’re doing those tasks heavily. In that case, you’d be better off going for a higher-core-count CPU.

Pricing is key here, and it really depends on where you are. In the U.S., the 5500X3D’s launch price of $240 to $250 felt a little too steep, especially with better alternatives on the market at similar prices. But if you catch it around $200, it’s a much better deal and competes with stuff like the 9600X, so it’s definitely a more appealing option.

What’s really impressive, though, is how AM4 is still relevant and kicking, despite being several years old. This thing has been around for ages, and AMD is still giving it support. AM4’s long life means less waste, fewer upgrades, and a platform that’s not forcing you to buy a whole new setup every couple of years.

We compare the 9980X vs previous Threadripper CPUs (like the 7980X) and against desktop-class CPUs (like the Intel 285K and AMD Ryzen 9950X)

The Highlights

• AMD’s new 9980X Threadripper moves to the Zen5 architecture
• On the gaming side, there are sometimes issues with consistency
• The 9980X is anywhere from 2% to 58% improved upon the 7980X in our benchmarks
• Original MSRP: $5,000
• Release Date: July 31, 2025

Table of Contents

• AutoTOC

Intro

We’re reviewing the $5,000 AMD Threadripper 9980X 64-core CPU and have a ton of new production tests to benchmark it. A lot of this is just an excuse to do some cool new testing. Like with medical simulations where we saw an 18% generational uplift, similar to the 18% we saw in financial options and black-scholes modeling, or the 58% improvement over the 7980X that we saw in convolution benchmarking. In most places, the gain is much smaller, like in compression with a couple percentage points of change. However, from the Zen 5 change to how AVX instructions are handled, it sometimes gains disproportionately. We saw the same with the 9900X vs. 7900X (or X3D variants) when in AVX-heavy scenarios.

Editor's note: This was originally published on July 30, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Testing

Patrick Lathan
Mike Gaglione

Video Editing

Tim Phetdara

Writing, Web Editing

Jimmy Thang

The quick version up front is that the improvement on the 7980X is anywhere from around 2% to that 58% number, but the vast majority of tests are closer to the range of 5% to 18%. It really heavily depends on the workload with these CPUs, particularly AVX occupancy.

These are workstation CPUs intended for research, production work, or generally tasks that either make money or advance science or something similar. We’re still benchmarking gaming, but the focus will be mostly on production workloads today with gaming only there to ensure there are no major broken results.

These CPUs are expensive. That limits the audience. For that reason, we added all the new tests as an opportunity to also re-run everything else, so all of this data is brand new. Even if you’re not in the market for Threadripper, this will have interesting data from more “normal” CPUs out there.

Overview

Here’s the quick recap of the CPU lineup.

AMD is launching two versions of the Threadripper 9000 CPUs. These include the non-Pro and Pro CPUs. The Pro CPUs had an earlier embargo; today, we’re covering the HEDT (or “high-end desktop”) non-Pro Threadripper CPUs.

The 9980X is a 64-core, 128-thread part that boosts up to 5.4 GHz and has 256MB of L3 Cache. The CPU sockets into STR5 platforms and, like the other two modern Threadripper parts launching with it, has a 350W TDP. It’s $5,000 for the 9980X.

The 9970X is a 32-core, 64-thread part. They all share the same boost of 5.4GHz, but the base clock is higher on the lower core-count CPUs as a result of higher power availability per core based on power budget. Cache is down to 128MB L3 on the 9970X and 9960X, the latter of which is a 24-core, 48-thread part. Pricing is $2,500 for the 9970X and $1,500 for the 9960X.

Compared to last time, prices are familiar: The 7980X was $5,000, the 7970X was $2,500, and the 7960X was $1,500. Threadripper 9000 prices are elevated from several generations back to the 3000 series, but the same as the 7000 series.

The architectural improvements are the same as in Zen 5 with the 9000 series launch. The biggest one you’ll see today is from the AVX changes. When we were digging into the largest improvement in our testing, AMD sent this explanation as a refresher on Zen 5:

“At first glance [the test] does appear to benefit from AVX-512 since the code has multiple references to ZMM. The main difference in 7K and 9K is the double vs single pump (256-bit native vs 512 native).”

“High level, it took two cycles to do a 512 bit operation on Zen4, but one cycle on Zen5 because we doubled the FP datapath width, and increased the bandwidth from the L2 to the core to be able to match that speedup. You can't always take advantage of it, but theoretically there is a 2X improvement.”

That “theoretically” is important, because it doesn’t show up in most of our tests; however, in some, there is a very large uplift. This isn’t special to Threadripper and is instead specific to Zen 5 vs. Zen 4. We’ll spend some time on that in our review.

As for the test bench: Our chart subtitles apply to the desktop platforms, but the Threadripper CPUs are tested with different memory and motherboards. It deviates from some of the other benches.

Let’s get into the benchmarks. We’ll start with production testing.

9980X Production Benchmarks

7-Zip Compression

7-Zip compression is up now.

This test is measured in MIPS, or millions of instructions per second. Higher is better throughput. The 9980X is the new chart-topper here, at 520K MIPS versus the 7980X’s 508K MIPS. The improvement is just 2.3% here. This is one of the lower improvements. 

There’s clear benefit to higher core counts in this test. The 7980X over the 7970X previously held a lead of 34%, or 67% over the 7960X.

Against the highest-end desktop part, the 9950X3D, the 9980X sees an improvement of 151%. Notably, extra cache seems to help here: Both the 7950X3D and 9950X3D are benefitted over the 9950X. 

Threadripper is in an entirely different class from desktop components, although the uplift over the last generation’s 7980X is limited and relatively boring here.

7-Zip Decompression

In decompression, the 9980X scaled up to 926K MIPS, gaining 8% on the 7980X’s 857K MIPS. This is a better showing than what we saw in compression and posts better scaling. The rest of the lineup is familiar to the prior examples. Extra cache doesn’t help as much in this test as compared to the compression test, as the 7950X3D is now below the 9950X. This would align with the speed benefit providing more of an uplift on Threadripper as well.

SpecWS: OptionsPricing

SpecWorkstation 4.0 is next. This runs a number of simulations and mathematical models that we aren’t experts in, but we can at least run the benchmarks. We’ll rely on the Spec website to explain what the tests are.

The first is Options Pricing. The website says that this runs Monte Carlo probabilistic simulations for financial uncertainty, Black-Scholes pricing models for theoretical value, and binomial options pricing. We are not experts in how these are used, but those of you in our audience who are experts have repeatedly expressed an appreciation for this test.

The results have the 9980X at the top, with a 7.8 score. That has it improved on the 7980X by an impressive 18%, aligning with the findings of the 9000 series desktop parts against the 7000 series in this same test. You can see that in the 9800X3D against the 7800X3D or the 9900X3D vs. 7900X3D. This is an architectural benefit. It’s one of the rare break-outs for Zen 5 that we talked about after the initial round of reviews when we had validated it as a legitimate deviation.

The 9980X improves on the highest-end desktop 9950X3D by 200%, basically being the difference between being runnable and not. Threadripper really makes an impact here, and the generational gain is real but rare in this one test.

SpecWS: OpenFOAM

OpenFOAM is next. Per the Spec website, OpenFOAM is a CFD test that “performs 2D Reynolds averaged simulation for fluid dynamics analysis.” It also runs a solver test.

The 9980X scores 23.3 here, leading the 7980X prior generation by about 9%. Not as impressive as Options Pricing, but better than some other tests we have today.

The lead over desktop parts like the 9950X and X3D is enough that it’s really not in the same class, with multiples of uplift.

SpecWS: Convolution

Convolution testing is next. Spec says that this test applies “a convolution filter to an image, a critical operation in signal processing and image analysis” for edge detection and feature extraction. This is heavily multi-threaded.

In this test, the 9980X scored 9.3 to the 7980X’s 5.9, a huge uplift of 58%. This is completely out of alignment with any other tests. We contacted Wendell of Level1 Techs and AMD’s engineers to get both a first-party and a neutral third-party check of these numbers. Wendell noted that this is expected behavior and had seen similar results in other tests, believing it to be related to AVX improvements in addition to being a test that runs long enough to benefit from them. AMD noted that it has also seen results around 60% for certain similar tests.

Although we have our 9970X review coming up separately, we’ll note that it also saw a 56% improvement here over the 7970X predecessor. The results align. Looking at last gen, the 9950X improved on the 7950X by 50%, which is consistent generationally. The results appear to be consistent and are present across numerous CPUs cross-generation, which means the only thing left to consider is whether this benchmark represents real-world scenarios. We’re not sure: This particular test exits our expertise, as we don’t do signal processing or image analysis work. We’d love to hear from those in our audience as to whether the Spec Convolution test aligns with real-world applications that you use in your work life.

Regardless, the result is repeatable -- it’s only a question of whether it’s effectively a microbenchmark or is something that scales to real-world use.

SpecWS: LAMMPS

LAMMPS testing is next. According to Spec, this test is for large-scale atomic and molecular massively parallel simulation, which Spec says “utilizes MPI to scale to multiple cores to perform complex simulations.” This includes life science subtests, such as for polymer chain calculations and protein calculations for, what we assume are, medical uses.

LAMMPS has the 9980X at a 5.5 score in Spec, leading the 7980X by 17%. This is close to the Options Pricing results. Although Spec has several tests where there’s no real impact, like Handbrake, it also has a higher saturation of tests with larger generational improvements.

SpecWS: Data Science

The Spec Data Science test is next. Spec says that this test “involves running a series of synthetic benchmarks that simulate real-world AI and ML workflows using the Python-based data science libraries Pandas, Scikit-learn, and XGBoost.”

Generationally, the 9980X improves on the 7980X by 10%, going from 2.0 to 2.2 in the scoring. For reference, the 9950X improved on the 7950X by 13% at 1.7 from 1.5.

SpecWS: NAMD

NAMD is next, another test our audience liked before. This is a molecular dynamics simulator for modeling “behavior of biomolecular systems,” with Spec saying that it is “used for research in biochemistry, pharmacology, and molecular biology.”

The 9980X scored 6.0, with the 7980X at 5.1. This is an improvement of almost 18%, which aligns again with LAMMPS and options pricing benchmarks.

SpecWS: RodiniaCFD

We have a lot more Spec results, but we’ll close on one that’s less interesting to bring it back down to earth and balance the higher results. This is for RodiniaCFD, which the site explains has a pre-euler subtest that “executes an unstructured grid finite volume CFD solver for 3D euler equations for compressible flow.”

The 9980X scored 3.7 here, with the 7980X at 3.5. This is one where the improvement is less exciting, back down to about a 5-6% improvement generationally.

Chromium

Up next is Chromium code compile. There are a lot of types of code compile, just like there are a lot of types of video encoding or photo editing or 3D rendering workloads, so we’re just representing one here as we do with any other production test.

The 9980X completes the compile the fastest, at 48 minutes total. The compile time is 7.5% reduced from the 7980X. Elsewhere, with the newer version of this test, we’re seeing reduced impact compared to prior test iterations. The 7980X and 7970X are relatively close to each other, with the 9950X3D and 9950X also near each other. Some of these CPUs are running with reduced memory speed as they required higher memory capacity and had more trouble holding our usual settings, so those are noted where true.

The 14900K is Intel’s best performer, requiring 100 minutes to complete the compile. The 9950X outperforms this.

Blender

Blender tile-based rendering is up next.

For this process, the 9980X is the new chart-topper at 2.1 minutes to complete a render of a single frame from the GN intro animation logo. The next fastest is the 7980X at 2.5 minutes, which makes sense: This test is heavily thread-dependent, so threads will outrank frequency where large differences emerge.

Intel’s newer generation does OK in this test, with the 285K between the 9950X and 7950X. It’s also one of the tests where Intel doesn’t see regressive performance, though we still wouldn’t recommend the 285K. That entire platform is dead, anyway.

Photoshop

Adobe Photoshop is next, tested with the Puget Suite. This uses an aggregate score of filters, resizes, and other functions within Photoshop.

The best performer here is the 9950X, followed by other desktop CPUs. The Threadripper parts fall further down the chart, with the 9980X in particular underperforming. We’ve seen this in the past, such as with the 7980X: They just have too many threads for their own good and Photoshop isn’t able to utilize them. The 7980X is outperformed by the 7970X and 7960X, so the 9980X landing in the middle isn’t a surprise. Its main improvement comes from the frequency.

It does OK here if this is just one of many applications you use, but if Photoshop is the only thing you do, there are better and cheaper CPUs for the job.

Premiere

Adobe Premiere is next, our best frenemy that we see every day.

In this one, the 9980X improves upon the performance from the 7980X and 7970X, but only barely. It’s definitely not worth a single generational upgrade, though we generally don’t recommend that anyway.

The improvement is almost 5% from the 7980X to the 9980X in the extended score for Premiere. Intel’s 285K trails most Threadripper CPUs in the chart and roughly ties the 7960X. It also technically outperforms the 9950X. Intel’s biggest advantage remains in its QuickSync solution with the IGP, which would show up disproportionately in more targeted tests rather than the full sweep done here.

Threadripper does well overall here and is at least better than its Photoshop showing, but without other applications leaning on threads, a desktop CPU would get most of the same performance. The best use for Threadripper here would be assigning its excess threads to other tasks, like separate audio compositing, while running Premiere tasks.

DaVinci Resolve

DaVinci Resolve is next. We haven’t tested this in years, so this is an experimental chart.

In this test, the 9980X’s frequency boost allows it to gain on prior Threadripper CPUs. The previous lineup had the 7960X and 7980X tied, with the 7970X marginally ahead. We saw this with the 7000-series Threadripper reviews where 64-core parts sometimes caused slight losses compared to 32-core counterparts.

The 285K falls behind the 9950X in this one, though not by a lot, with the 14900K roughly within re-run distance of the 285K.

Threadripper is at least the best performer here as well, despite not providing clear value over desktop parts. It’s just not built for these kinds of workloads, but still being the best is important.

Gaming Benchmarks

We’ll keep gaming short. The only purpose of gaming tests on Threadripper, generally, is to make sure there isn’t some major problem, but cheaper desktop parts are going to be better for pure gaming builds. Threadripper is actually detrimental if all you do is gaming.

You're going to notice that the Threadripper chips don't always follow a strictly logical order, especially when they're within a few frames per second of each other. That's because of the increased run-to-run variance causing less meaningful averaged results.

Stellaris Simulation Time

Stellaris simulation time is first. The 9800X3D is the current leader at 37.1 seconds on average for simulation time. The 9700X follows this at 43.2 seconds, benefitting from Zen 5 architectural improvements over the prior generation. The 285K isn’t what we’d call “good” here, but at least matches its predecessor.

Threadripper is way at the bottom, with the 9980X at least improving on the 7980X notably, but it’s still far worse than any other modern gaming CPU. The 5700X is nearly at the level of the 9980X. It’s just detrimental to have this CPU configuration for this game, which isn’t really news to anyone. It can at least play games, but the difference in simulation time between the 9800X3D and the 9980X would be noticeable in real game play.

FFXIV: Dawntrail - 1080p

Final Fantasy 14: Dawntrail is next. The 9980X and 7980X high core-count CPUs had some major inconsistency issues in this game, so there’s an asterisk next to their entries.

We’re still showing the averages of 4 runs, it’s just that the runs are more variable than typically. The 9980X, for instance, had a range from 274 to 248 FPS AVG, which is a huge swing. Our typical standard deviation in this game is a couple frames per second for the average. The game was playable, but all over the place for the average framerate. Lows were worse overall as well, but again, technically playable.

This is why we still test games with Threadripper, though.

Dragon’s Dogma 2 - 1080p

In Dragon’s Dogma 2 at 1080p, the Threadripper CPUs end up in the lower half of the chart. The 9980X is worse than the 7950X here and about the same as the 7970X. The 7980X was below the 7960X and 7970X, indicating that these extremely high core counts are detrimental to gaming performance. The higher frequency matters more than the extra cores, so the trade-offs are harmful to gaming performance here. This has been true forever with Threadripper, so none of this is news.

What matters more is that they’re still playable. Threadripper does suffer from worse lows, particularly 0.1%, but not so bad that they render the game stuttery. You could still play games on a Threadripper system, but again, gaming-only users should buy something else.

Cyberpunk 2077: Phantom Liberty - 1080p

Cyberpunk is next. In this one, the 9980X outperforms the 7980X on a technicality, but both are closer to the R7 2700 than they are to the 9800X3D. The run-to-run consistency was fine, with the 9980X only exhibiting a 1.9 AVG FPS standard deviation, so it’s not like what we saw in Final Fantasy -- it’s just not particularly good. This is still a passable framerate, so in the context of a computer built for specific work tasks that can still play games when needed, it passes that need.

Baldur’s Gate 3 - 1080p

In Baldur’s Gate 3, the 9980X ends up around the level of the 265K -- which is really just more embarrassing for Intel than anything else. We already know Threadripper isn’t particularly good at gaming, despite being OK at it, but the 265K should be doing better here. This is also a game where the 285K was hugely regressive, though, at 109 FPS AVG against the 14700K’s 117 FPS AVG and 14900K’s 123 FPS AVG.

We did test other games, but they’re just not relevant beyond proving the point we already have: Threadripper is passable if gaming is not your primary need. It’s just not the best choice for it.

Power Consumption

9980X Power Consumption - Blender

This next chart shows the power consumption as measured at the EPS12V cables with a power interposer between the motherboard and power supply. Tested with an all-core workload in Blender, we observed stable and consistent power draw across both the 7980X and 9980X CPUs, with the 9980X measuring at 371W from 354W on the last-gen Threadripper flagship. That’s a lot of power to cool.

This does not show transients.

9980X Thermals

Thermals - Blender

This chart shows the thermal behavior of the 9980X. We’re using a SilverStone 360mm liquid cooler with a Threadripper-sized coldplate for this, so the results are not comparable to our 7980X review thermal results from its launch. Also, as usual, thermal testing would be best done with a lot of coolers compared and noise-normalized, but this is kept simple for the review and to help get an idea (as that’d be a cooler review).

The 9980X under an all-core workload ran at around 58 degrees Celsius when running the relatively loud 100% fan speeds on the 360mm liquid cooler. 

Thermals - Equilibrium

This chart shows thermals at steady state across the various CCDs. The CCD-to-CCD delta here is 6.7 degrees Celsius, at 49.7 to 56.1 degrees in an ambient of 21 degrees Celsius, +/- 1C. Generally speaking, this can be cooled at lower noise levels with 360mm coolers without major issues if assuming a well-ventilated case. The surface area is so huge on this CPU that the power is distributed across a large area, making it easier to cool than a 200W heat load might be on a normal desktop-sized Ryzen CPU with 2 CCDs.

9980X Frequency

Frequency - Blender All-Core

With all cores working, the CPU typically ran at around 3950 MHz, with occasional spikes to 4200 MHz while some threads were bringing in data for new tiles to render. The base clock is 3.2 GHz, so it’s not dropping that low during this particular workload, but it’s also far away from 5.4 GHz. This is typical behavior for all-core workloads.

Frequency - Blender vs 7980X

This chart shows the 7980X for the same test. The frequency bottoms-out at around 3.7 GHz, but is all over the place during this workload. The 9980X has improved upon the frequency in all-core scenarios overall.

Frequency - CB Single-Thread

In a single-threaded test with Cinebench, the 9980X ran at 5425 MHz, exceeding the spec listing of 5.4 GHz for boost. This is also expected behavior, with the more limited load boosting higher. The 7980X in the same test ran at about 5340 MHz, so the single-thread frequency has improved generationally -- but not much, and that’s why some benchmarks only show a couple percentage points of change.

9980X Conclusion

On the gaming side, there are sometimes issues with consistency. This means, run-to-run, you don’t get the same experience. There’s far more deviation here in average frame rate and the frametime consistency is worse than traditional desktop parts. This is especially true with 64-core Threadripper CPUs. This is not really unexpected. These high core count CPUs sometimes just have so many cores that it starts causing scheduling problems. Sometimes you’ll also end up in situations where, because the clocks aren’t boosting as high (because of the higher core count), you’re losing that frequency advantage. Again, this is not unexpected. The good news is that the games we tested on the 9980X weren’t broken. They were able to run and weren’t awful experiences, which wasn’t the case with the earliest Threadripper CPUs.  

Compared to the 32-core Threadripper, the 64-core part technically runs cooler. That’s because you’re taking the same power and distributing it across more silicon. This means you’re going to get lower temperatures per die per hot spot. That remains true here where the 64-core CPU can be cooler than the 32-core processor. 

With its prices, these Threadripper CPUs aren’t something you’re buying for “value.” The target demographic for these processors is probably making money with their computers. 

Threadripper also has the benefit of PCIe lane availability for machines with multiple accelerators or a lot of I/O, which are more limited with traditional desktop CPUs. 

64 cores don’t always scale well. Sometimes a 32-core CPU can be a better fit. Make sure to do research online for your needs. For example, we found out that a 32-core CPU would work better for us while using Adobe Premiere for video production. So it’s best to research these CPUs with your needs.

We go over AMD’s Computex 2025 announcements which include the company’s new RX 9060 XT GPUs, Threadripper CPUs, AI Pro workstation GPU, and more

The Highlights

• AMD’s RX 9060 XT will have 8 and 16GB models
• AMD announced new Threadripper CPUs that include the 9980X, 9970X, 9960X along with PRO 9000 WX-series CPUs
• AMD also revealed the 9995WX, its new AI Pro workstation GPU, which will come with 128 AI accelerators, 32GB of GDDR6 memory, up to 1531 TOPS, and a 300W TDP

Table of Contents

• AutoTOC

Intro

AMD just announced its RX 9060 XT GPUs (coming in two memory configurations). We already knew about these but the company just formally announced them. AMD also revealed its “Radeon AI Pro R9700” workstation GPU, and the company’s latest Threadripper 9000 series and Threadripper PRO 9000 WX-series of CPUs. Unlike NVIDIA, AMD actually wants people to know about its products rather than about anti-consumer, anti-free-press actions, so AMD not only announced the products and gave information on them, but will also be sending out review samples well in advance and without conditions - which normally isn’t worth mentioning, but is worth pointing out because of the recent NVIDIA issues.

Editor's note: This was originally published on May 20, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Host

Steve Burke

Camera, Video Editing

Mike Gaglione
Vitalii Makhnovets

Writing

Tannen Williams

Web Editing

Jimmy Thang

The 9060 XT 16GB will be $350 with the 8GB model at $300. They will release on June 5th. The GPU die is the same for both models, but new from the 9070 (read our review) and 9070 XT (read our review) (which also shared a GPU die). The new die is Navi 44 for the 9060 XTs and sized at 199mm^2, down from 357mm^2 on the 9070-class cards.

The company didn’t provide as many first-party testing results as they typically have in the past. That’s not necessarily a bad thing, because all of those results have to be taken with a grain of salt anyway, but we’ll mainly just be sticking to the specs today. We plan to review these cards once they launch. Our understanding is that, unlike the 5060, AMD plans to continue sampling GPUs as usual.

Just a heads-up: The information in this article is from a pre-briefing, so this is based on conversations with AMD and not the live presentation itself.

AMD Radeon RX 9060 XT

The 9060 XT will come in 16GB and 8GB versions. 

As for the features that will be shared between the two: Each will have 32 compute units, 32 hardware RT accelerators, 64 of what AMD calls its AI accelerators, and a 3.13 GHz boost clock. Both models will run PCIe gen 5.0 x16 slots, DisplayPort 2.1a, and HDMI 2.1b. AMD also lists a range of 150W-182W for board power, which explains the single PCIe 8-pin connector pictured in the rendering of the GPU. In speaking with AMD, the lower end of the range is for 8GB models.

For reference, AMD’s 9070 XT has 64 compute units, 64 RT accelerators, and 128 AI accelerators, or double the amount of the 9060 XT’s CUs and accelerators. The 16GB 9060 XT matches the memory capacity of both the 9070 and 9070 XT, but with a weaker core. 

These 9060 XTs will be direct competitors to NVIDIA’s 5060 Ti cards, even mirroring the same VRAM configurations. Despite identical memory sizes, NVIDIA’s 50 series cards utilize a newer GDDR7 memory compared to AMD’s GDDR6. As for how much that matters, that depends on the architecture and how much it’s going to rely on the memory bandwidth and that extra speed. We’ll look at it in testing and see how it performs in the real world. 

Additional differences include the 9060 XT’s use of PCIe 5.0 x16 as opposed to the 5060 Ti’s (read our review) PCIe 5.0 x8 interface. In benchmarking at x8 vs x16 on gen 5, it’s not going to matter. The place where it might matter is socketing it into an older board where cutting the lane count in half is going to become a restriction in some configurations.

AMD’s first-party benchmarks compared it against the 8GB RTX 5060 Ti, which we think is fair since it’s a price-parity comparison. We’ll do our own benchmarking pretty soon in our review. 

AMD Ryzen Threadripper 9000 and PRO 9000 WX-Series CPUs

AMD also announced its newest Threadripper 9000 Zen 5 CPUs, including the 9980X, 9970X, and 9960X, codenamed “Shimada Peak.” These have been upgraded with increased memory support and enhanced AVX-512 for more demanding tasks.

We’ll start with the standard AMD Ryzen Threadripper 9000 CPUs. This series includes the 9980X, 9970X, and 9960X.

The 9980X is a 64C/128T CPU at 3.2 GHz base clock and with 256 MB of L3 cache. The 9970X has 32 cores, 64 threads, a 4.0 GHz base clock, and 128 MB of L3 cache. And finally, the 9960X will come with 24 cores, 48 threads, a 4.2 GHz base clock, and also 128 MB of L3 cache. All of these CPUs will also feature an up to 5.4 GHz max boost clock, PCIe 5.0, the same sTR5 socket, and a 350W TDP.

For AMD’s Ryzen Threadripper PRO 9000 WX-Series: The company announced six new CPUs, which include the 9945WX, 9955WX, 9965WX, 9975WX, 9985WX, and the flagship 9995WX. Starting with the 9945WX and working our way up, these chips will come with core counts of 12, 16, 24, 32, 64, and finally 96 cores for the 9995WX. This mirrors the existing and prior 7000 series CPU configurations just now on Zen 5. 

Both the PRO and non-PRO Threadripper CPUs seem to resemble the same basic specs as the 7000 series of Threadripper processors. In these spec sheets, with a higher max boost frequency for the 9000 series CPUs, but a lot of the rest is familiar. 

One notable difference between the PRO WX and the non-PRO series of Threadrippers is that the workstation series offers “AMD PRO technologies,” which AMD describes as, “a robust suite of enterprise-grade features including multilayered security, advanced remote manageability, and long-term platform stability.” Additionally, at least in the past, the PRO WX-series cards supported the WRX90 chipset in addition to the TRX50 chipset.

AMD hasn’t announced any prices at this time, but the press-brief lists availability for July 2025, so we should be expecting to see these soon.

AMD Radeon AI Pro R9700

Finally, AMD introduced its latest AI Pro workstation GPU. Intel also just announced its new Pro GPUs this past week and we already have a tear-down up of the B60.

For specs, this RDNA 4 card will come with 128 AI accelerators, 32GB of GDDR6 memory, up to 1531 TOPS claimed, and a 300W TDP.

Compared to one of its predecessor, the Radeon Pro W7700, the new R9700 increases TFLOPS (FP16) from 56.54 to 96, increases AI accelerators from 96 to 128, upgrades to PCIe Gen 5 from Gen 4, and doubles the memory size from 16 to 32GB. Unfortunately, AMD’s press-brief didn’t include any CU, stream processors, or memory bandwidth info for the R9700, so we’ll have to wait to see those exact specs.

Due to the R9700’s noticeable configuration improvements over its predecessor, the new GPU ends up being slightly more comparable to the Radeon Pro W7800 which has 140 AI accelerators, 32GB of GDDR6 memory, and 90.5 (FP16) TFLOPS. 

In its press-brief, AMD included a slide to illustrate how 32GB of VRAM gives users more options in their ability to load larger AI models by highlighting four models that would exceed 16GB of VRAM, but can be used with 32GB of VRAM instead. Additionally, due to the GPU’s ability to load models with larger parameters or that are less quantized, the GPU may also see an uplift in the accuracy of the model’s responses.

To expand upon that point, AMD includes another chart labeled “Large AI Models Performance” where it compares an RTX 5080 (read our review) to its AI Pro R9700. Once again, this chart demonstrates how 32GB offers access to run larger models that 16GB just can’t handle. These results are expected. We think a more meaningful comparison might’ve been using the RTX 5090 that also has 32GB of VRAM. This would represent a more like-for-like scenario but we don’t do a lot of ML testing so we’ll leave that for someone else. 

AMD also shows off the card’s “Multi-GPU PCIe 5 platform” that allows users to connect 4 AI PRO R9700s for some extremely demanding models that need up to 128GB of combined VRAM and theoretically 4x the computing power.

We didn’t receive a price for this card, but AMD lists an availability of July 2025. 

Conclusion

That’ll wrap it up for AMD’s announcements.

Unfortunately, it’s a bit difficult to get an idea for performance based on the specs alone, and even harder to get an idea for the value for something without a price.

Ideally, we’d be able to get our hands on some of these once they’re publicly available, which should be soon according to AMD’s press-brief.

We take a look at a number of user reports about ASRock motherboard and 9800X3D CPU instability or failures

The Highlights

• Our report here monitors the issues surrounding 9800X3D CPUs and ASRock motherboards and allows us to see if anything larger may come from the situation
• Thus far, it seems like it possibly boils down to two primary issues: ASRock BIOS stability and possibly a CPU batch issue
• We don't think the CPU batch issue is likely

Table of Contents

• AutoTOC

Intro

ASRock motherboards seem to be experiencing 9800X3D (read our review) failures at a higher rate than other motherboards.

A Reddit user reports his CPU dying after two months. Another user experienced failure after two days. And another user reported a dead 9800X3D after a week, and then claims his replacement 9800X3D also died after a week.
This sample of 42 reported 9800X3D failures, compiled by Reddit user u/natty_overlord, consists of over 80% observed on ASRock motherboards.

Editor's note: This was originally published on March 3, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Host, Writing

Steve Burke

Video Editing

Vitalii Makhnovets

Research, Writing

Tannen Williams

Writing, Web Editing

Jimmy Thang

Google Form results, collected by u/ofesad, who granted us permission to share his results, show numerous failures sharing the same CPU batch/lot number. This highlights possibly bad batches from AMD, but we think it’s more likely a BIOS issue.

Other users claim they “revived” their seemingly dead CPU by downgrading to a previous BIOS, and ASRock sent two users a then-unreleased BIOS that resolved their issues, but asked them not to share it.

If these issues keep happening and AMD and ASRock can’t get to the bottom of it, we’ll do first-party, hands-on testing with some of the boards and CPUs that might be affected. But we think it looks like they’re getting to an answer so we’re going to monitor the situation because it looks pretty close to a resolution. This appears to be a couple possible issues. BIOS is definitely one of them. We’ll also talk about the batch thing, which seems a little shaky. 

We’ll be able to use this piece later if ASRock and AMD can’t resolve the situation. This story offers a quick recap. We’ve compiled all the information we could find out there so far on the specific issues and failures so that you’ll have all of the evidence. If this helps you research any issues that you’re running into then we’ll also present a couple of solutions we found or we’ve thought up. 

We’re making this because we compiled all of the research for it but we haven’t done a first-hand testing deep dive on it yet because we’re basically at a stage where we’re trying to figure out if that’s necessary. This is a new approach for us, where we’re compiling all of our research and we’re just going to put it out there and hopefully it helps someone. Likewise, hopefully some of the people who are running into problems with this issue might contact us with potential leads on where to go next.

This is also Tannen’s first research piece and he’s done a great job compiling everything, digging through the forums, and putting together this report to share with you all and to hopefully help some people who are running into this. We plan on following up on this as we learn more. It may be contained to just hardware news, but if a lot of people inform us of potential leads then it may be possible that we revisit this with hands-on testing.

Defining the issues

Failures in any CPU line happen, but Intel’s recent issues were uniquely bad. We don’t see that too often. 

The 9800X3D that famously exploded on Reddit a few months ago is also in recent memory, but after doing some forensics on that one, all evidence pointed toward crushing the socket at an angle and not being correctly oriented when the clamp was closed. That CPU also died immediately and before the user was ever able to boot, further reinforcing that 12V shorted to ground because it just died on boot.

These ASRock and 9800X3D failures are different: They’re happening sometimes months into use, meaning that the systems did work, but stopped spontaneously.

Generally, CPUs are among the most stable components, and so it’s easy for the story to run away with the social media cycle -- but dozens of failures on one platform in a relatively short time span does cause questions.

For perspective, though: Retailer Mindfactory alone has sold over 20,000 9800X3Ds, leading us to estimate the worldwide units sold are in the hundreds of thousands. 

There’s a very small chance of experiencing these issues yourself, even if you’re using a 9800X3D and ASRock motherboard. Both the number of reported failures and ASRock’s seemingly higher incident rate both stood out to us.

The Problem

Here’s what’s going on: Some user systems with a 9800X3D are able to POST, or power-on self-test, and run as expected. The time until failure ranges from under an hour to 3 months. Those with debug displays encounter a “00” error code, which commonly indicates a CPU problem. 

There seems to be two root causes: First is a possible bad batch of CPUs from AMD; second appears to be ASRock BIOSes causing problems with system boots as well as motherboard settings possibly leading to potentially unstable CPUs.

One of the things we came across here was a potential for voltage that was too low, which shouldn’t hurt anything. It just wouldn’t be able to boot. So that’s actually good news because that means you don’t have to, hopefully, worry about the CPU exploding. That has happened in the past.    

One challenge is that there are some dead CPUs out there with burn marks. Currently, the research we’ve been able to do makes it unclear how connected these issues are. We just want to be very transparent about that. Right now, it is impossible to differentiate with our current research between those possible failures without some more hands-on testing. We’ll keep monitoring to see if we need to more aggressively bring in components for testing, but with the pace ASRock has been working on this, we suspect they’ll hopefully have a fix before we could root-cause it since the lab team is bogged-down with other failure analysis right now.

Strangely, we also noticed that many users note their boards work fine with other processors either prior to or after their reported 9800X3D failures. 

Findings Between All Reports (Cause Unclear)

Let’s get into the causes of failure we found across the posts.

All reported failures produce the same initial symptoms of failure, making it challenging to establish the source. Adding to the complexity, not everyone using a 9800X3D and ASRock motherboard experiences failures. We’ll start with findings from all failure types before covering specific cases where the origin is more easily identifiable.

In the sample report of 42 9800X3D failures at the time of writing, the boards affected include: 34 ASRock, six ASUS, one Gigabyte, and one MSI. Chipsets include: 30 X870s, six B850s, four B650s, and two X670s. It appears to be distributed across multiple chipsets and multiple motherboards but the distribution seems to match what people tend to buy right now. Failures occurred on BIOS versions: 3.11, 3.15, 3.16 , 3.17 (beta), and 3.18 (beta), though it’s unclear if failures were necessarily caused by those BIOSes. For the time before failures: six weren’t specified, 15 occurred in a week or less with four of those happening in less than a day, 14 took place in the range of one week to one month, and seven took over a month before failing. 

Also, four listings report the CPU showing burns or markings, which is what caught our attention.

Issue 1 (BIOS Boot issues)

It’s hard to parse what might be causing those specific burns versus everything else so we’ll start with BIOS issues.

At least four users fixed their presumably dead 9800X3Ds by flashing back BIOS to a previous version, which means the CPUs weren’t dead, and two remedied their issues by updating to a “special” BIOS sent to them by ASRock.

u/Flaringup noticed failure after updating to BIOS 3.16. u/Eldaroth experienced the issue after updating to BIOS 3.18. u/Fancy_Potato1476’s system malfunctioned shortly after installing Windows with the motherboard running 3.15 out of the box – turning the computer into a truly fancy potato. This was also the same BIOS u/Kojac4323 was using when he encountered failure.

These user reports indicate failures typically happen after a BIOS update and suggest versions 3.15, 3.16, and 3.18 may cause boot issues.

Three of those users claimed a BIOS flashback to an older 3.10, 3.11, or other old versions resolved their issue.

User u/Eldaroth explained that a 3.10 flashback didn’t immediately solve the problem, but after a second attempt at a 3.05 flashback, Eldaroth was able to “revive” the system. From there, the user flashed back to newer BIOSes and found 3.10 was the latest option working for the build.

This suggests that the issues may not be killing the CPUs (except for the ones with the scorched marks, but that’s a different story), but that it may be a boot issue. The hope would be that a botched BIOS is just causing issues booting and not causing any damage to the CPU itself. It’s rare for a BIOS to damage a CPU, but it can happen. We saw that with ASUS previously on the 7800X3D, which is why everyone is so sensitive to this issue.

At the time of writing this, we haven’t spotted any 9800X3D boot issues occurring on BIOS 3.10, possibly establishing it as the most stable option currently. Users who reverted to 3.10 reported their systems being fixed.

As for the users who received a BIOS from ASRock: According to one, ASRock stated, “Attached is the new BIOS. Please do not spread this yet. It will probably be released soon. This BIOS is not related to the dying CPUs. But it can help with some other boot issue. If you can try it that would be great. After the update, please remember to give the system a few minutes to see if it boots.” 

That’s likely a reminder that memory training can also look like a boot failure. Especially in some configurations, memory training can take 5-10 minutes in some situations.

The other user with the new BIOS claimed: “ASRock confirmed to me that 3.18.MEM03 that they provided to me increases the voltage to 1.2V for the 9800X3D and that allows it to boot and fix the 00 debug code. The issue is that not enough voltage was applied for some 9800X3D units and it was not stable.” Both users reported this BIOS resolved their situation.

This would be better than the possibility that it was overvolting the CPUs, which would be the only likely way the BIOS would actually inflict damage to the CPU. Too little voltage likely won’t hurt, but it’d also be unstable. If this is the case, then this would be one of the better failures to have.

On February 24th, ASRock released a beta BIOS 3.20 with the description stating, “Improve minority proportion of AMD 9000 series CPU boot issue.” We assume this was the same BIOS previously sent out to those select users. 

To be clear, BIOS updates won’t “revive” a literally dead CPU, but they can potentially solve boot issues causing your CPU to appear as dead. We think some users experiencing boot issues and concluding it’s a dead CPU might’ve partially contributed to ASRock’s disproportionate CPU failures, and actually what they might have been seeing instead was just that it wasn’t booting without the CPU being dead, though we can’t fault the users for believing that.

Issue 2 (CPU Batch Failures):

Moving on to the failures possibly caused by a bad CPU batch.

As seen in the “9800X3D fails” Google Form results, out of the nine users who included their CPU’s batch/lot number in their response, seven are from batches CF 2443PGY or CF 2442PGY. 

But remember that this could be completely coincidental and doesn’t necessarily guarantee bad batches. We at GN have CPUs from both of these batches and they’re fine. There is a lot of coincidence here: AMD’s 9800X3Ds have been in high demand and they haven’t been out too long yet. We don’t know how many batches there are, but we wouldn’t think it’s a crazy amount. Likewise, people experiencing any kind of failure, whether that’s caused by the board or the CPU, would be likely on a similar batch if they’re all building and buying around the same time. 

We wouldn’t definitively state that there is a bad batch, but it’s still worth exploring and considering in case this develops and more people report failures from these batches. CF 2443PGY and CF 2442PGY would be the 2 codes to pay attention to.

In those seven responses of the exploded CPUs, the motherboards include: three ASUS, two ASRock, 1 Gigabyte, and 1 MSI, illustrating an expected distribution of failures. ASUS is the largest vendor by market share.

Issue 2 - How to identify the batch number / do some basic checking

If you have a definitely dead CPU and you want to check the batch number, here’s how to identify it. This is also useful for warranty claims. 

The CPU batch number can be found in the image above, outlined in red. The batch number begins with two letters, which we believe to indicate CPU stepping. 

As explained by u/rigred on Reddit, the letters are followed by four digits specifying the year and week the CPU was manufactured, and ends with three letters specifying ATMP and wafer production location.

In the case of the “CF 2443PGY” batch, these were produced towards the end of October 2024 and assembled in Penang, Malaysia.

ASRock Response

There’s been something of an ASRock response, though as of writing this, they’re still investigating.

Current boot issues are addressed by the company’s most recent 3.20 beta BIOS, though its efficacy has yet to be determined on a large scale.

ASRock Japan’s post on twitter, which has been machine translated, states issues occur after updating BIOS on already stable systems. 

If we jump back to u/Fancy_Potato1476, mostly because the name conveys a certain opulence that we appreciate, the fancy potato didn’t update BIOS and still experienced boot issues, seemingly contradicting ASRock's claim. The ASRock post further explains:

"The issue is caused by some older DDR5 RAM and certain memory controllers on X3D CPUs, as well as the impact of Agesa.” 

The first part of that wouldn’t really make sense because if the system is working and then it stops working, that doesn’t really link up to RAM that was stable and then just suddenly wasn’t, but what might connect it is the Agesa part, which is the binary that AMD distributes that’s part of the BIOS and that would affect memory behavior. So if there’s any truth to that statement, then it’s the Agesa part that’s key.

When asked if it’s AMD or ASRock who’s responsible, the company stated via translation, “It is caused by a very specific combination of components.” 

The post ends by repeatedly expressing, “Do NOT update the BIOS if it’s running stably.” 

Generally, we’d agree. These days, new BIOSes can offer important security patches; however, broadly speaking, we prefer not messing with BIOS if everything is working well and there’s no strong security reason to. 

Conclusion

It looks like a combination of issues. There’s definitely a BIOS problem. There’s potentially a problem with the voltage being too low, which is causing inoperability at attempted boot that shouldn’t harm anything physically, so that’s a good problem to have as far as problems go. There’s also a potential bad batch issue. The BIOS issue could have multiple sub-issues, including too high voltage. Some users reported excessive VSOC via HWINFO, but these numbers aren’t always accurate and should be double-checked with physical measurements. 

Some general advice for anyone running into things like this: First, you’d want to rule-out memory training on initial boot. AMD systems, in particular, may require additional time to complete memory training where it’s essentially tuning your memory timings. Memory training normally only happens on the first boot. This shouldn’t take over 15 minutes with a new configuration and should finish much faster for configured systems.

For those using a 9800X3D on an ASRock board, we’d follow ASRock Japan’s recommendations of not updating BIOS unless something appears unstable. 

If something does appear off, we’d advise a flashback to version 3.10 or 3.11 if 3.10’s unavailable. These appear to be the most stable versions of BIOSes in relation to the boot issues. We’d temporarily hold off on updating to the latest 3.20 beta BIOS (unless you have issues already, in which case you should just update) mainly because it’s extremely recent, and beta BIOSes are generally less stable.

Use Flash Back if you already are on an unstable BIOS. This allows a BIOS flash without stability of the platform via a USB key.

If your system’s failing to post after previously working, we’d first recommend inspecting the CPU for any markings before going forward. We’d also advise checking your batch number at this point while your cooler’s uninstalled. 

For the handful of users with another compatible motherboard, we’d suggest using it to test your CPU’s ability to post. This would determine whether your processor’s dead or if there’s a boot issue. If your CPU’s unable to boot in the secondary motherboard or if you don’t have access to one, we’d advise flashing back to BIOS 3.10 first, then 3.20, and finally 3.05, in that order. After each flashback, give your system a few minutes before attempting to boot. If any of these resolve your issue, we’d suggest staying on that version.

If these options don’t go anywhere, you’re unfortunately left with returning the parts to the retailer if you have a warranty or going through an RMA with AMD. Luckily, we haven’t found any claims rejected and have spotted RMAs approved less than 24 hours after submission. 

If you’ve experienced a failure with one of your components and you don’t think it was something that we’ve already covered, you should email us at tips@gamersnexus.net. Conversely, if it’s something we’ve covered and we’re just not done yet, like with this story, for example, then let us know and we might be interested in buying components. We’re also doing an RMA rescue series on our GNCA channel, where we’re basically buying people’s failed components and then pursuing the RMA instead of them having to go through the process of having to do it so that we can test a manufacturer’s warranty process with an actual failed component from an end user. 

Moving forward, we’ll keep following this story if anything develops further.

We put the 9950X3D through numerous gaming and productivity benchmarks, efficiency tests, and more

The Highlights

• 9950X3D is a 16-core, 32-thread CPU with a 5.7 GHz max advertised boost clock and 128MB of L3 cache
• The 9950X is a better value for pure productivity and the 9800X3D is a better value for pure gaming
• The 9950X3D is a compelling CPU for both heavy production workloads and gaming
• Original MSRP: $700
• Release Date: March 12, 2025

Table of Contents

• AutoTOC

Intro

The quick version up front: The 9950X3D is comparable to the 9800X3D in most gaming scenarios, sometimes trading places; in production, it’s similar to the 9950X. The biggest change has been to the setup, which AMD says should now be simplified from prior dual-CCD parts with one faster CCD and one extra V-cache CCD. Historically, setting this up properly has made it necessary to isolate drives. If you were to install a 7600X and upgrade to a 7950X3D later, the easiest thing to do would be a clean Windows install (although there were ways to avoid this). That should be fixed now, but we’re still keeping all our drives isolated.

AMD is launching its R9 9950X3D CPU. This is a 16-core, 32-thread part with a listed MSRP of $700. The $600 MSRP 9900X3D will be launching alongside it, but wasn’t sampled, which is normally not a good sign.

Editor's note: This was originally published on March 11, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Testing

Patrick Lathan
Mike Gaglione

Camera, Video Editing

Vitalii Makhnovets

Writing, Web Editing

Jimmy Thang

But as we all know, MSRP often doesn’t hold at launch as new silicon gets sold at higher prices. We just uploaded an entire video digging into that. In either case, for these CPUs, we definitely wouldn’t pay over MSRP since the 9950X (read our review) is available regularly for $545, with the 9800X3D (read our review) for gaming at $480 (which is MSRP) as we write this. That may change, of course.

Today, we’re reviewing the 9950X3D. It’s been a long review cycle the past 3 months, so we’re going to keep this one simple and focus on the numbers.

9950X3D Overview

Let’s get straight into it today. We’ll start with the specs.

The AMD 9950X3D is part of the Zen 5 architecture that launched with the 9700X (read our review) and other CPUs last year. The 9800X3D swooped-in a little later and cleaned-up what was a confusing and messy launch, largely making major moves for gaming CPUs and giving us something to be excited about as it’s a really good CPU.

The 9950X3D is a 16-core, 32-thread CPU with a 5.7 GHz max advertised boost, 4.3 GHz base clock, and L3 cache at 128 MB. TDP target is 170W.

For comparison, the normal 9950X also has a max advertised boost of 5.7 GHz, base of 4.3 GHz, and TDP of 170W. These are shared. The cache changes, at 64 MB of L3.

The 9950X3D has two CCDs, with one of the two CCDs bearing extra cache. This is stacked vertically. As we described in the 9800X3D review, the cache this time is flipped so that it’s closer to the substrate than the lid, pushing the cores closer to the IHS. In the 9800X3D review, we demonstrated how this helped significantly with cooling.

9950X3D Testing

We’re keeping it incredibly simple this time. As always, you can find our test bench information published here. 

For gaming tests, we have all new data including the latest Windows updates and microcode for everything. That means we’ve refreshed the data set and wiped out what we had, so every CPU you that has been run was done in the last 3 days or so. We got the important ones in there. For production, we were able to salvage a lot of data since it’s the same.

We’ve been completely buried by one GPU after another in an onslaught of benchmarks and follow-ups the last few weeks, so for this one, we’re sticking to the basics.

Let’s just get into it.

Frequency Tests

Frequency - Blender All-Core

Frequency analysis is up first. We do this testing to ensure the CPUs are functioning as expected and to help explain the performance later.

First up is the Blender all-core workload. In this test, the 9950X3D had a frequency plot that started at about 5250 MHz, but settled closer to 5020 MHz to 5080 MHz during testing. This chart is intentionally zoomed-in to make it easier to see, so the scale purposefully does not start at 0.

For comparison, the 9950X non-3D (read our review) had higher peaks, but similar valleys. It ranged from 5010 MHz to 5080 MHz. In terms of average frequency over the course of the test, the 9950X3D averaged 5038 MHz all core to the 9950X’s 5036 MHz, but the X3D CPU did so with fewer peaks and more level frequencies in the middle of its range. We think this will be beneficial to it in gaming. 

The 9800X3D 5220 MHz all-core, putting it well above both. This will help it in some specific workloads, but obviously the lower core count will set it back elsewhere.

Frequency - Cinebench 1C

The next chart is for frequency in a Cinebench single thread workload. This has the 9950X3D up in the range of 5650 to 5725 MHz, which hits AMD’s advertised frequency of 5.7 GHz. The 9950X holds its frequency steadier and with fewer dips between tile cycles, but is overall comparable.

The 9800X3D holds 5225 MHz throughout the test so it’s lower than both when in a single-threaded workload in this situation.

9950X3D Game Benchmarks

Baldur’s Gate 3

Baldur’s Gate 3 is up now. This one had the AMD R9 9950X3D at 155 FPS AVG, technically becoming a new chart topper. The 9800X3D was our chart topper last time and is now functionally tied with the 9950X3D as the best CPU on the chart.

The good news is that the 9950X3D doesn’t appear to be suffering from its dual-CCD approach, so parking is functioning properly and the CPU is not hamstrung by its extra threads. 

The 9950X3D outranks the 7950X3D by similar margins as the 9800X3D did: It’s 23% higher average framerate, with lows comparable for the average. The 7950X3D (watch our review) outdid the 7950X, which we’re using old data for but should be no greater than 2-3% different based on our study of this test, by 29%. That’s with proper setup for the 7950X3D this time.

As compared to the 9950X at 101 FPS AVG, the 9950X3D outdid it by 54%. The 9950X is closer to the 7950X (watch our review) for performance, which makes sense. This game really benefits from the extra cache.

In fact, an easy example of this is the 5700X3D (read our review) vs. the 5600X3D (read our review): In some games, the 5600X3D outperforms the 5700X3D because of its higher clock rate. In this instance, the cache and core count was more beneficial than the frequency.

The 5800X3D (watch our review) remains an excellent CPU, up at 119 FPS AVG. The 9950X3D and 9800X3D outrank it by about 30%. As for Intel, it remains uncompetitive here. The 285K is getting crushed by two prior Intel generations for reasons discussed in that review, and that’s with new Windows updates.

Stellaris

Stellaris is one of our favorite CPU benchmarks because it looks at time rather than framerate, which is the most tangible to a user and the most directly influenced by the CPU. Players of 4X or other grand strategy games like Total War with the campaign map, Galactic Civilizations IV with turn pacing (and that’s a great game, if you haven’t played it), and Civilization would also see value here.

For Stellaris, the 9800X3D and 9950X3D both perform at the top of the chart. The 9800X3D outperformed the 9950X3D with a reduction in simulation time of 5%. That’s near error, but not quite. This seems to be a combination of a higher base clock and utilization.

The 9950X3D is definitely working as expected, though, because it’s outperforming the 9950X significantly. The simulation time requirement drops by almost 15%, from 32.3 seconds to 27.6 seconds.

This is the one game where Zen 5 in particular had stronger gains over Zen 4, with the 9700X doing well here and proving that. That’s from IPC uplift overall, where Zen 5 is benefitted.

Intel’s 285K is competitive with the 7800X3D and 9700X, at least. The 14900K (read our review) and 14700K (read our review) are within error of each other.

Dragon’s Dogma 2

In Dragon’s Dogma 2, the 9950X3D leads the chart. It landed at 132 FPS AVG here, passing the 9800X3D by a measurable but irrelevant 3.2%. Both CPUs lead all of Intel’s, although Intel at least lands its prior two generations ahead of the 7950X3D and 7800X3D with the game’s updates. This game really seems to benefit from extra cache, with the 9950X3D leading the 9950X by 46% and the 9800X3D leading the 9700X (although they have other differences) by 41%. Dragon’s Dogma 2 remains heavy on CPUs in NPC-intensive areas.

The 285K continues to impress with how much of a downgrade it is from not only AMD’s current generation, but Intel’s past generations.

We added the older results for the 3700X and 2600 to this chart. We noticed that performance on older generations hasn’t changed much. At most, there might be a 5% change here, but we don’t think so. Even with that though, anything is an upgrade.

Intel has seen the most upgrade since our last round of tests. This game has gotten updates, so it’s possible some of those were targeted at Intel. Windows updates could also affect it. We consistently saw uplift across Intel’s CPUs. That’s shifted the relative ranking of the 14th and 13th gen against the 7800X3D (watch our review).

Final Fantasy XIV Dawntrail - 1080p

Final Fantasy 14: Dawntrail is up now. In this one, the 9800X3D ran at 380 FPS AVG, with the 9950X3D at 373 FPS AVG. We observed relatively wide run-to-run variance in some of these results, so the error bars are wider than typical. The 9800X3D leads the 9950X3D by just 2%, so they are functionally equal.

The 9950X3D bests its 9950X non-3D variant by 50 FPS or so, or 16% here in average framerate. The 1% lows are also significantly improved, indicating that frametime pacing is keeping up with improvements in the average framerate.

The improvement over the 7950X3D is 5.8%.

Intel’s closest CPUs don’t appear until the 14900K at 310 FPS AVG. This is mostly interesting because there was a time when Final Fantasy’s prior benchmark versions were entirely dominated by Intel, with the clean division halfway down the chart. This is actually what we’re seeing now favoring AMD, relegating Intel to the bottom. That’s flipped in recent years and generations.

Intel’s 285K underperforms against its prior two generations. There was no change in performance against last time for the 285K. Intel’s one advantage in this test is frametime pacing, where the 0.1% lows indicate that Intel’s CPUs generally have more consistent frame-to-frame intervals than AMD’s CPUs, although not by an amount that’d change your experience in a noticeable way.

The 5600X3D outperforms the 5700X3D in this game. This has been known and is because of the higher clock speed on the 5600X3D, which proves more valuable than the extra cores.

Final Fantasy XIV - 1440p

At 1440p, the top of the chart truncates as a result of GPU limitations on the RTX 4090 (watch our review). We’ll move to a 5090 (read our review) for our full revamp of CPU testing for the next major architecture, but for now, this is where we cap-out. We’re sure this is deeply disappointing to all 12 of you who have an RTX 5090.

The 9800X3D and 9950X3D are about the same once again. The 7950X3D is also now about the same, as is the 9700X, thanks to the external limitations. This is a good reminder that the gains once scaling graphics are most seen in time-based situations or in seriously heavy CPU games like Dragon’s Dogma 2, but otherwise, most of the time you’ll get the most uplift from a GPU.

Starfield

In Starfield, we had the 9950X3D at 171 FPS AVG, leading the 9800X3D’s 165 FPS by 3%. The 9800X3D was notably ahead of the 7800X3D and the 9950X3D continued that, though neither had as revolutionary of a gain as we’ve seen in other benchmarks.

The 14900K trails the 7800X3D, improving upon its prior round result in a meaningful way; however, because of the improvements we’re seeing in the prior generations, the 285K now falls back behind Intel’s 14900K in this test. The 285K still regresses and generally embarrasses Intel, trailing even the 13700K (watch our review). Intel has continually tweaked its microcode on these prior generations, so it’s possible that they rolled-out a microcode that had lost some performance at some point and they’ve regained some now with the 13th and 14th series. We update BIOS to the newest version for each round.

Against the 9950X at 124 FPS AVG, the 9950X3D improves by 37%. That’s one of the larger gains. Of course, if you’re not going to use the extra cores, the 9800X3D makes more sense for value.

Cyberpunk 2077 - 1080p/Medium

Cyberpunk 2077 is back in our CPU test suite again with the Phantom Liberty expansion. Tested at 1080p/medium here, the 9800X3D and 9950X3D both ran at about 219 FPS AVG and were well within run-to-run variance at only fractions of a frame per second apart. The 7800X3D trails, but not by much. It’d be roughly the same experience as these two.

The lead of the 9950X3D over the 9950X is 37% again, matching some of the other games. The Intel 200 series outdoes the prior generations here, finally, with the 285K at 170 FPS AVG. Unfortunately, that’s still below the AM4 5700X3D and 5600X3D.

F1 24 - 1080p

F1 24 at 1080p is up now. This one has the 9950X3D and 9800X3D again roughly tied, with the 7800X3D not far behind. The advantage is only 7%. The 9950X3D leads the 9950X non-3D variant by 29%, slightly reduced from the advantage seen in other games. We might be hitting a GPU limit here.

Intel’s 14900K is its closest competition, released in 2023, with the 285K down at 9950X levels. The 5600X3D and 5700X3D results show again that this game likes frequency and IPC to some extent.

F1 24 - 1440p

1440p is almost exactly the same in the bottom half, with the top switching around due to GPU overhead and limitations on GPU scaling. The 5800X3D falls down the ranks as the 14th and 13th gen handle the overhead a little better and with more stable frametime pacing, which helps the average. Otherwise, things are about the same sans limitations of scaling for the 9950X3D.

9950X3D Production Benchmarks

We’re moving on to production tests now. This is where the 16-core CPUs do well. Historically, we’ve seen the X3D variants of all of these CPUs underperform against the non-X3D parts due to power allocation to allow higher boosting. Extra cache doesn’t help in our testing here normally. We’ll see if the 9950X3D breaks that general trend.

Blender Rendering

Blender testing hasn’t changed since our October round. We ran validation on several CPUs and the results came out basically identically, so we can keep a lot of data for more comparisons. This should help those of you on older hardware because we’ve got more present here.

The 9950X3D required 6.6 minutes to complete the render, which is about tied with the 9950X. It was technically faster, but in reality, these are tied. That’s good news for the X3D part, though: Past X3D CPUs, like the 7950X3D, have been technically slightly slower than their non-3D equivalents. That’s not because of scheduling or parking, but because the frequency is slower in an all-core workload.

Another good example is the 7800X3D, which was slower than the 7700X by time required, or 5800X3D as slower than the 5800X. The 9950X3D is the first to break this trend in a big way. Technically, the 9800X3D looked like it was doing that against the 9700X, but the power target was what brought most of that change.

The 9950X3D outperforms the 285K here, with about a 7% reduction in total time required to complete the render.

Chromium Code Compile

Chromium code compile in Windows is another where the data set hasn’t changed, so we were able to salvage it after validation. The 9950X3D required 81 minutes to complete the compile, which is comparable to the time required for the 9950X, but technically improved. This puts it marginally ahead of the freshly retested 285K, with a reduction in time required to compile from 285K to 9950X3D of 4.7% less time required. The 14900K required 88 minutes here, with the 265K at 98 minutes. 

The 9950X3D is the new leader in our compile test. This is not going to be representative of every type of code compile, just like none of these tests is representative of every angle of a use case; however, the way we test it, the 9950X3D is the new leader short of going to Threadripper.

7-Zip Compression

Data for decompression and compression can’t be salvaged, so it’s all new.

In 7-Zip file compression testing, the 9950X3D led the chart at 206,643 MIPs, or millions of instructions per second. That has it just ahead of the 9950X by 3.3%. This is one of the tests where cache can help, depending on its implementation. The 5600X3D and 5600X are good examples of this: The X3D part has a lower advertised frequency, but manages to still roughly tie the 5600X.

The 9950X3D outperforms the 7950X3D by 8.5%, which completed 191K MIPS. The 14900K is next at roughly 189K MIPS, then the 13900K (watch our review). The 285K follows all of these, down at 179K MIPS. 

Core count clearly matters in this test: The 3950X 16-core CPU is outperforming the 5900X 12-core CPU and 9700X 8-core CPU.

7-Zip Decompression

In 7-Zip Decompression, we measured the 9950X3D at 277K MIPS, with the 9950X non-3D at 272K MIPS. You wouldn’t really benefit from the 9950X3D in a meaningful way in either compression or decompression in this workload. The 9950X achieves all of the performance already, so you’d need use cases that more directly leverage the cache to get value out of the 9950X3D.

Intel’s 14900K is its closest competitor, followed by the 14700K and then the 285K.

Adobe Premiere

We saved some of the data for Adobe Premiere as well. The biggest swing was to Intel’s 12th to 14th Gen CPUs here, where we saw some movement from the Windows updates recently. Most of the other parts stayed relatively stationary. Any 12th to 14th Gen CPUs with data prior to this round would move around a bit, so be aware of that; however, just to try and offer some extra data that’s still mostly comparable, we’ve left those parts here. Most of this data is brand new.

The 9950X3D scored 11600 points in the Puget suite aggregate extended scoring for Premiere, which puts it at the top of the chart. It bests the 9950X by 5.8%, with the 14900K closest to it, then the 285K. The improvement over the 7950X non-3D is 7%.

9950X3D Efficiency

We’ll keep power and efficiency testing short this time and just show a couple situations.

Starfield

In Starfield, the 9950X3D ended up at 1.7 FPS/W, putting it behind the 7950X3D and 7800X3D, but tied with the 5700X3D and 9800X3D. The 9950X3D pulled 98.8W when playing this game, and Starfield is one of our games that most heavily loads the CPU (but is still nothing like an all-core Blender workload).

The 9950X non-3D part pulled 168W in this same test, putting it down at 0.7 FPS/W. That means the 9950X pulled nearly 70W more than the 9950X3D, or about a 70% increase in power consumption despite running at a lower framerate. In terms of FPS/W, the 9950X3D is both higher framerate and lower power, and so it is far more efficient. It’s still not as efficient as the low-power 7800X3D, though.

7-Zip Compression

7-Zip compression shows that the 9950X3D can still be power-hungry. In our compression efficiency testing, the 9950X3D pulled 203.8W. That put it at 1014 MIPS/W, which makes it less efficient than about half the chart. The CPU is the best performer, but not for efficiency and that’s because it’s pulling 204W, its efficiency has decreased compared to some others.

The 9950X scored 979 MIPS/W and pulled the same power at 204W, making it less efficient than the 9950X3D. The 7800X3D is a lower performer overall, and in big ways, but has such impressively low power consumption that it ends up being the most efficient.

Of course, if you were serious about running this kind of workload all the time, you’d still want something more powerful than the 7800X3D.

7-Zip Decompression

Decompression testing looks better for the 16-core parts, with the 7950X3D proving incredibly efficient here, followed by an impressive result from the 7950X non-3D with ECO Mode enabled. The 9950X3D ran at 1358 MIPS/W, putting it slightly ahead of the 9950X. They’re still in the middle of this chart though.

9950X3D Conclusion

That’s it. You have the numbers.

For the quickest recap: For gaming, you can think of the 9950X3D like a 9800X3D. We didn’t run into any major issues with the 9950X3D here. That in and of itself is kind of an accomplishment for AMD. The company has really struggled over the years with the dual CCDs, where one has the extra X3D cache on it. Over the years, it’s taken them some time to get to a place where it’s not regressive and where it’s a little easier to set up. The 9950X3D does appear to do that in our experience so far and that is a major improvement for AMD. It’s taken them some generations to get there.  

If you have the funds and are looking to build a purely gaming computer, we think you should scale it down and go for a 9800X3D. It’s just not that big of a difference as the 9800X3D often trades places with the 9950X3D and you save some money. 

Intel, on the other hand, is out of this conversation right now. They are not part of the high-end expensive CPU for gaming build scenario at the moment. 

Meanwhile, the 9950X makes sense for production-heavy builds that don’t have an explicit use for that extra cache. There’s definitely use-cases for this out there. We see a little bit of that in our 7-Zip testing, but for the most part in the things we test, it doesn’t tend to benefit from the extra cache in non-gaming scenarios. 

Where the 9950X3D, and the other X3D 16-core parts, shine is a more limited use case where you have some mix of really heavy production and really heavy gaming. If you do a lot of compression, decompression, maybe render things on the CPU, are heavy into Premiere, or do a lot of code compiles and play a lot of games, then that’s kind of the use case for the CPU. 

If you’re in one camp or the other exclusively, then you can save some money by going for either a 9800X3D or a 9950X.

We wouldn’t pay more than MSRP for the 9950X3D. CPUs tend to stick closer to MSRP, but can still have stupid prices from some retailers or third-party sellers.

We conduct a deep-dive investigation on how a Reddit user’s 9800X3D CPU and MSI MAG X870 Tomahawk WiFi motherboard exploded

The Highlights

• A Reddit user’s 9800X3D and motherboard incinerated
• We decided to purchase the CPU and mobo to figure out what happened
• Our verdict was that the incident was likely caused by user error

Table of Contents

• AutoTOC

Intro

We bought a used motherboard that has multiple burn sites, charred plastics, solder that has bubbled through the socket, scorched pins that were discolored by the heat and turned blue, and it’s accompanied by a CPU with a matching damage pattern.

Also, it smells like…magic smoke.
We’re taking a look at a failed 9800X3D CPU that exploded in the socket and motherboard. We’ll dive into what went wrong for a Reddit user who posted it a while back, hopefully providing an educational opportunity and some cool traces of catastrophic damage.

Editor's note: This was originally published on December 30, 2024 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Editing

Mike Gaglione

Testing, Writing, Camera

Jeremy Clayton

Video Editing, Camera

Tim Phetdara

Writing, Web Editing

Jimmy Thang

Overview

The used AMD Ryzen 9800X3D and MSI MAG X870 Tomahawk WiFi motherboard we purchased are heavily damaged and likely totally dead. We bought them from the Reddit user, who posted it to r/pcmasterrace after the incident.

The user said this:

“I built a new PC last night, and I couldn't figure out why it wouldn't POST. When checking for bent pins, I found that it killed itself. :(“

The situation immediately reminded us of the 7800X3D failures following its launch. Since that came down to a fix in the motherboard BIOS, other users naturally started asking questions. When asked about BIOS, the user said:

“I don't know what the BIOS rev. was because it never worked, unfortunately. It has whatever BIOS it shipped with.

It burned up before I ever entered the BIOS. The socket was brand new when I put the chip in, no bent pins or anything.

Edit: Since people have many theories about pins being bent, here are some more photos: https://imgur.com/a/b5x4BVh

The plastic is melted and I think this deformed them. It's a chicken or egg thing.

This was not watercooled and there was no water around this PC.

I don't see any stickers with the BIOS rev on it.”

The above images are some photos the user provided. As you can see, it’s bad. But we have our own evidence and microscope shots to get into because the Reddit user was willing to sell us the components.

The root cause last time, back with the 7800X3D, mainly came down to excessive voltage over an extended period of time, possibly in conjunction with poor internal thermal protections, and motherboard overcurrent protection (OCP) being set way too high. This led to dielectric layer breakdown at the transistor level in a runaway failure state, causing shorts and internal temperatures hitting the point of melting silicon.

In simple terms, too big zap force make CPU go boom.

Ultimately, the issue was fixed via BIOS updates leveraging stricter controls around VSOC, as handed down from AMD to the board manufacturers.

But this new failure likely isn’t the same. 

A lot of the internet pointed toward some potential user-caused damage from improper installation. We had some tell us not to buy the part as they were worried we’d be paying for someone’s mistake. While we really appreciate the concern, it’s the audience that puts us in a position to be able to afford to buy out catastrophic failures like this when they happen. We view it as part of the business: If there’s a chance of something educational coming out of it, we want to be there to learn it. Worst case, some guy installed his CPU wrong and he gets helped out, never makes the mistake again, and we all get some cool shots of a crazy failure. 

Best case: You never know when someone has discovered the next massive failure that could affect thousands of users in an anti-consumer cascade, like Intel’s instability, and it’s important for us to treat all of these events seriously and get the parts before they disappear into the hands of manufacturers with motive and opportunity to hide the results. Third-party investigation is important to transparency.

So, that’s why we’re OK with spending money on something that unveils nothing every now and then, because every time it unveils something important, we can help keep a company honest. And when it doesn’t, someone at least got a bailout.

Let’s get into the damage report.

Damage Report

The bottom of the 9800X3D (read our review) has two major burn sites with discoloration, charring, a hardened, enamel-like substance, and individual points of concentrated scorching where the tips of the LGA socket pins were located. Also, it smells bad.

The motherboard’s socket has damaged areas directly matching the pattern from the bottom of the CPU. The pins themselves are slightly bent out of alignment and discolored, with a few showing an intense bluing as seen on heat-treated metal. Solder from under the socket flowed up onto some of the pins, and the bed of plastic is scorched, appearing molten. There’s also one pin near the bottom that’s badly bent over, without visible burn marks. It, too, smells bad.

The plastic edge of the socket is damaged in two major locations. The bottom left corner shows marring along a slight angle on both the left and bottom borders of the socket area. Along the bottom edge, the plastic alignment pin is clearly misshapen, appearing crushed.

Moving to the bottom of the socket actuation mechanism (SAM, as AMD calls it, also known as ILM in Intel-speak), the hole in the base shows two points of physical wear accompanied by discoloration on the PCB itself. This area differs in design between the AM5 socket manufactured by Foxconn, which this is, and the other AM5 socket, made by Lotes. We’ll get into that later.

A final sign of damage is a missing chunk of plastic between pins 3 and 4 on the ATX 24-pin header, which we wouldn’t have expected.

In technical terms, this board is f***ed up.

We haven’t observed any damage to the back side of the board underneath the socket or anywhere else. That includes the top part of the SAM, which some people thought looked bent in the user’s photos. It is not bent. That may have been lighting and those users are incorrect.

The CPU and motherboard are irreversibly and catastrophically damaged.

Knowing all of the aftermath, we need some testimony.

Other key pieces of first-hand testimony from the Reddit user include the following:

In reference to the pins, the user said, “They were definitely not bent prior to installing the CPU. The CPU is bulging where it's burnt and the mobo socket is slightly melted.”

When asked if all power cables were plugged in, the user replied, “Yes everything was in place. I checked all connections when it wouldn't post and everything was fine. Nothing was in the socket when I put the chip in. That was the first time it was ever opened.

I did not update BIOS prior to trying to boot.”

This is about the time we stepped in, offering to purchase the parts from the user for their full retail price.

Hypothesis

Moving on to our hypothesis, we thought that the cause of this failure was a dead short to ground, and not an inherent flaw in the CPU or the motherboard BIOS.

We thought this could have happened two ways and kept an open mind.

Option one would be a defect in the socket or the motherboard as a whole – manufacturers can always screw up. If the factory misaligned the socket in relation to the underlying PCB, or damaged the plastic surround of the socket, then it could have led to misalignment and a short.

Option two is improper installation. If the user installed the CPU into the motherboard in such a way that caused the outer socket damage and misalignment of the CPU in relation to the socket pins, then that would be sufficient to cause a short as well.

Detailed Support and Evidence

It’s possible that the issue was caused by something else we can’t account for, but given the evidence we have, we believe that improper installation is the most likely cause.

Now for the details and evidence to support our hypothesis.

The CPU appears to have been installed with an offset within the socket by ~1.01mm diagonally to the left and down at the bottom edge where the socket’s lower guide pin is. This is enough to cause the pins to mate with the wrong pads.

To determine this, Jeremy on our team took a measurement based on converting the known width of the guide pin (1.3mm) and then pixel measuring the microscope shots by pixel counting.

It took a while. There’s a lot of pixels.

This got us the distance between where the CPU’s guide cutout is supposed to sit versus where the plastic is crushed on the guide pin, then we converted it to millimeters. It’s not exact, but it’s very close, and establishes the basis of our hypothesis.

This is generally supported by the marred edge of the socket at the bottom left, and possibly faint rounding off along almost the entire bottom interior edge. This would also result in the bottom edge of the CPU being raised away from the socket in the Z-axis, adding light or poor pin-to-pad contact into the mix, i.e., higher resistance.

Taking a closer look at the bottom of the CPU shows that it was rotated by 1.0-1.4° clockwise, relative to the socket, when the burn occurred. This is based on the pattern of pinpoint scorch marks left by the pins. We carefully inspected the burn marks on the pads where you can see the point of contact, which is evident not only from the natural scratches caused by contact, but by the residue surrounding the burn sites. They should contact the pins in parallel rows, but the marks clearly show an angle. As you go along the pins, you see it diverging. Measuring in software, we came to the 1-1.4 degree offset.

Analysis of the burned pins in the socket shows that all of them are VDDCR (core voltage) pins that are down and/or left of VSS (ground) pins. If the CPU was shifted down and left in relation to the socket, then the burned VDDCR pins would have been in contact with VSS pads on the CPU, causing a catastrophic short circuit.

The fact that the top row of pins in the bottom half of the socket has no burns at all supports this, as those pins would have been in contact with the CPU substrate, not any pads. There’s nothing else conductive to touch in that direction until you get across the gap to the upper field of pads.

That said, not all VDDCR pins that were nearby to ground got burned. We can speculate on a few reasons for this. 

The skewed angle of the CPU in the Z-axis and the unknown pivot point would make the offset inconsistent across the 2D plane of pins. Also, it’s possible that some pads on the single-CCD 9800X3D are not connected internally.

The marring and discoloration where the tip of the SAM (or ILM) touches the motherboard PCB is less conclusive evidence as compared to the rest. 

Best case scenario, it’s just physical wear unrelated to the burning incident. Worst case, it’s a location where core voltage was able to find another path to ground and scorched the PCB.

Finally, the SAM doesn’t show any signs of damage or bending that we can detect. It’s made of springy steel that readily returns to its original state after flexing – assuming it isn’t pushed past elastic deformation into plastic deformation, or in other words, made to permanently bend. 

We think the area suspected of damage in the user’s photo is an optical illusion – a reflection or light shining through the top of the case.

Through all of this, we want to make it clear –  the user shouldn’t be bashed for this. This sort of thing can happen to anyone, and that’s especially true with newer platforms. We’re grateful that the user was willing to sell us the parts to inspect, because we had fun working through the diagnostic.

We’ll use it as a learning opportunity.

Concern about SAM/ILM Styles

All of this led to one observation that we hadn’t realized before that we’d like to briefly cover.

We have a new concern about the two different styles of AM5 socket by Foxconn and Lotes. Research on this piece led us to realize that there are actually a lot of differences between them, in ways that should mostly be immaterial to functionality. 

For example, the Foxconn socket has solid pins and solid plastic, while the Lotes socket has split pins and a more skeletonized plastic molding.

The discoloration on the burned motherboard where the tip of the SAM touches down raises our concern in general, even outside the scope of this piece, because the metal comes in direct contact with the PCB, directly on top of surface-level traces. 

We don’t think this is what happened here, however: Repeated socket actuations could theoretically cause the SAM to abrade through the mask and create a short.

The Lotes version of the socket has the insulation sheet run across this entire hole, adding a barrier of mechanical protection. 

We aren’t saying that the Foxconn socket will have problems, just that we would like to see more conformity to a single style between vendors.

We took a brand-new sample of the same model X870 Tomahawk motherboard and repeatedly opened and shut the SAM 16 times with a CPU in the socket to see if this area of the board would show similar wear or any change at all.

At the beginning of the test, we saw some disturbance of the protective sheet on the left, and a small spot of what looked like adhesive on the right, surrounded by an extremely faint discoloration. At the end of the process, it looked virtually unchanged, and nothing like the burned motherboard.

This pushes us to think these spots were subjected to heat, or maybe a direct short as we mentioned before.

Conclusion

The short version of this is that, after looking through everything, we think that the result of all this is improper installation, which is something a lot of Reddit users were pointing out when looking at the photos online. 

Regardless, we definitely think this story was worth doing. First of all, it was a lot of fun to piece together a mystery. It also allowed us to possibly learn something major as you never know when some random PC builder might encounter something like the next Intel instability issue, where it might initially be perceived as user error but then proves to be a big, valid issue. 

In this case, this issue doesn’t seem to be something for people to worry about, though users should pay attention to how they're installing their CPUs. It’s possible that a situation like this could have happened if you tried to install the CPU with the motherboard oriented vertically. It’s important to lay the system flat to install it properly and to be careful with where the guides are aligned. You can also slightly wiggle the CPU a bit once it’s installed, but shouldn’t do it hard, to see if there’s something wrong.

We delve into AMD’s CES reveals, which include new CPUs, GPUs and SOCs

The Highlights

• AMD’s GPU reveals include the Radeon RX 9070 and RX 9070 XT
• AMD’s CPU reveals include the 9950X3D and the 9900X3D
• AMD announced 3 new SOCs: the Z2 Extreme, Z2, and Z2 Go
• AMD also announced a new mobile CPU: The FireRange AMD Ryzen 9 9955HX3D

Table of Contents

• AutoTOC

Intro

AMD announced a ton of CPUs, GPUs, and handheld hardware today. The announcements were for the 9950X3D, 9900X3D, Ryzen Z2 SOC for handhelds such as the ROG Ally, and RDNA 4 GPUs like the RX 9070 and RX 9070 XT. AMD also announced a number of mobile CPUs. Our focus will be on RDNA 4 and the new Zen 5 X3D parts alongside the handheld SOC.

AMD 9070 XT & 9070

We’ll start with AMD’s GPU news since it’ll be the quickest.

Editor's note: This was originally published on January 6, 2025 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Host, Writing

Steve Burke

Video Editing

Vitalii Makhnovets

Writing, Web Editing

Jimmy Thang

AMD announced the existence of its Radeon RX 9070 and RX 9070 XT today, noting Q1 2025 availability.

Specs are extremely limited right now. The company did picture several partner model cards in its announcement slide, including at least one that looks like a Yeston model, an ASRock model, XFX, and all the others listed. The cards pictured above are generally 3-slot coolers that are 2-3 slots thick.

AMD says the GPUs will use its RDNA 4 architecture and will utilize a 4nm process from TSMC. AMD mostly described its specs with adjectives, which is unfortunately not particularly useful. Words like “optimized compute units,” “supercharged AI compute,” and “improved raytracing per CU” don’t tell us a whole lot. We’ll have to wait for that information.

Likewise, AMD announced that FidelityFX Super Resolution, or FSR4, will be released and has been built for RDNA 4. It intends to re-launch its Anti-Lag software solution that was intended to compete with Reflex, now in its Anti-Lag 2 iteration. We were not pre-briefed with any further information than this at the time of briefing.

The company is clearly self-aware, as it also presented a slide about its naming choices for the RX 9070 series. Go figure. The slide above shows that AMD intends to line-up the 9070 series, including both XT and non-XT models, with the RX 7900 XT down to the middle of the RX 7800 XT (read our review), whatever that means. The worst 9070 is apparently half of one RX 7800 XT -- or maybe that means 1.5 7800 XTs? All we’re missing is a note telling us that the image is not to scale.

Anyway, against NVIDIA, this roughly positions the 9070 series as comparable, according to this image, to the 4070 Ti (watch our review) and 4070 Super (read our review). We won’t get out our scrying stones for this hastily thrown-together image since it’s hard to judge without real numbers, but that’s at least how AMD seems to be positioning it.

The company claims the change is to line-up with its Ryzen 9000 CPUs and says it will reserve 8000 naming for its mobile CPUs.

AMD CPUs

On the CPU side, AMD’s two new desktop CPUs are predictable: The 9950X3D and the 9900X3D, which use the Zen 5 architecture that shipped at the end of last year and follow-up the wildly successful 9800X3D. The 9800X3D has been constantly out of stock due to the demand.

The 9950X3D is a 16C/32T part that advertises a maximum boost frequency of “up to 5.7GHz,” noting a 144MB total cache size. At the time of writing this, AMD has not provided pricing details or a specific release date beyond sometime within the next few months. 

For comparison, the 9800X3D (read our review) has a total 104MB cache and $480 MSRP. The advertised boost of the 9800X3D is 5.2GHz, so the 9950X3D has a greater cache size and may benefit from higher boosting. The 144MB cache on the 9950X3D comes from the additional CCD in the configuration and could have some specific benefits that we’ll explore in our eventual review. 

The 9900X3D is a 12C/24T component that advertises up to a 5.5 GHz boost max. It has a 140MB total cache. The 9950X3D runs a 170W TDP, with the 9900X3D at 120W. The 9800X3D is also 120W. Because of this, the 9800X3D may benefit from additional power available during fully loaded workloads. There could be some shuffling of the CPU stack in specific benchmarks due to the power budget differences.

AMD’s updated chipset drivers should more intelligently park CCDs and, in theory, should make it easier to upgrade in-socket without needing to blow away the whole OS prior to moving from a single-CCD part to a dual-CCD part. We will still be using isolated SSDs for our reviews, but this should be a benefit for end users who may later seek to upgrade in-socket.

AMD published some first-party claims. As usual, we’ll have our own numbers soon -- as will basically all other reviewers -- and so you should wait for those prior to making decisions. To set the stage for what we’re verifying against, AMD is claiming the following:

AMD says this is “the world’s best gaming processor,” though note that they are comparing it to the 7950X3D (watch our review). The 9950X3D is shown as being on average 8% better across 40 games that AMD tested, with a range of no change to a 58% uplift over baseline compared to the 7950X3D.

AMD also claims that it outperforms the 285K (read our review) by 20% on average across 40 games. We definitely believe this, based on numbers we ran for the 9800X3D and 285K already.

Its first-party numbers also point to performance improvement in Blender, with lesser improvements in Photoshop and Premiere in PugetBench testing against AMD’s own prior processor.

Historically, these CPUs do not necessarily provide significant improvements over the single-CCD X3D CPUs of the same generation. You might see rough equivalence or slight changes in specific games. The primary advantage would be for someone who does a lot of gaming but also wants the additional cores for production workloads. 

The other historical challenge has been behavior with core parking, something we’ve now detailed extensively. While core parking is still a “thing,” AMD says its new chipset drivers should resolve a lot of the past issues.

AMD Z2 SOC

AMD’s Z2 SOC follows-up the Z1 and Z1 Extreme mobile solutions that were found on some handheld devices. AMD has also offered mobile chips like the 7840U and 8840U that have been in handheld devices and are comparable.

The Z2 is light on information: AMD again defers to descriptors like ‘breathtaking” and “exhilarating speed,” which we assume is the next speed setting for a Back to the Future movie. 

It also gets into some business-y stuff, like the addressable market and increase in competition in this market.

As for actual news, the Z2 family comes in 3 variations currently known: The Z2 Extreme, Z2 Go, and the…Z2 non-Extreme, non-Go.

The Z2 Extreme and Z2 are both 8C/16T parts with the same cache and a boost frequency separated only by 100 MHz. The actual change comes in the form of the integrated graphics. This is also where the Z1 and Z1 Extreme deviated most heavily. The configurable TDP allows up to 5W more driven to the Z2 Extreme, which will cost battery life but help power the GPU. The Z2 has a higher boost clock despite a lower cTDP, likely due to overall package budget allocation with the GPU change (and also density).

The Z2 Go is new. This is a 4C/8T part that only boosts to 4.3 GHz maximum advertised, only has 10 MB of cache, keeps the 15-30W cTDP, and keeps the 12 CUs. This CPU is far weaker than the others listed here, especially with that clock drop, so we’re curious to see what types of devices make the best use of it. We’ll also be curious to see battery life and if it can stick closer to that 15W number while still providing meaningful performance.

These are all listed for Q1 2025 availability, so we’ll be busy on our team running handheld benchmarks once again here soon. We ran several reviews last generation and will need to do a total refresh.

AMD HX3D

We’d like to dedicate this next section to our late friend Gordon Mah Ung, who once joined us to complain about AMD’s mobile CPU naming scheme.

AMD’s new mobile CPU is the FireRange AMD Ryzen 9 9955HX3D that’s releasing in 1H 2025, and it’s joining the 9955HX and 9850HX mobile parts.

The 9955HX3D is advertised as what AMD claims is the best gaming and content creation part for mobile. We don’t really test mobile, but we certainly use high-end laptops for our travel and might try these out.

The 9955HX3D is a 16C/32T part that boosts up to 5.4GHz. It has 144 MB of cache and a TDP of 54W. The 9955HX is the same, but with less cache. The 9850HX is a 12C/24T part with lower boost, no X3D cache by mercy of its easier name, and the same TDP.

AMD also spent some time on its new “AI” brand name mobile processors, but we’ll leave that to someone else to cover as that’s not really our area of focus.

We compare Intel’s 12th gen CPUs against newer CPUs in a variety of gaming and productivity benchmarks

The Highlights

• Alder Lake brought a new platform that included new I/O, options for both DDR4 and DDR5 and PCIe Gen5
• Intel’s 12th gen CPUs are no longer chart toppers
• Intel’s 12th series CPUs escaped the company’s 13th and 14th gen issues

Table of Contents

• AutoTOC

Intro

We’re revisiting Intel’s best recent CPUs right now. Intel Alder Lake managed to escape the 13th & 14th “Gen” issues without a scratch while also being the start to this era of CPUs. They can socket into the same motherboard as a 14900K in many instances and are somehow even still available for (sometimes) reasonable prices. Recently, the 12900K was as low as $120 from Best Buy as it got purged from inventory.
In this article, we’re revisiting the 12900K (watch our review), 12700K via our KF, the 12600K, 12400, and 12100F.

Editor's note: This was originally published on November 17, 2024 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing, Video Editing

Steve Burke

Testing

Patrick Lathan

Mike Gaglione

Video Editing

Tim Phetdara

Writing, Web Editing

Jimmy Thang

As a quick reminder of the history of these parts, this is what we thought of them back when they launched: “This is an excellent first volley from Intel with Alder Lake. It is on the expensive side. Price has crept up, performance, fortunately, has also crept up but so too has power. You get some new and exciting technologies with Alder Lake; DDR5 being one of them. Ultimately, it's about how this competes and this has surprisingly decent value when compared to the 5900X (watch our review) and the 5950X (watch our review), especially in production workloads. There are places where AMD still holds an advantage but they have gotten slimmer.”

That was for the 12900K. For the 12100F (watch our review), we were also relatively positive: “At $130, it's actually a pretty exciting CPU for us to review because, for gaming, it did very well. And even with a high-end GPU, it's doing pretty well, so we were impressed with its gaming performance.”

It feels weird to revisit our old reviews because we were really excited about what Intel was doing at the time. It was fiercely competitive. 

It’s easy to forget how positive we were on some of Intel’s launches back from the 8000 series into the 12th Gen with Alder Lake when looking at the last few rounds. The 13 and 14 series CPUs were largely refreshes, but Alder Lake brought a new platform forward with new I/O, including options for both DDR4 and DDR5 and PCIe Gen5.

AMD had also forsaken its budget market at this time: Going back through our old reviews, we were reminded of how AMD had gotten so comfortable in its position that it had stopped the 5000 series briefly at the 5600X (watch our review) levels. They introduced the 5600 (watch our review) to help with this, but overall, AMD’s pricing was much higher than it had been in the preceding generations. That left Intel with a huge gap to fill with its 12100F, which later went on to land on our Best CPUs of the Year awards list for at least 2 years for its viability as a true budget gaming part.

So that’s the history. These CPUs were exciting. 

For this revisit, to make space on the charts so they are somewhat legible, we’re removing the 7900 non-X, 7700 non-X (watch our review), and 7950X (watch our review) ECO Mode results from gaming benchmarks. You can find all these numbers in our 9800X3D review or 7600X3D CPU review if you’d like them. They are directly comparable.

That’s enough of a history lesson. Let’s get into it -- and we’ll start with a new set of experimental charts.

Modern Equivalent Table (Gaming)

Equivalent Gaming Performance in 2024 | Alder Lake Revisit | GamersNexus | EXPERIMENTAL CHARTS

We have a table we’re experimenting with for this. This table will list the closest equivalent component for each application tested. Sometimes the ranges don’t line-up well, so we chose the closest within reason, but deferred to older parts where necessary. We defined “modern” as anything from Ryzen 5000 or newer and anything from Intel 13 and newer, even though 5000 can be pretty old -- it opened up more comparisons.

Broadly speaking, we noticed that the 12900K is similar to a newer i5 in several games. This included Stellaris, F1 24, Starfield, Final Fantasy XIV, and the Ultra 5 in Rainbow Six (but with worse lows). The Ultra 7 265K (read our review) was also close in Final Fantasy and Baldur’s Gate 3. AMD’s CPUs are more varied, and include the 7600 (watch our review), 7600X (watch our review), 5800X, and some X3D parts, generally those are higher performers.

The 12700K was broadly similar to an Ultra 5 245K from Intel or a 5600X to 5800X from AMD, with some X3D presence. Most X3D parts perform much higher than these Alder Lake CPUs.

The 12600K was regularly near the 5800X and 13600K CPUs.

The 12400 regularly neighbored the 5600X and sometimes the 245K or 9600X. The 12100F had few modern neighbors, mostly aligning with a 3700X (watch our review) or 3600 (watch our review) for gaming performance.

Modern Equivalent Table (Production)

Equivalent Production Performance in 2024 | Alder Lake Revisit | GamersNexus | EXPERIMENTAL CHARTS

Here’s the same concept, but applied to production workloads.

Intel Alder Lake does better here for modern equivalents. The 12900K is regularly similar to a 13700K (watch our review) or 7900-class CPU. It isn’t distant from the 265K in Decompression, although dips in Premiere closer to a 245K (read our review).

The 12700K (watch our review) is similar to the 13600K in many of its tests, so after 3 years, it has dropped to subsequent series i5 performance levels. The 245K is regularly right alongside the 12700K. From AMD, the 9700X (read our review) and 7700X are regularly its modern equivalent. The 12600K (watch our review) is most similar to the 9600X or 7600X in many tests, with no nearby modern Intel equivalents. They are all much better than this. We might have to test a 13400 (read our review) or something to see this level.

The 12400 (watch our review) is regularly near the 5600X. In some tests, it is down at 3600 or 2600 (watch our review) levels. The 12100F has no modern neighbors and, in some instances, no suitable comparisons close by. The R5 2600 (watch our review) is regularly the closest comparison for the 12100F.

Intel 12th Generation Gaming Benchmarks

Stellaris

We’ll start with Stellaris, the space game which we use to test for simulation time rather than framerate. This is still a great benchmark because the results don’t care about resolution or graphics: It is a highly CPU-bound game with real-world implications for time.

First up, our new entry with the best result is the 9800X3D with liquid nitrogen and at 6.2 GHz. Although you could have a friend or family member pour LN2 while you game, it’s not likely -- but we wanted to put it here to show just how insane the CPU is when pushed to the limits.

Snap back to reality, we have Alder Lake: The 12th Gen CPUs land at 36.7 seconds for the 12900K, 37.7 seconds for the 12700KF, 41.2 seconds for the 12600K, and 43.1 seconds for the 12400. Top-to-bottom, this creates a range of 6.4 seconds, or a reduction in simulation time from the 12400 to the 12900K of 15% -- meaning 15% less time to simulate. If you had bought the 12900K for $630 in 2021, then it’s given you about 3 years of performance and has aged into a modern i5 in this test, which really isn’t that bad. The 14600K is adjacent at 36.6 seconds. An in-socket upgrade to a 14900K (read our review) would get you about a 9.5% reduction in simulation time and is probably not worth it for most people. The 9800X3D (without liquid nitrogen) would yield a 30% reduction in simulation time.

The 12700K is slightly better than a 5700X3D, with the 12600K around 5800X (watch our review) and 5600X levels. The 12400 is significantly better than the 12100F at 47 seconds and just behind the 5600X.

Dragon’s Dogma 2

Dragon’s Dogma 2 is up now. In this one, the chart leader is the 9800X3D at 129 FPS AVG, which is an incredible lead over the 7800X3D’s 111 FPS AVG.

The 12900K falls down to a cluster of Intel parts that cap-out around 100 FPS. The 265K is roughly equivalent to the 12900K in averages and lows. The 245K isn’t far behind. 

The 14900K boosts the ceiling to 110 FPS AVG, alongside the 13900K, 14700K, and 13700K that find a 10% higher ceiling. The 5700X3D has functionally identical performance to the 12900K. Anything on this list is a sidegrade for it other than a 9800X3D.

We feel the same about the 12700K: It wouldn’t be worth upgrading by this test alone.

The 12600K and 12400 show more age: Both are still great for framerate and completely playable, but at least a gap to the top is established. Moving to a 9800X3D would boost performance by 46% from the 12600K. An in-socket upgrade might be about 22% by moving to a 13700K. 

The 12100F is at 71 FPS AVG, which is also remarkably good for such a modern game. The lows are hurting a little more and sometimes get spiky, but overall, we’re impressed by how it has held on. Upgrading to a 13700K in-socket would be a huge upgrade from the 12100F. It would be economical, and might be worth considering.

Final Fantasy XIV: Dawntrail (1080p)

Final Fantasy 14: Dawntrail is a 2024 entry for us.

The Alder Lake series does OK here from an absolute standpoint, but is far down the charts in a relative sense.

The 12900K and 12700K are between the Ultra 7 265K -- which did horribly in this benchmark -- and the 13600K. The Ultra 200 Series is known to be regressive in this game, with Intel also showing the same behavior. The sad thing is that you’d be going backwards if you didn’t pay attention to benchmarks and bought a 265K. It wouldn’t be a crazy thing to do, either: It’s 3 so-called “generations” newer, yet worse than a 12700K and 12900K, at least in this test. The 12600K wouldn’t even see a huge uplift to it either.

The 13700K and 14700K offer large improvements around 15-18% from Alder Lake, though you’d need a good price to be worth the purchase. The 14900K boosts to 310 FPS AVG, an uplift of 26% over the 12900K.

AMD’s 9800X3D sets the ceiling at 373 FPS AVG, with all the other X3D parts right alongside it. 

Starfield

Starfield is up next. The 12900K hits 124 FPS AVG in our test here, which aligns it with the 13600K and 14600K CPUs, slightly bested by the 5800X3D (watch our review). This goes to show how good the 5800X3D was at launch, especially given the price gap when both the 12900K and 5800X3D were still regularly available new.

The 9800X3D shows room for a 36% improvement in performance from the 12900K. The 285K with ultra-fast, expensive memory in Gear 2 improves by 23% on the 12900K, but the like-for-like comparison has it at 15% ahead.

The 12700K is similar to a 245K -- you’d be downgrading overall by moving to it, aside from efficiency. The 5700X3D (read our review) is also nearby. Upgrading the 12700K to a 14900K would get you about 13% more performance and probably isn’t worth it overall.

The 12600K stands to gain more notably if upgraded in-socket to a 13700K, where it’d gain 26%. The 12400 could be worth considering an in-socket jump to a 14600K (watch our review) or 13700K as well, if cheap enough.

The 12100F is somehow still chugging along, sandwiched between AMD’s 3000-series parts and outperforming the R5 3600 and R7 2700 (watch our review).

Baldur’s Gate 3

Baldur’s Gate 3 used to have the X3D series all in the 120s, but the 9800X3D broke that in a massive way and hit 160 FPS AVG in our particular test case. We validated this in our 9800X3D review and explained why it’s happening.

X3D dominates the entire top quarter of this chart, followed next by the memory-boosted 285K. The prior generation 14900K, 13900K, and 13700K are all within error of each other. Don’t be confused by their ordering: Their performance is identical and within run-to-run variance, which is due to encountering a memory limitation. We can see this from the 285K (read our review) stock results versus the DDR5-8600 results.

The 12900K ran at 96 FPS AVG, or equal to the 265K. The 265K would be an expensive downgrade when looking at the total picture. The 12900K is still doing well enough here that it probably doesn’t make sense to replace except maybe with a 9800X3D.

The 12700K is about tied with a 245K. Like the 12900K, there aren’t many worthy upgrades here. A 13700K, 13900K (watch our review), or 14900K would give about a 15% uplift in our testing.

The 12600K and 12400 are at about 13600K levels of performance. An in-socket upgrade to a 13700K in this chart would yield about 28% improvement from these CPUs. The 12100F had trouble running this test. We might be able to force it to work, but natively, the low performance was bad enough that we consider it disqualifying in our test.

F1 24 - 1080p

F1 24 is up next.

The game scales from 163 FPS AVG up to 464 FPS AVG in our testing. The 12900K starts Alder Lake off down in the range of the i5 CPUs, including the 13600K and 14600K. Inspecting the data, we found that the 12900K had a more variable average FPS than some other CPUs, which we think is due to its core arrangement and Windows 2H24: The range was 310.5 FPS to 316 FPS AVG run-to-run, and upon inspection, it is due to the frametime pacing where we sometimes get a higher throughput with worse pacing and sometimes the opposite.

Overall, it ends up around 13600K levels. We saw this last round as well, just with an older Windows version. The 14900K has a 23% advantage on the 12900K. The 9800X3D runs 49% ahead of the 12900K.

The 12700KF is between the 5800X and 5600X, with the 245K just ahead. Intel’s 12600K lands at 270 FPS AVG, meaning a 13700K upgrade would boost the average by about 34%.

The 12100F still does great here, all things considered, and is just ahead of the 3700X.

Production Benchmarks

On to production benchmarks. For these tests, we’re looking at applications like Blender, Chromium code compile, and more. Users of the i7 and i9 CPUs are more likely to care about the performance here. It’s also one of Intel’s strong points of the past generations.

Blender

Blender 3D rendering is up first for production.

The 12900K did well here. It’s at 11.7 minutes required to complete a single-frame render of the GN intro animation, which has it about tied with the 12C/24T AMD R9 7900 non-X CPU. The 13700K does well with its higher frequency and equal core count to the 12900K. The 14900K has large gains here from moving to a 32-thread configuration, reducing the time required by 27% to 8.5 minutes. That’s about the same we see from the newer 265K, with the 285K doing well in one of its few strong tests and reducing time to 7.1 minutes. That has it at about the 9950X levels of performance.

If you were upgrading for gaming, the 9800X3D is the only option that might universally make sense against the 12900K. But for production, unfortunately, the options wouldn’t necessarily move the needle on gaming performance in a meaningful way despite offering large gains in workstation applications. You’d have to choose.

The 12700KF has the same core count as the 13600K, so the two perform about the same. An upgrade to the 14900K in-socket would be a huge 39% reduction in render time required.

The 12600K is at about levels of the 9600X. The 7800X3D (watch our review) outperforms it, but is better in gaming than production as compared to the non-3D parts like the 7700X. The 9800X3D would at least improve on the 12600K somewhat while giving a big boost to gaming.

As for the 12400 and 12100F, they’re near the bottom. The 12100F struggles with core count, so the 2600 is a little faster. The 12400 is roughly tied with the 3600.

Chromium

In Chromium code compile, the 12900K required 119 minutes to complete the compile. This has it closer to the R9 7900 non-X (watch our review) than anything else. The 13700K improves with its higher frequency and equal core count, with the 14900K giving a compile time reduction of 26% less time. The 285K is also a big step up, though not significantly different from the 14900K.

Intel’s 12600K might see enough benefit from an in-socket upgrade to a 14900K or 14700K (read our review) that it’d be worth considering, especially for the gaming uplift, but only if you’re trying to save on cost by reusing a board and DDR5 RAM. 

The 12100F required 382 minutes, which is still about an hour more time than the R7 2700 and about tied with the R5 2600.

7-Zip Compression

7-Zip compression testing makes the 12900K feel a little older, outperforming the 14600K by just 4.3% (and similar for the 9800X3D). In the very least, upgrading to a 9800X3D for gaming would at least net equal performance in this type of task.

The 14900K offers a 38% increase in MIPS over the 12900K, maybe making it worth considering.

A new build with a 9950X yields about a 46% uplift in this benchmark.

The 12700K is down near the 7700X (watch our review) and 9700X, with the 14700K 48% higher in MIPS.

If you have a 12600K and wanted to stay on Alder Lake, moving to the 12900K improves performance by 48% here, which is pretty massive. 

The 12400 is more similar to a 5600X or 3600, so anything would be an upgrade. The 12100F is at the bottom, falling behind the R5 2600 in a predictable way with its thread deficiency in this test.

7-Zip Decompression

7-Zip decompression shows a lot of scaling with cores, as indicated by the 9950X (read our review) and 7950X. The 12900K still does OK here and bests the 9800X3D on a technicality. The 265K offers an uplift that wouldn’t be worth buying into, with the 285K pushing 30% higher in MIPS to 193K. The 7900X (watch our review) and 13900K offer more meaningful uplifts though, with the 13900K and 14900K benefiting from higher thread count and opening opportunities for upgrades.

The 12700KF is at 245K levels of performance and about tied with a 5800X. The 12600K would see multiples of uplift with some of the newer options at the top of this chart, again including the 14900K and 13900K. The 12100F isn’t comparable to anything here, with the 12400 similar to an R5 2600.

Adobe Premiere

Adobe testing is next with the Puget Suite.

Back with the Alder Lake launch, we stuck with Intel for our Premiere editing systems since it was the best opportunity at that time.

Today, the part still does pretty well in Premiere. Actually, we still use its direct descendants in our main editing machines, including 13700Ks and various i9s. The 12900K scored 9948 points in aggregate, which has it between the 9800X3D and 7900X. The 14900K wouldn’t boost it much, only 11% here. The 285K scores a rare victory in this one, but again wouldn’t be a huge move if you’re already on a 12900K. It might make more sense for a new build.

The 12700KF could be kept relevant a little longer with a bump to a 14700K and still be a top scorer on the chart with modern memory. The same goes for the 12600K and 12400.

The 12100F at least outdoes the 2600, but that’s it.

Adobe Photoshop

Adobe Photoshop is last.

This one is a bloodbath compared to many years ago, with Adobe updates and AMD architecture changes benefiting AMD.

The 12900K is in the lower half of the chart and surrounded by i5 CPUs, with the 12600K near AMD’s 5800X. The 12100F at least does comparatively better here and outranks the R5 3600.

Overall, almost anything is an upgrade over Alder Lake in this test.

Conclusion

Wrapping things up, the 12th Gen CPUs are still pretty good. 

People commonly ask us when they should buy or wait. If you’re on a 12th Gen CPU, we’ll break it down like this: Ask yourself if you’re happy with your PC right now. If you’re not actively annoyed by your computer’s performance, then you can just keep using it. If, however, the performance is bad or you just want to build a PC because it’s fun, then there are options here. 

One of the options is for an in-socket upgrade, to which there are caveats, which we’ll discuss below. Another option is to build a new system.  

For the in-socket option, the 13th and 14th series would be potential drop-in upgrades. The lower down the stack 12th Gen CPU you have, like the 12400F (read our review) or 12600K, the more meaningful it would be to do this. 

For this to work, you need to make sure your motherboard with a 12th Gen CPU has the newer CPUs on its compatibility list. You should be able to find this on the manufacturer’s website. You would also need to update the BIOS. If you’re upgrading from something like a 12100F to a 13900K, you’d want to make sure that your board has a good enough VRM to handle the additional heat and power. Likewise, it’s ideally an unlocked board for more feature support.

We tested on DDR5 here with like-for-like memory between the platforms. You could have used DDR4 with 12th Gen also. DDR4 could be a limiting factor, so if you have to upgrade your RAM and motherboard, you may as well go with a fully new build from AMD instead (if building a gaming PC), like a 9800X3D or similar.

And finally, used CPUs might be a bit of a landmine situation, unfortunately. Intel’s 13th and 14th Gen woes are detailed in other stories we’ve published, but one potential problem is that used CPUs could have instability issues. You’ll want to be careful when buying used. This is unfortunate, because CPUs have historically been pretty bullet-proof -- especially Intel’s -- and have been a great used option to save a quick $100 on an in-socket upgrade.

The price of new 13th and 14th series have dropped in price, which makes something like a 13700K not a bad option, especially if you’re on a lower tier 12th series part. 

Overall, objectively speaking, Intel’s 12th CPUs (for the most part) are still great gaming parts. They’re not at the top of the charts anymore, but that’s OK.

We take an in-depth look into Intel’s new Reduced Load ILM by putting it under a laser scanner, specialized pressure scanning, and more

The Highlights

• Intel’s new Reduced Load ILM (RL-ILM) helps unbend its CPUs
• Despite offering improvements, the new and better ILM is optional
• The RL-ILM is an improvement in both the curvature of the IHS and substrate and of the temperature in our testing

Table of Contents

• AutoTOC

Intro

Intel is finally trying to unbend its CPUs, despite having to be on a bender to buy a $630 285K right now. Today, we’re using our laser scanner to look at the deflection in the CPU heat spreader from the different loading mechanisms, including these scans of the 285K (read our review) and 245K with different coolers installed. Today’s testing also includes specialized pressure scanning to produce pseudocolor images of pressure distribution across the IHS surface, very brief thermal testing to look at the differences with Noctua’s LBC (Low Base Convexity) flat coldplate, and we’ll look at the mechanical aspects.

Editor's note: This was originally published on November 4, 2024 as a video. This content has been adapted to written format for this article and is unchanged from the original publication.

Credits

Test Lead, Host, Writing

Steve Burke

Testing, Host

Mike Gaglione

Camera, Video Editing

Vitalii Makhnovets

3D animation, Camera

Andrew Coleman

Writing, Web Editing

Jimmy Thang

Unfortunately, Intel’s new and better ILM is optional. It didn’t force motherboard manufacturers to use it, so they can still cut corners if they want to save a few pennies. The new ILM is called the RL-ILM, or Reduced Load ILM, with the old one being referred to as the “Standard” ILM (indicating an assumption of it being the default). Our Z890 Hero ships with the RL-ILM, as do most high-end boards, so we used it as a test platform to swap to other official LGA-1851 ILMs for comparison.

Let’s get into it.

Differences

We’ll get some basic education in and go over the differences:

CPU sockets are one part mechanical and one part electrical. Intel uses what is called an Independent Loading Mechanism for its socket. Some people include the ILM when referring to the socket. On a technicality, the literal socket is the Land Grid Array with the carrier that actually holds the CPU. The loading mechanism is the mechanical part of the socket.

Intel is shipping 2 types of ILM, RL-ILM and Standard, and it is using at least 3 different suppliers that we’re aware of to manufacture these. Our Z890 Hero came with an RL-ILM by Lotes, which is a long-time supplier of ILMs. We also have the same-brand ILM of the Standard variant, plus the two other suppliers you’ll find on boards.

RL-ILM vs. Standard ILM

Here’s a CAD render of the socket. The standard ILM has an angle that increases the force application along the edges of the CPU. That’s the real difference here. This is what causes the depression we’ve seen in previous 3D laser scans we performed. These scans are from our past content: You can see how the ILM causes significant bending and forms a central concavity with the heat spreader, leading flatter cooler coldplates to be worse on Intel despite being better on AMD. You can learn more about that in our previous coverage here and here. 

Back to the CAD model, the RL-ILM is basically just flat. This is the biggest change, as the force should be reduced. This is also why Intel requires a higher force heatsink to be installed in order to ensure contact.

The RL-ILM also has one other difference: There’s an additional adhesive spacer on the underside, which can be thought of as similar to the washer mod that Noctua now ships with its NH-D15 G2 coolers as an option. The additional spacer goes underneath the existing black spacer, meaning that the ILM "leg" component probably was taken from existing Standard ILM stock, then retrofitted with effectively a sticker.

3D Animation

In our original Thermal Grizzly contact frame benchmark, we showed how the ILM clamp appeared to apply very slightly higher pressure to one side of the socket. This was exaggerated by the fact that the ILM has some play in it, where it can shift side-to-side and be repositioned and we saw that still happens on the RL-ILM. 

Here’s our 3D render of the standard ILM: With the CPU dropped into the socket, the standard ILM uses a hook that’s attached to the lever to centrally press down on the ILM lid that clamps directly to the CPU IHS. With the lever fully down and secured, the ILM is now secured at 3 points: 2 on the bottom of the ILM and 1 at the top. All of this is the same on the new RL-ILM. 

As for the CPU, the ILM has two wings that press down on the IHS at the borders, and with that curvature we showed in the CAD model, the force application at these points is high enough that a highly precise gauge can show how light is able to shine through despite the CPU being relatively flat when unclamped and looking flat to the eye.

We’ll refer you to our Thermal Grizzly Contact Frame benchmark from 2022 to learn more about this older style of ILM.

For the new version, clamping the CPU in the socket functions mechanically identically for the end user, with the lever pulling down to hook under a securing latch and clamp the ILM at 3 points, with 2 main contact points at the wings of the IHS. However, the lack of a bend in the ILM reduces the load. Intel still has to keep the force high enough that the CPU’s pads make contact with the socket pins, but has to be careful that it’s the right amount.

Too much or too little force can cause boot issues and high clock memory stability.

And that’s really it for these ILMs.

Pressure Scans

Noctua just got done spending literal years developing its new NH-D15 G2 and shipped it with 3 different coldplates, which makes it a unique candidate for pressure testing. 

For pressure testing, we take the different ILMs and apply a special pressure paper between the CPU and the coldplate. We then take that and scan it in with a specialized pressure scanner to create pseudocolor images of the pressure distribution.

Pressure Scan Noctua Results - HBC on RL-ILM vs. Standard

Here are the results for the two ILM types with the HBC cooler.

The new Reduced Load ILM with the high base convexity Noctua coldplate yielded low pressure at the outer edges, but especially toward the top of the board near the VRM and EPS12V cables. The pressure centrally remained high; however, because the CPU should be flatter with this ILM, the Noctua cooler ends up with less evenly distributed pressure because it’s designed for a different scenario.

The standard ILM with HBC cooler scans reinforce this: The HBC cooler ends up with more evenly distributed pressure at the top and bottom edges of the CPU IHS.

Pressure Scan Noctua Results - HBC, LBC, Standard

And here’s only the RL-ILM with the 3 Noctua cooler cold plates.

The RL-ILM pressure distribution was the most evenly distributed with the standard and LBC solutions. The two are mostly indistinguishable for distribution, although the precise pressure centrally will influence the results in thermal testing.

The LBC cooler had slight gaps at the left and right edges, but consistently square distribution at the top and bottom corners, with good pressure across the entire center. The standard cooler had less consistent pressure at the top and bottom edges and similar gaps to LBC at the edges. Ultimately though, these two basically look the same for contact.

Laser Scan: Noctua Coldplates

Our Noctua NH-D15 G2 review went into depth with laser scans of the cooler’s coldplates, and that hasn’t changed. We’re showing the LBC, Standard, and HBC scans again briefly here just to help recap the impact because when we’re looking at pressure and how it is affected by the ILM, the cold plate is a part of that equation. 

And now we’ll scan the new Intel CPUs to see how their shape matches the pressure scans we saw earlier. 

285K & 245K Unsocketed Laser Scan

Here’s a look at the plain Intel 285K when it’s just flat in the laser scanner. The CPU isn’t in a socket at all here, so this is as simple as it gets. Even in our 2D screenshots of the 3D scan, we can see the letters -- the CPU IHS is so flat that the very slight indentation for the text is visible.

The IHS itself has a few higher points, one just off-center, one along the right edge when oriented in a legible orientation, and one just off the left edge of the CPU.

Magnifying it 100x, that coloration grows to form just a few high points. Overall, it’s flat, but at high magnification, some small deviations appear. One thing that is clear though is that there is no substrate curvature, which makes sense since it hasn’t been socketed.

Let’s create a grid with the 285K and add the 245K to it. The 245K (read our review) follows a similar pattern: Centrally, it’s a little higher, then just off-center right it’s also slightly higher at 1x. Adding 100x to the grid, there’s a similar pattern as with the 285K.

Finally, we added our unsocketed 12900KS from the golden sample coldplate story. It’s still flat when unsocketed, but the difference in IHS design is also slightly showing through.

Socketed Testing

And now, we’re going to throw this Z890 Hero with the new ILM into the scanner and socket the CPUs in it. We obtained this package of ILMs to test. The ASUS board uses the Lotes RL-ILM, so we’ll start with that one.

Standard vs. Low Pressure Socket - 3D

Here’s a one-to-one 3D visualization in Blender taking STL files from our laser scanner, showing the 285K with the standard ILM first. As usual, 1x magnification doesn’t show much, but bringing that to 100x quickly shows a deep concavity centrally, just like we saw with LGA 1700 CPUs.

Switching over to the new reduced load socket, we can see that the 1x to 100x magnification shows less of a pronounced curvature of the IHS itself. It’s still curved, but much less, with the CPU maintaining a more consistent height instead.

Socket Comparison - Grid (285K)

Here’s a grid comparison of the different ILMs on the same motherboard, tested with the same CPU -- starting with the 285K.

You can see that the Standard ILM at 100x magnification shows a huge deflection centrally, as we’ve seen before, with higher pressure on the far ends of the mechanism. While we can sort of see the slight ridgeline down the middle of the CPU, the bigger issue is how deeply it indents.

The reduced load socket is significantly flatter, with less of a central deflection. The ridgeline in the CPU IHS becomes more pronounced in the graphic because it is more consistently the highest thing in the image. Remember that this is at 100x magnification, so the differences are exaggerated intentionally.

Socket Comparison - Grid (245K)

Unveiling the 245K results in the grid, we see the same patterns: The standard ILM deeply indents the CPU centrally, deflecting and deforming it in a way that coldplates with matching convexity will cool it the best. The reduced load socket is flatter and more consistent, though is still slightly deflected centrally.

Laser Scan: ASUS Cooler

We need a laser scan of the cooler coldplate before moving to the pressure maps, as the cooler and IHS alike contribute to the pressure distribution. 

This laser scan shows the coldplate of the ASUS Ryujin liquid cooler, which is what Intel sent with its CPUs to reviewers. Other coolers would fit, but we wanted to test what Intel officially endorsed.

At a 1x scale, the ASUS Ryujin coldplate looks relatively flat, but still shows a protrusion dead-center, gradually reducing height towards the outer edges. When we did our in-depth testing on Intel performance with varying custom-made coldplates from Scythe, we found that this pattern often did well for Intel.

Scaling it 100x, we get this almost comical tower protruding from the coldplate. This helps us see the steep slope as ASUS applies massive pressure dead-center with its coldplate design. This is sort of a hamfisted approach and version of what Noctua did more precisely with the D15 G2 for LGA 1700, except Noctua had more nuance in the exact shape of the convexity, which will better align with the concavity in LGA 1700 CPU heat spreaders previously. It’s similar to what we saw in the $60 Thermalright liquid cooler, which managed to brute force its way in performance thanks to similar protrusions.

Pressure Testing Results

Time to look at some pressure scans of the ASUS cooler with the new Intel ILMs.

These images show a new pressure scan of our 14900KF with the ASUS Ryujin cooler and the old (or “standard”) ILM. In this scan, you can see the 14900KF has narrowing pressure on the left and right sides, with most of its pressure centered. That’s where it should be, and most of that is thanks to the comically protruding ASUS coldplate, but fuller coverage is ideal. The older IHS also is a little bit different shape than the new one. The second column represents the pre-installed reduced load ILM using the 285K. Looking at the third column, adding the standard ILM with the 285K, doesn’t look too different. The pressure profile appears to be distributed taller and narrower. There’s still some of that slimming effect going on when we get to the left and right sides but not nearly as pronounced as with the last gen IHS design and ILM. 

Ultimately, what we see is that ASUS’ older brute force approach gets a better pressure distribution on the prior LGA 1700 socket than on the new ARL 285K socket, which is thanks to the massive central protrusion. This is the approach Thermalright took with its $50-$60 liquid coolers previously as well. It’s relatively hamfisted, but works, whereas the more carefully shaped approach of air coolers like the D15 G2 and the Scythe FUMA 3 are technically a better pressure match; now, that said, a 360mm liquid cooler is still “better” (with regard to capability) overall, and it will cool better, but the Ryujin could improve with more purposeful coldplate shaping.

Thermal Test Setup

Thermal testing is up now. Full transparency that we’re keeping this really simple this time, mostly because it doesn’t take much testing to verify if there’s a difference at all.

We’re only running the comparison thermals with one cooler this time. The ASUS cooler is so heavily deflected that we’re not sure the comparison would be that useful, so instead, we approached it with what should be a worst case scenario: The Noctua NH-D15 G2 LBC, or low base convexity, which is the flattest of Noctua’s options. In theory, this should be the worst on the more deflected standard ILM+IHS combination and the best on the flatter IHS from the RL-ILM.

Other coolers could have more or less impact. Coolers with higher force application centrally and with more convexity would continue to compensate for design problems of the standard ILM, but we want to just run a quick evaluation on one of the uncompensated scenarios.

We are also not testing anything below the minimum spec Intel declares for the socket, which is a 35 lb. force from the cooler. Anything high-end that’d be paired with the current CPUs will meet or exceed this requirement anyway.

Thermal Results

Here are the results from a simple A/B test. For this testing, we did two full mounts and at least 3 passes to average the numbers. This allowed us to check for variance mount-to-mount. All our other CPU cooler standards and methodologies apply, like manually spreading paste, controlling the fan speeds, and fixing the voltages and frequency. We disabled all power and thermal limits and set a fixed voltage with fixed frequencies. We have a known power draw down the EPS12V and 24-pin ATX12V through the 4 phases that it has (without PCIe slot power). That allows us to get these numbers.

The result was 61.8 degrees delta T over ambient for average P-core temperature with the standard ILM and 59.6 dT with the RL-ILM, or the improved one, meaning about a 2.2-degree reduction when accounting for  ambient. Without the deltas, we were running the 285K in the 80s to low 90s because we disabled all TVB 70-degree throttle controls. Running the CPU hotter allows us to see more of a gap between the results. A CPU consuming less power with a stronger cooler would likely not show as big a gap.

Checking briefly with Der8auer as a peer review, we learned our results are roughly in-line with his own. The differences are aligned with cooler and heat load differences.

We observed a slightly lower core-to-core delta with the new ILM, but it was within error. The AVG all-core temperatures were not significantly different from the P-core temperatures in this one due to the proximity of the P-cores to E-cores in this architecture (combined with our adjustments in BIOS). 

So, as short as possible, the RL-ILM is about 2.2 degrees better at this heat load with this cooler.

Tutorial to Remove and install the ILM

Before we move to the conclusion, in case you buy a motherboard with a standard ILM and want to move from the high pressure standard one to the low-pressure RL-ILM, we’ll walk you through how to do that. 

If you are going to swap the socket, we recommend sticking with the same brand for the replacement if possible. In our case, we used Lotes. 

To begin, we recommend starting with the CPU installed to protect the pins underneath to mitigate the risk of dropping, say, a loose screw down into the socket. 

From there, unscrew the 4 screws. We used a regular T20 Torx screwdriver. 

Removing the screws frees the top and bottom pieces of the socket. It also frees the backplate. When you’re installing the backplate, it’s important to get the orientation right and to ensure that the plastic sticker side is touching the bottom of the motherboard and not the exposed metal side. The backplate also features a notch that aligns with the triangle that’s on the corner of the CPU.   

We found that it’s easier to install the lever arm piece first with its 2 screws. Once that’s in place, it’s time to secure the other side with its 2 screws. You don’t need a lot of torque for the screws. We recommend that you tighten them in a star pattern to evenly distribute pressure.  

Conclusion

We regularly see people online saying that some cooler is 3 degrees lower than some other cooler, so just a reminder here on how all of this works: That 2.2 degrees is specifically at the power load we tested and with the cooler we used, under the conditions we employed. It will be higher or lower based on how these parameters change.

As an example, we did one round of tests with all the Intel throttle controls still enabled and saw less than 1-degree of difference -- but that’s because it was just throttling itself to regulate the temperature.

The new RL-ILM is definitely an objective improvement in both the curvature of the IHS and substrate and of the temperature in our brief testing. The pressure distribution depends on the cooler more than anything and it isn’t always clearly better, but the thermal result tells us that the net result is positive.

Frustratingly, this is optional. Intel is not at a stage where it should be making clear, simple, easy improvements “optional” for motherboard vendors. 

Although we don’t want Intel or AMD to force certain lock-downs, like taking away overclocking features, we do think both companies should enforce a default or baseline configuration that is in the best interests of the consumer, with the option for the consumer to tweak as their motherboard allows once exiting default settings.

In this situation, we do think Intel should just bite the bullet and force the better solution. It may be a situation where board partners had already purchased millions of these older mechanisms. Regardless, Intel has at least improved its mechanism. It is technically slightly more expensive than the original ILM, but since we’re talking pennies, we’d like to see this forced in the next generation as the standard ILM since it is just better. Intel needs to stop taking a soft-handed approach to its partners and taking the small victories when it can get them.

This doesn’t kill the contact frame market, though: That’ll still provide uplift, as the RL-ILM remains a mid-step improvement without going full flat like the prior contact frames we’ve tested.

That’s it for this one. We probably won’t do a ton of Arrow Lake follow-up testing since it doesn’t make any sense to buy right now, but we may explore a few other features.