What kind of monster do you get when Microsoft assembles a computer? From PC building to data centers

Recently, many people have been discussing various hardware upgrade options. There's a lot of enthusiasm for talking about motherboard support for CPU overclocking, debating whether a graphics card or hard drive can handle a particular game, and exploring how to modify settings to break through existing performance limits, and so on.

Given that Windows 11 often ships with a large number of components that have little to do with gaming but consume significant resources, many users prefer to heavily customize various Windows settings. This has even led to the creation of community-driven gaming-focused Windows distributions, such as AtlasOS.

Most of these customizations focus on removing unnecessary components (e.g., printer services) and disabling non-essential security features (e.g., VBS). With so many unusual modifications, it feels like... Microsoft doesn't really care about gaming PCs? Is it possible that Microsoft itself doesn't have a clear grasp on PC assembly? What would happen if you asked a Microsoft employee to assemble a computer for you?

Building an Interesting Scenario

In a fictional scenario, there is a wealthy individual. He wants to acquire a deeply optimized gaming PC capable of running the majority of games.

He decides to seek Microsoft's services. Consequently, he invests one hundred million and assembles a team of 100 Microsoft principal engineers. He grants them one year to build a compact, powerful, meticulously refined, and flawless gaming device that is also affordable, capable of running his specified list of games.

So, after one year, what will he receive?

Here, one might attempt to think outside the box...

What kind of hardware?

It should be a small case

Desktops assembled by traditional manufacturers often feature a significant amount of empty internal space. This excess volume is highly undesirable for a device designed to be refined, compact, and efficient.

However, the traditional approach to assembling ITX form factor cases requires carefully selecting compatible cases and motherboards, which can often lead to thermal dead spots or cabling challenges.

In the case of deep customization, the motherboard, memory, graphics card, and storage drive are likely soldered onto a highly integrated circuit board. Microsoft might collaborate with AMD to customize a graphics card specifically optimized for this architecture, pair it with memory at precisely tuned frequencies, and include a storage drive that may not be a standard hard drive. This approach can significantly improve space utilization and reduce the overall size of the machine.

It should be performant enough

Note: Excellent hardware should be just sufficient to meet computational requirements, not the most powerful hardware available. This is especially true for custom optimizations tailored to proprietary scenarios: it only needs to handle the workload effectively; there is no need to use the best possible option.

In compact and refined devices, using the most powerful hardware may introduce additional power consumption and thermal management burdens, as well as increased costs. Obviously, the majority of gaming performance needs to be considered here. These experts are likely to specifically customize the hardware.

For example: if the device needs to support certain application management features based on Hypervisor, a CPU with strong Hypervisor support can be specifically selected. Conversely, if certain specific workloads, such as CUDA, are not required, they can be entirely removed. Hardware customization can fully serve the business scenario; when the business scenario is known, any unnecessary features can be completely eliminated.

Ultimately, everything in this machine should reflect one key principle: "just right." It does not have a single redundant resistor. All chips are exactly what is needed—capable of delivering performance in the target scenarios, yet precisely sufficient in performance.

Its power consumption should be very low

This is quite obvious. Since all unnecessary hardware has been stripped away, and every power-consuming component is already the minimal set optimized for the target, it is evident that its power consumption will be lower than almost all similar devices on the market. This is because other devices on the market find it difficult to select, customize, and trim components so precisely.

It will give you the feeling of a complete, integrated whole, rather than a hodgepodge of various hardware components.

In fact, this is also why, even when we buy branded computers today, we often find that the internal hardware is not the most powerful, and sometimes even belongs to an older generation. This is because they believe that the use case for these devices is business office work. They consider this to be just right for enterprise applications.

Its Heat Dissipation Should Be Just Right

Thermal management in traditional PC tuning is notoriously unpredictable and hard to visualize. It often relies on stacking a large number of fans, which frequently leads to either excessive or insufficient cooling: fans barely spinning while hardware remains hot, or fans running at full speed while hardware stays cool.

Since hardware customization has been deeply optimized down to every detail, thermal management should not pose a significant challenge.

After all, manufacturing processes have not yet broken through the limits of human chip fabrication. While the hardware used is customized, the most critical computing units have not been removed, making heat generation inevitable.

However, for machines with extreme customization, there is ample room for thermal optimization: during hardware design, engineers can carefully simulate airflow paths and even apply different fan speed curves under varying loads to achieve a perfect balance between noise and cooling.

