The Space Heater Benchmark: Which Open Models Will Heat Your Apartment Most Honestly?

SATIRE — In the interest of reproducible science, the Institute for Thermally Significant Compute has released the first Space Heater Benchmark for open models. Unlike cowardly benchmarks that obsess over code completion, math, or whether a model can identify a pelican in a low-resolution parking lot, this evaluation asks the question developers actually face at 2:13 a.m.: if I run this locally, will my laptop become a small but determined appliance?

The benchmark evaluates models across three dimensions: Fan Noise Per Token (FNPT), VRAM Requested With Personal Disappointment Included (VRAM-WPD), and Regret at First Kernel Panic (R1KP). Scores were collected under laboratory conditions: one developer apartment, two mugs of coffee, a power strip of uncertain provenance, and a closed issue titled “Performance optimization?” that had been open since 2021.

Methodology nobody asked to audit

Each contender was instructed to produce a Rust function that sorts a vector, explain the function, rewrite it in TypeScript, apologize for using TypeScript, and then summarize the apology in the style of a release note. The model ran until one of four conditions occurred: the answer completed; available VRAM became theoretical; the operating system displayed concern; or the test operator removed a hoodie because the room had reached “late July build pipeline” temperatures.

For fairness, every model received the same prompt, the same quantization argument the operator found on a forum, and the same passive-aggressive assurance that “this should fit easily on 8 GB.” Results are ranked from Mildly Domestic to Municipal Zoning Concern.

Tier 1: The Laptop Warmer

These smaller models are ideal for engineers who want local inference without making a conspicuous lifestyle change. They generate useful autocomplete, brief summaries, and enough heat to keep one hand comfortable while the other searches for a smaller model. Fan activity is audible but socially defensible. During testing, one system’s fans produced a tone corresponding approximately to an employee pretending not to be overwhelmed in a sprint planning meeting.

• Thermal profile: a pleasant desk-level breeze with occasional bursts of executive urgency.
• VRAM behavior: asks for a few gigabytes, then looks around for more “just in case.”
• Regret rating: low, unless you expected a 7-billion-parameter model to redesign your distributed systems architecture between keystrokes.

Tier 2: The Personal HVAC Pilot

Mid-sized models occupy the benchmark’s most competitive segment. They are large enough to make you feel sovereign and small enough that you can still describe the experiment as “running locally” without checking whether the machine is technically in the same postal code as you. Inference begins with optimism, transitions into fan noise, and concludes with a highly specific interest in memory bandwidth.

These models earned strong scores in the Room Temperature Delta category. One test machine raised the ambient temperature by three degrees Celsius, or roughly one full argument about whether the model was actually using the GPU. The answer to that argument remained unavailable because the desktop session had become a still-life painting of a spinning cursor.

• Thermal profile: the sound of a compact vacuum cleaner learning to reason.
• VRAM behavior: can fit, provided “fit” means closing every browser tab, chat client, music app, terminal, and perhaps a door to an adjacent room.
• Regret rating: moderate. You will learn a great deal about KV cache precisely when you least want to.

Tier 3: The Landlord Notification Event

The larger open models provide an experience often described as “frontier-adjacent,” mostly because the user spends so much time near the frontier of thermal throttling. These models do not merely run on a consumer laptop. They negotiate with it. They ask the GPU to search within itself for hidden reserves of courage. They treat unified memory as a philosophical claim rather than a physical limit.

In this tier, benchmark runs are measured not in tokens per second but in meaningful domestic milestones: Did the radiator activate? Did the cat leave the room? Did a neighbor ask whether you had started cryptocurrency mining again, despite your earnest explanation that no, this was worse: a coding assistant was deciding whether a variable name should be camelCase?

• Thermal profile: jet engine in a confidential meeting.
• VRAM behavior: reports a numerical requirement, then reveals it was merely opening negotiations.
• Regret rating: high but intellectually flattering. You will say “it almost worked” with the solemnity of a person describing a polar expedition.

Tier 4: The Model That Is Technically Local Because Earth Is Local

This category includes models whose recommended hardware configuration contains more nouns than the average developer workstation: server, rack, node, fabric, interconnect, chassis, facility, and “friend with access to a lab.” Running one on a laptop is less an inference strategy than a performance-art piece about ownership. The machine will attempt the load, report several numbers in scientific notation, and enter a meditative state from which it may not return.

The Space Heater Benchmark awarded these models the coveted Platinum Boilerplate badge. Not because they are bad models. Quite the opposite: they are excellent at generating a complete infrastructure plan explaining why you should not have attempted to run them on the device currently emitting a smell best described as warm library book.

How to improve your score

The Institute recommends several practical mitigations. First, lower the quantization until the model can no longer remember why it entered the sentence. Second, reduce context length, thereby converting your agent from a tireless collaborator into a very fast intern who has forgotten the first half of the meeting. Third, use a smaller model and call it “right-sized.” This is the official industry term for accepting physics after several hours of denial.

Developers seeking peak heating performance should instead maximize batch size, keep a 190-page repository in context, compile shaders during inference, and place the laptop on a blanket to ensure every available cooling pathway is converted into a learning opportunity. Do not do this. The benchmark is satire; the blanket remains tragically sincere.

The one result worth keeping

The Space Heater Benchmark cannot tell you which model is best, because it measures fan noise, memory hunger, and shame instead of capability. But it does preserve one useful observation: for local inference, model size, quantization, context length, available memory, and memory bandwidth materially shape the experience. Before choosing a model, check what your hardware can actually run comfortably—not just what it can be persuaded to load once.