HardwareFreaks

Tag: System Architecture

  • Cinder City becomes the first PC game to recommend 64GB of RAM, and at the worst time

    The world of PC gaming is undergoing a seismic shift. As games evolve from simple experiences into sprawling, photorealistic worlds, they demand increasingly greater processing power and memory. This trend pushes hardware requirements to new extremes, often leading to a frustrating paradox where standard gameplay seems to require cutting-edge components.

    Typically, when a game demands high fidelity, players expect top-tier graphics cards, like the latest high-end GPUs. However, in this new era of demanding software development, the requirements are becoming more nuanced and contradictory. Games are growing larger, more hardware-intensive, and sometimes, frustratingly, less optimized.

    But what happens when a game tries to navigate these shifting demands? Enter Cinder City, a title that throws a wrench into the usual expectations. While many modern games ask for powerful graphics cards to render stunning visuals, Cinder City sets itself apart by requiring surprisingly modest GPU power—just an RTX 4060 with 8GB of VRAM.

    The real kicker, however, isn’t the graphics card; it’s the memory requirement. Despite the relatively moderate visual demands, the game recommends a staggering 64GB of RAM. This massive memory ask immediately signals that the bottleneck for this experience is not necessarily the graphical processing, but rather the sheer scale and complexity of the game’s environment or data structure.

    This discrepancy forces gamers to consider what truly defines performance in modern gaming. It suggests that future system requirements will be less about maximizing GPU power alone and more about balancing complex memory management and system architecture. The focus shifts from pushing for the most expensive hardware to optimizing how that hardware utilizes available resources.

    The Cinder City example highlights a crucial point: game developers are starting to push against the traditional hardware-centric model. They are introducing demands that challenge established norms, hinting at an evolving landscape where system memory capacity may soon be as critical as raw graphical horsepower for delivering truly immersive experiences.

    Buy on Amazon

    Credit: TechSpot

  • ‘No bloat, no telemetry, no nonsense.’ Former Microsoft coding wizard makes an OG Notepad clone that’s just 2,686 bytes in size

    Featured image No bloat no telemetry no nonsense Former Microsoft coding wizard makes an OG Notepad clone thats just 2686 bytes in size

    In the world of software, sometimes the most frustrating upgrade is not a new feature, but needless bloat. Take something as ubiquitous as Windows Notepad—a simple text editor—and watch how it evolves over the years into a bloated application packed with features that often feel entirely unnecessary. For some users, this evolution has felt less like an improvement and more like Microsoft’s ongoing penchant for adding extra layers of complexity.

    One former Redmond coder, Dave Plummer, decided to fight back against this trend by turning his attention to the very structure of these applications. Leveraging his background in software exploitation, Plummer began exploring how the system itself could be manipulated to achieve radical efficiency.

    His goal was ambitious: to recreate a version of Notepad that was fundamentally lightweight—aiming for a size closer to the original 1977 Atari 2600 games, which were limited to just 2 kilobytes. The challenge wasn’t just minimizing code; it was figuring out how to strip away the heavy baggage while retaining functionality.

    Plummer’s resulting program was staggeringly small: just 2,686 bytes. This seemingly impossible feat was achieved not by cheating the system, but by understanding its architecture. The key lay in a brilliant trick: instead of replicating standard menu systems and graphical user interfaces that Windows already provides, Plummer used assembly code to simply instruct Windows to display them when needed. This meant standard text editor functions only consumed hundreds of bytes because they were calling upon the operating system’s existing capabilities.

    To finalize this ultra-lightweight executable, Plummer utilized specialized tools like Crinkler, a tool legendary in the demoscene for linking and compressing code efficiently. This allowed him to consolidate all the generated file objects into a cohesive, highly compressed program.

    This approach highlights a crucial modern dilemma: resource management. As we face the ongoing global memory crisis, developers—especially those in the gaming sector—are under immense pressure to reduce memory consumption and keep budgets tight. Finding ways to shave off every precious megabyte is no longer optional; it is a necessity.

    Plummer’s project serves as a compelling exercise for any developer looking to optimize code, but more importantly, it speaks to the enduring need for efficiency in all areas of technology. It proves that sometimes, the most effective way to tackle complexity is not to add more features, but to strip away the unnecessary and rely on the fundamental power already built into the operating system.

    Credit: PC Gamer

  • Geekom A9 Max 2026 Mini PC Review (Ryzen AI 9 HX 470)

    When a hardware company rolls out an update, we expect a noticeable leap in performance. For Geekom’s A9 Max Mini PC, the jump from the 2025 model to the 2026 iteration featured a slight evolution: the CPU was upgraded from the AMD Ryzen AI 9 HX 370 to the more capable HX 470. On paper, this upgrade suggested a modest performance boost—perhaps a 5% gain. We were ready for that little bump in speed.

    However, as we dug into the specifics of the new model, the narrative quickly shifted from hopeful anticipation to a puzzling reality. What was expected as a gentle acceleration turned into something far more complex, forcing us to look beneath the surface and uncover the real root cause of the performance discrepancy.

    The answer wasn’t found in the CPU clock speed or graphics card power; it lay hidden in the fundamental architecture of the system: the memory configuration. Despite both the 2025 and 2026 models shipping with 32GB of high-speed DDR5 5600 SODIMM memory, they were set up in dramatically different ways.

    The predecessor, the 2025 A9 Max, utilized a dual-channel configuration, meaning the memory sticks operated simultaneously for maximum throughput. This dual-channel setup provided a robust foundation for the system’s performance.

    In contrast, the new 2026 model appears to have opted for a less efficient single-channel configuration, utilizing just a single 32GB stick. While this still provides ample RAM capacity, operating in single-channel mode severely restricts the communication bandwidth between the CPU and the memory, which is critical for high-performance computing.

    This decision, made without clear specification on the product page, proved to be the biggest hurdle. In practical benchmarking, this shift caused performance to be significantly worse than anticipated, demonstrating that a slight increase in the CPU was entirely overshadowed by inefficient system design choices.

    The difference is stark: when designing modern systems, dual-channel memory is often non-negotiable for maximizing potential. Geekom’s choice to move away from this setup fundamentally hampered what could have been an exciting upgrade, suggesting that while the underlying hardware remains highly competent, system architecture plays a far more crucial role than advertised.

    Other details remain consistent with the 2025 model, including the sleek chassis and efficient thermal management. Yet, this deep dive reveals that for potential buyers seeking maximum performance from their Mini PC, the architectural decisions governing memory access must be scrutinized alongside the component upgrades.

    Ultimately, the story of the Geekom A9 Max 2026 is less about incremental CPU gains and more about the subtle but profound impact of system configuration on real-world results. It serves as a sharp reminder that sometimes, what appears to be a minor specification change can hide a much larger performance shift.

    Credit: KitGuru