Under this balance, cooling just barely allows the machine to perform at its best, and that performance just barely ensures the games being run maintain the monitor's frame rate while keeping the hardware healthy. Not a single fan rotation should be wasted.

One fewer rotation means falling one frame behind the monitor (just kidding 🐶).

A Deeply Customized System

Up to this point, it seems we have been stuck at: assembling a deeply customized and optimized ITX mini PC case.

However, all hardware optimization is only meaningful to the extent that it can just barely run the workloads inside. And the first workload you face is the operating system.

Traditional operating systems—whether Windows, Linux, or Mac OS—offer a wide range of configuration options and tuning headroom. Yet, these systems are designed for general-purpose computing across all possible scenarios, leaving ordinary users with very limited room for optimization. Moreover, many advanced tuning methods simply have no user-facing settings; they require modifying source code or even building a dedicated system distribution. For teams without sufficient resources, this can be completely out of reach.

This is why, even after installing Windows, you still need to manually install drivers and tweak settings: Windows itself has no way of knowing exactly what hardware you are running on.

From here on, our discussion will focus on system-level performance tuning, specifically tailored to our specialized hardware. As I mentioned, when optimizing for specialized hardware, you can push performance to the absolute peak.

This system should also exhibit a set of key characteristics, such as: consistently fast, highly secure, easy to use, and well-behaved applications. We can discuss these in detail.

This system should "feel fast"

Once we know the target use case for a device, optimization can be highly targeted.

For example: if you have determined that the device is a desktop unit that will most of the time be connected to a power source, then the "shutdown" function can be entirely replaced by "sleep." We can reduce power consumption to an extremely low level during sleep.

Computer sleep states are typically divided into multiple levels, such as S1, S2, and S3. In the S3 state, the computer powers down most devices, including the CPU, display, and hard disk drive, but continues to supply power to some devices and memory to allow for rapid restoration of the operating system and applications.

The characteristic of the S3 state is extremely low power consumption. Unplugging the power cord will not damage the hard drive, yet the device can still boot up in a very short amount of time. Since we know the use case, we can simply let sleep replace shutdown and wake replace boot, creating the illusion that this device turns on and off instantly.

This system should be very easy to use

Since this is an operating system designed for specific scenarios, most features can be stripped out, such as the traditional settings interface. We don't need to allow users to modify system settings at all, such as partitions, drivers, or manageability. We can simply remove the settings entirely. The only things we should leave are basic configurations like language, input method, time, and IP address.

We can directly enable automatic HDR and 10-bit color on compatible displays, automatically set the optimal resolution, and also enable variable resolution support.

Ultimately, what the user should experience is this: plug in the power cable, connect the video cable, press the power button, and the system instantly evaluates the supported features of the display, allowing it to drive the monitor in its optimal state.

How to run the application so perfectly?

Don't forget that for proprietary business scenario devices, such as gaming scenarios, no one cares about the system. In fact, people would prefer the system to be turned off while the application is running, so that all computing resources can be dedicated to the application.

After all, the purpose of such devices is to serve a single scenario. By abandoning general-purpose scenarios, application-oriented optimizations can be taken to the extreme!

When we build an ideal device, all developers will perform unique optimizations for that device, since I know exactly what kind of device it is.

The Pinnacle: I Know Exactly What This Device Is

Many of the approaches to developing applications on dedicated devices are fundamentally different from those used for general-purpose devices. This is built on a foundational assumption: we already know exactly what the device is. As a result, all considerations related to compatibility can be entirely discarded.

For example: for application developers, since the hardware's computational capabilities are already known, they can push it to its absolute limits. There is no need to provide users with complex display settings: resolution, DLSS, textures, rendering distance, lighting... The application developer should have already optimized the best image quality, keybindings, and other settings during the development phase.

During the use of the application, no cumbersome settings can be found. It will always run in its optimal state and provide the best experience, and furthermore... it will never crash.

Never Crashes: After All, Developers Are Developing on It

"Never crashes? Are you kidding me? A single null pointer in the code and it's all over!"

Almost every game crash is accompanied by inadequate testing. The difficulty of testing lies precisely in the vast array of diverse hardware configurations. You never know what bizarre results some peculiar piece of hardware might produce.

