benchmarks

Gamers Nexus benchmarks GPU gaming performance on Linux using the Bazzite OS, an exploratory first step toward establishing a Linux testing methodology. It compares results against Windows and notes where Linux still falls short.

Gamers Nexus benchmarks the Ryzen 9 7950X in its BIOS Eco Mode presets (65W, 105W and stock 170W). It measures the performance cost against the power and heat savings.

Geekerwan's Chinese-language review of Intel's Lunar Lake lightweight laptop chip, covering performance, perf-per-watt curves and battery life benchmarks. It tests whether x86 can compete on efficiency.

Matthias Wandel tests old and new code on a range of PCs, including a new mini PC, to measure how much faster modern hardware really is. He also shows optimization techniques such as branchless code, with benchmark programs on GitHub.

Geekerwan reviews smartphone CPUs by power efficiency rather than benchmark scores, with test methodology and chapters on Qualcomm, Apple, Samsung and Google chips. It explains why high benchmark scores can coexist with heat and poor battery life.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.

2kliksphilip examines UserBenchmark, a hardware comparison site known for strongly biased, pro-Intel writing. The video explains the site's credibility problems and points viewers to better sources for CPU and GPU information.

Digital Foundry investigates why Resident Evil Village on PC runs worse with Capcom's Denuvo DRM than a cracked version. They benchmark and confirm performance and frame-pacing differences.

Linus Tech Tips compares Microsoft's Surface Pro X (SQ2) with the Apple M1 MacBook Air, focusing on how Windows on Arm and x86 emulation perform against Apple's Arm hardware. The verdict is that the Surface falls well short.

Casey Muratori shows how typical 'clean code' object-oriented patterns can cost large factors in performance. He benchmarks them against simpler data-oriented code.

Cathode Ray Dude's hour-long retrospective on the ABIT BP6, the dual-Celeron motherboard. He covers early multiprocessing, its legend, a build, running NT 4, benchmarks and the pros and cons of early SMP.

Linus Tech Tips benchmarks the prebuilt PCs from its second Secret Shopper series, shares final thoughts on each integrator and picks a winner. Dell ranked last.

Gamers Nexus criticizes ASUS over its handling of exploding Ryzen CPUs, overvolting BIOS settings and warranty and support behavior. It re-benchmarks the chips at defaults and argues ASUS eroded customer trust.

Robert Wills of TNMoC explains the Apollo Guidance Computer hardware and software, then walks through the Apollo 11 landing procedure step by step, including the 1202 alarms.

In Ars Technica's War Stories, Naughty Dog co-founder Andy Gavin explains how the team squeezed Crash Bandicoot onto the original PlayStation. They overwrote Sony library code in RAM, built custom animation compression, and streamed assets around slow seek times.

Casey Muratori's first refterm lecture lays out philosophies of optimization, distinguishing optimization from non-pessimization, which means avoiding needless work. It uses his fast terminal renderer project to show how fast computers really are.

Timothy Roscoe of ETH Zurich delivers the joint USENIX ATC/OSDI 2021 keynote arguing that operating systems must reckon with modern hardware, which is a heterogeneous collection of processors, firmware and coprocessors rather than a simple machine. It shows how much runs below and beside Linux.

Lex Fridman interviews legendary chip architect Jim Keller about Moore's Law, microprocessor design, and first-principles thinking. Keller draws on his work at AMD, Apple, Tesla and Intel, discussing instruction sets, transistor budgets, and self-driving.

Chuck Moore, inventor of Forth, presents GreenArrays' 144-core asynchronous chip at Strange Loop 2013. He explains how idle cores draw almost no power and how tight code minimizes energy use.

Casey Muratori's two-hour talk tracing the history of object-oriented programming back to the 1960s and examining how its ideas, and later entity component systems, came about. It is followed by a Q&A.

Casey Muratori shows how fast a terminal renderer can run, building a simple reference renderer that handles Unicode and colored text far quicker than Windows Terminal. He argues that common excuses for slow terminals do not hold up.

Kaze Emanuar explains how he rewrote and optimized the Super Mario 64 source code so it runs far faster on real N64 hardware. He covers performance bottlenecks and fixes in detail for his ROM hacks.

Casey Muratori's University of Twente guest lecture is a case study in how straightforward code can cut thousands of lines and tens of seconds of runtime down to a few dozen lines running in under a second. It uses concrete examples to show why software is often an order of magnitude slower than it should be.

Ben Eater explains how a USB keyboard communicates, covering the electrical interface, bit and packet encoding, packet contents, and a comparison with PS/2.

Overclocker der8auer tours Hetzner's Falkenstein data center in Germany, showing custom racks, own mainboards, passively cooled servers and ATX-style cases on shelves.

Bryan Cantrill of Oxide Computer Company gives a Stanford EE380 talk on rethinking the server. He argues that hyperscaler-style rack-scale machines with open firmware, RISC-V and Rust should be available to everyone, not just the giants.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

Veritasium explains why analog computing may suit AI workloads, covering old analog computers, The Analog Thing and Mythic's analog chips that use flash memory for neural network inference. It argues digital hardware is hitting limits.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

A 36-minute animated deep dive from Branch Education into how DRAM works. It shows how memory connects to the CPU and how billions of bits are stored in nanoscale capacitor cells. It also covers why DRAM sits between SSDs and the processor.

PS5 lead system architect Mark Cerny gives a deep dive into the PS5's architecture, covering its SSD, I/O, audio and design goals. He explains how removing bottlenecks shapes future games.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Khalil Estell's CppCon 2024 talk argues C++ exceptions can reduce binary size in firmware. He digs into how exceptions work and how to shrink their code footprint on embedded platforms.

Wes Bos breaks down the techniques behind the McMaster-Carr website's speed: server-rendered HTML, prefetching, CDN and service worker caching, preloading, critical CSS and fixed-size images. He also notes its old-school jQuery and YUI JavaScript.

A Gamers Nexus investigative documentary on the black market for Nvidia AI GPUs, following smugglers, middlemen, and buyers, including reporting from China. It examines how export-restricted chips reach their users.

Casey Muratori follows up his refterm proof-of-concept, a GPU-based terminal renderer, with a second part covering memory usage, glyph sizing and correct Unicode and VT handling. It is built to show that a terminal can be fast and correct without heroic effort.

Ian Cutress interviews chip architect Jim Keller about his time at AMD, Intel and elsewhere, management advice, design approach, Moore's Law and x86 versus Arm.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

Dave Plummer tours the IBM z16 mainframe from design through factory assembly, test lab, accelerators and water cooling. He explains why mainframes still exist and what makes them reliable.

A walkthrough of the Quake III fast inverse square root, explaining where the constant 0x5f3759df comes from. It covers IEEE 754 floats, the bit hack that approximates a logarithm, and a Newton's method refinement.