However, when performing targeted application optimization for proprietary hardware, the results on the developer's machine are guaranteed to be identical to those on the user's device. There is no room for excuses like, "It was working fine on my computer just a moment ago."

Testers only need to run the test once. If there are no issues, the version delivered to users is guaranteed to be free of problems. This is the advantage of computing on dedicated devices.

And this advantage can even evolve into cheating...

Cheating: I already know what you're going to do

In many scenarios, optimizing for proprietary hardware is a form of "cheating." This kind of cheating is not a bad thing; rather, it is a clever shortcut. After all, we already know exactly what you intend to do.

For example: In-game cutscenes are traditionally rendered in real-time to create grand, immersive scenes. This approach is adopted because games may run on a wide variety of unusual devices, and developers aim to keep file sizes as small as possible.

However, if we know for certain that the display aspect ratio is 16:9, we can simply pre-render a cinematic CG sequence for that specific device and play it back here. This allows users to enjoy a high-quality experience even on hardware with limited computational power.

For instance: If we know that the device will always be connected to the network during operation, we can save space by automatically starting to pre-download this video segment just before the player reaches this level, or by deleting the video segment after the level is completed. The potential for optimization is virtually limitless.

Worry-free

Traditional PC assembly involves a significant amount of physical labor, tuning, and background knowledge. Even after everything is fully assembled, users still face a complex array of challenges: progress synchronization, a multitude of launchers, and account management.

For professional gamers, this may be acceptable. However, for non-professional users, who might simply want to experience 100 major titles, the need to register numerous accounts and manage countless settings and launchers can be overwhelming.

However, when we reach a point where we can demand that developers optimize their games specifically for a platform, everything changes.

We can require them to adhere to fixed interaction logic. For example: WASD must always control player movement; the mouse must always control the camera view; player movement speed must be capped at 3 meters per second; the jump key must be bound to the spacebar; and the field of view must be set to 85 degrees. This ensures that the control feel across all games remains as consistent as possible without disrupting the standardized device experience.

It’s not just about game interactions. Applications can also fully utilize the system’s built-in integrated authentication to manage accounts. Furthermore, we can require developers to refrain from using third-party launchers or anti-cheat detectors. This standardizes application paradigms, truly delivering an experience where you can open any app and use it immediately, without worrying about anything.

Moreover, users can even enjoy a bonus benefit: no viruses, ever.

Anyway, I know who I need to run

A general-purpose computing platform can never achieve a goal of being completely free of viruses.

The operating system has no way of knowing whether you are intentionally running a peculiar application or accidentally launching one. The APIs called by a virus and those called by a regular application may be exactly the same (for example, reading a file); it is the malicious intent of the virus developer that defines the access as harmful.

Proprietary hardware devices, however, remain different. Since the device, the user, and the application developer all know exactly what the user intends to run, it is entirely feasible to enforce digital signature protection on application developers: simply block the execution of all applications except those developed by these specific developers.

Malicious developers will not appear on the whitelist, and this simple approach ensures that proprietary hardware is completely immune to viruses. The principle is: “After all, everyone knows exactly who the device is running.”

However, since “you already know exactly who you are running,” optimization can be taken to the ultimate extreme: virtualization.

Enjoy Virtualization

The biggest difference between a custom gaming PC and a standard home computer is that, in the use cases of a custom gaming PC, it is almost never the case that two games are run simultaneously. In contrast, running multiple applications at the same time is commonplace on a standard home computer.

So, why not simply eliminate the feature of running multiple applications simultaneously? We could just declare: This device can always only run one game at a time.

In this scenario, the game can exclusively occupy the entire hardware to achieve extremely high performance. However, users may still need to switch between multiple games... The simplest method, as the subheading suggests, is virtualization.

Run each game in a virtual machine? No. Unlike traditional virtualization, we are discussing dedicated custom hardware, where there is still significant room for optimization.

1. Use a Hypervisor

Use Hypervisor-based virtualization. Under the isolated computing power of the virtualization environment, only one game is run. This ensures that we do not launch multiple system kernels simultaneously, and only one system kernel is running (the container). This already avoids the biggest drawback of virtual machines: redundant execution of system kernels.

2. Pass through hardware

Hardware passthrough is already a basic feature of any Hypervisor: any hardware maps itself to a segment of memory address space. You only need to hand this address range directly to the Hypervisor, and the computing power inside can directly operate the real hardware without needing translation from the host system. Using a Hypervisor can yield performance identical to running directly on bare metal.

3. Store game progress in any location

As I mentioned, dedicated hardware can only run one game at a time. So, whichever game is being run, that game's Hypervisor is launched, and the graphics card is passed through to it. At this moment, the game enjoys a dedicated, complete, physical graphics card. After the graphics card finishes rendering, it sends the output directly to the display. The system has no opportunity to interfere with rendering, and performance may even be better than without virtualization.

But the biggest advantage is this: the Hypervisor can hibernate just like a virtual machine. In other words, it writes memory, VRAM, and other data directly to disk, so that any game you’re not currently playing occupies none of the critical computing resources at all. Exiting a game doesn’t mean killing the process; it means putting the Hypervisor into hibernation.

Opening a game takes almost 3 seconds to load. You double-click Need for Speed on your desktop, and three seconds later, you’re already driving.

Moreover, the game launch process doesn’t require the traditional steps of opening a launcher, loading, logging in, entering the game, loading again, and starting a quest.

This may be hard to imagine, but the result is: we trade a slightly slower game-switching speed for the guarantee that no matter how many applications you have open, the system will never lag, because only one application is ever actively running at any given time, while all others remain “paused.”

The hardware performance of such a device doesn’t need to be exceptional, yet the experience can still be excellent. Performance optimization on proprietary hardware can reach extraordinary heights, and every kind of technology can be leveraged. DMA is one example.

4. DMA

Similarly, the same point applies: performance optimization on proprietary hardware can reach extraordinary heights, and DMA is a prime example.

DMA allows peripherals (such as the GPU) to access system memory directly, without going through the CPU. In DMA mode, peripherals can read from and write to memory directly, thereby improving data transfer speed and overall system performance. For GPUs, using DMA technology enables them to read data directly from the hard drive and render it to the screen without CPU mediation, thus enhancing graphics processing efficiency. With DMA, a gaming device can truly achieve: texture data goes straight to the GPU.

What else can be optimized? Yes: the hard drive.

5. Hardware-accelerated virtualization of the hard drive

Don’t forget, we are using proprietary hardware, and the hard drive is also custom-designed.

Since the hard drive is custom, we can abandon the traditional hard drive approach! Just as DMA, mentioned above, can provide extremely high performance for GPU access to the hard drive, we can simply have the hard drive support dynamic partitioning at the hardware level, using technologies similar to mdev or SR-IOV, expose it to multiple PCIe devices, and then pass those PCIe devices directly through to the Hypervisor. This is truly peak-level optimization, but the result is:

The main system’s partition may be independent from the game’s, with each game residing in its own independent system partition. This partitioning is not traditional logical partitioning; rather, it is hardware-accelerated disk isolation. The isolated, independent virtual NVMe controller (which is a hardware component) is passed directly through to the Hypervisor, allowing the game to access only its own disk, and that disk contains only the game itself, with no system files.

In this design, although we use virtualization, we do not use any virtual hard disk (VHD) files. Instead, we pass the isolated physical disks directly through to the Hypervisor, allowing us to enjoy performance identical to that of physical disks. Combined with DMA, this load speed should be fast beyond my imagination.

Of course, the trade-off is that users will find it difficult to expand storage on their own.

Screen Recording and Live Streaming

The core concept introduced earlier is this: the defining characteristic of dedicated computing devices versus general-purpose computing devices is that optimization can be pushed to the extreme, but at the cost of limited use cases. Another excellent example is screen recording and live streaming.

The worst possible method for screen recording is likely taking continuous screenshots and then stitching them together into a video. This is why many people’s impression of screen recording remains stuck on the idea that it is extremely resource-intensive.

Clearly, modern general-purpose computing devices have long supported more reasonable approaches to screen recording: they can fully utilize the GPU to provide hardware acceleration for screen recording and live streaming, allowing the graphics card to directly handle the encoding and decoding of the output visuals. However, this obviously requires continuously writing the recorded content to the hard drive, which in turn consumes disk performance.

For dedicated hardware, the optimization here can be quite interesting: it can use a small, independent chip equipped with video encoding/decoding and storage capabilities. This chip can be manufactured as an HDMI middleware device that automatically intercepts all passing signals and records them into the chip’s internal storage. As a result, screen recording becomes completely independent from the operating system’s computational workload.

Obviously, you will have a million questions: What happens when the storage space is full?

Live streaming, of course, does not have this problem, as it does not need to consider disk storage at all.

In the specific use case of game screen recording, long-duration recordings are rare; instead, users are more likely to capture highlight moments or interesting clips. Under traditional general-purpose computing, it is difficult for users to predict when a highlight moment will occur, often resulting in missed recordings. Dedicated computing, however, works differently: it can record continuously, rotating through the chip’s internal storage space and automatically overwriting the oldest recorded content. This way, you can always access a video of what just happened.

In this circular recording mode, players can freely achieve pentakills, and every moment is securely recorded. You can review them anytime without consuming GPU compute power.

In fact, the "always-on recording" feature is already well-supported by many modern gaming graphics cards, and it no longer incurs the performance penalties associated with traditional disk-based recording. After all, during gameplay, the video encoding/decoding chip is likely idle.

Reviewing the Topic

Yeah, what was our original question again?

Imagine you are a wealthy individual who wants a deeply optimized gaming PC to play most games. You decide to ask Microsoft to provide this service. So, you invest 100 million, assemble 100 of Microsoft's lead engineers, give them one year, and require them to build a compact, powerful, refined, and flawless gaming device with a low unit price that can run your specified list of games.

It looks like we've essentially described such a device.

It's an ITX case, extremely compact with not a single bit of extra space. It features a powerful CPU and GPU, capable of meeting the requirements of almost all games. It has very low power consumption, lower than any other gaming PC on the market. It produces minimal noise, has a reasonable airflow design, and generates little heat. Most importantly, it is very user-friendly: 1-second boot time, automatic adaptation to various monitors. The system is deeply optimized and customized, runs very stably, and absolutely will not crash or suffer from viruses. You only need one account to log in to all games, without needing to download launchers. Applications will never freeze, and you can always see the highlights of your recent gaming sessions...

This device should be very expensive? Actually, once it goes into mass production, the cost per unit should be very low. And because it's durable enough that you can't break it no matter how you use it, it doesn't even depreciate much on the second-hand market... Perhaps one unit only costs a little over 3,000, while a gaming PC with similar performance might cost five figures.

Yeah, I think you already understand what I'm trying to describe.

This device now has a famous name:

Xbox.

Epilogue

I am constantly amazed by the design of the Xbox. Its optimization is truly clever and almost feels like "cheating," yet the user experience is exceptionally smooth. Every time I see this, I feel quite ashamed of my own tuning efforts, because no matter how much I optimize, the results only ever asymptotically approach what the Xbox achieves.

However, this also highlights an important point: optimization for dedicated hardware can reach an absolute pinnacle of perfection.

In the past, I often compared the performance of my self-installed nginx against professional appliances like F5 and A10, and I really couldn't compete. Their optimizations extend all the way down to the circuit level. To put it dramatically, not a single resistor is redundant. Many functions are likely implemented directly within the network card hardware.

The more you try to use a general-purpose computing platform for specialized tasks, the less cost-effective it becomes. It's like using public cloud resources for mining, which is a massive financial loss. Similarly, playing games on a desktop PC means spending five figures of money to achieve an experience that an Xbox delivers for just 2,000 RMB. After all, a desktop PC is essentially a general-purpose computing device: it can run anything, handle programming, allow system reinstalls, support gaming, and even be used for mining.

If you fix a specific use case, you'll find that the potential for optimization is immense. This is why many data centers still rely on bare metal servers to this day.

Despite all its drawbacks, large companies prefer to run their workloads on bare metal rather than virtual machines. The advantage of bare metal is that it is highly amenable to targeted optimization. As mentioned above, almost all virtualized computing platforms are general-purpose, and using them for specialized workloads is like using a home computer for gaming. The benefits usually lie in manageability, scalability, and some auxiliary features, but the drawbacks are poor cost-performance and limited optimization potential.

Bare metal servers can be equipped with specialized components like FPGAs to allow for custom optimizations tailored to specific business scenarios. You can remove certain hardware functions, such as the Hypervisor, and add others, such as SR-IOV and RDMA.

The most extreme example is mining: mining farms are often built right next to hydroelectric power plants in Sichuan. They have no cases; just a motherboard and a stack of GPUs, and they start mining. Clean room? Low noise? Cooling? Doesn't matter. This is the result of maximizing economic efficiency.