The hardware catalogue

All the tools read from one catalogue of desktop processors and graphics cards, plus the coolers, fans, cases and power supplies the simulator uses. Each processor and card carries the manufacturer's rated power (TDP for processors, total graphics power for cards), its core and thread count, its video memory and a relative performance index.

The performance index is an editorial scale maintained by hand to reflect published gaming and multi-threaded results; it is not the score of any single benchmark. The fastest current consumer card, the GeForce RTX 5090, sits at 12,000. It is good for statements like "about 20 % faster" and not for predicting a frame rate in a specific game, which depends on resolution, settings and the game itself.

The detailed specifications on the comparison pages — shader counts, memory bus width and speed, process node, release date — come from the TechPowerUp GPU and CPU database, and each page links the entry it used.

Power supply calculator

The calculator adds up what the machine draws under a realistic combined load and then sizes the supply above it:

  • System draw = graphics card rated power + processor rated power + 50 W for the motherboard, memory and storage.
  • Recommended supply = system draw × 1.25, rounded up to the next 100 W, and never below 650 W, because nothing sensible is sold below that.
  • Example: an RTX 5080 (360 W) with a Ryzen 7 9800X3D (120 W) draws 360 + 120 + 50 = 530 W. 530 × 1.25 = 662.5 W, which rounds up to a 700 W supply.

The 25 % margin is not padding for its own sake. A supply running near its ceiling sits in the least efficient and noisiest part of its curve, and modern graphics cards draw brief spikes well above their rating, which is what makes an otherwise adequate unit shut down mid-game. On the page for each graphics card, cards rated at 300 W or more carry a note about the 12V-2x6 (12VHPWR) connector, because using an adapter on those cards is where most reported connector failures start.

Where it can be wrong: rated power is not peak power. Overclocked parts, some high-end processors whose default limits allow well over their rated figure (an Intel Core i9-14900K is allowed 253 W), and machines with many drives or fans can all need more than the estimate. The pages for individual cards assume a mid-range processor drawing 105 W.

Bottleneck detector

The detector places the processor and the graphics card on the same performance index and measures the gap between them:

  • Difference = (card index − processor index) ÷ the larger of the two.
  • Within ±5 % the pair is reported as balanced. Otherwise the part with the lower index is reported as the limit, and the size of the gap sets the label: up to 15 % minor, up to 35 % moderate, above that severe.
  • Example: a Ryzen 5 5600 (index 4,900) with an RTX 4070 (6,300) gives (6,300 − 4,900) ÷ 6,300 = 22 %: a moderate processor limit.

Where it can be wrong: which part limits a game depends on the resolution, the settings and the game. At 4K the graphics card is almost always the limit, and at 1080p with a high-refresh monitor the processor often is. The detector compares the two parts on one scale, so use it as a first check rather than a verdict for a specific title.

LLM VRAM calculator

The memory a language model needs is the sum of three parts:

  • Weights = parameters × bits per weight ÷ 8. The quantization formats are counted at their effective size: Q8_0 at 8 bits, Q6_K at 6.5, Q5_K_M at 5.5, Q4_K_M at 4.5, Q3_K_M at 3.5 and Q2_K at 2.63. For a mixture-of-experts model this is the total parameter count, not the smaller "active" figure it is marketed by: only a couple of experts run per token, but all of them have to be in memory to be the one chosen. Llama 4 Scout activates 17B and fills a card like a 109B.
  • KV cache = 2 × context tokens × layers × KV heads × head dimension × 2 bytes. This is the part people forget, and the reason a model that fits at a short context stops fitting at a long one. Layer and head counts come from each model's published configuration, except where the architecture keeps no separate keys and values at all: DeepSeek V3 caches a single compressed vector per token, and its entry carries the head figures that reproduce that size.
  • Runtime overhead: a flat 0.5 GB.
  • Example: Llama 3.1 8B at Q4_K_M with an 8K context needs 4.2 GB of weights, 1.0 GB of cache and 0.5 GB of overhead — about 5.7 GB. Figures are in binary gigabytes (GiB), the unit graphics drivers report.

Where it can be wrong: runtimes differ. Some quantize the KV cache, which shrinks it; multimodal models and long system prompts add memory; and llama.cpp, Ollama and vLLM each reserve their own buffers. Leave a margin of a gigabyte or two on the card.

LLM inference speed

Generating tokens one at a time is limited mainly by how fast the model's weights can be read from memory, so the estimate is built on memory bandwidth:

  • Tokens per second ≈ memory bandwidth (GB/s) ÷ model size in memory (GB) × 0.75. The 0.75 factor accounts for the overhead real runtimes add to the theoretical ceiling.
  • Memory bandwidth = memory bus width × memory speed. An RTX 5090 has a 512-bit bus at 28 Gbps: 1,792 GB/s.
  • Model size = parameters × bytes per parameter for the chosen format: 2 bytes at FP16, 1 at 8-bit and 0.5 for the 4-bit formats.
  • Example: Llama 3.1 8B at 4-bit is about 4.0 GB. On an RTX 4070 (504 GB/s): 504 ÷ 4.0 × 0.75 ≈ 94 tokens per second. Prompt processing is shown at roughly ten times that, because it runs in parallel across the whole prompt.
  • The model is marked as fitting when it uses up to 85 % of the card's memory, tight up to 100 %, and overflowing above that.

Where it can be wrong: the estimate assumes one card, one request at a time and the whole model in video memory. Offloading layers to system memory slows generation sharply, and drivers, runtimes and batch sizes move real results in both directions.

Electricity cost calculator

  • Monthly cost = watts ÷ 1,000 × hours per day × 30 × price per kWh. The yearly figure uses 365 days.
  • Example: a 350 W machine used 4 hours a day at 0.20 per kWh uses 42 kWh a month and costs 8.40 a month, or about 102 a year.

The price per country is a reference residential average and is only a starting point: the price on your own bill is more accurate, and the calculator lets you type it in. The country is preselected from your browser's language and, when available, from an approximate location lookup — see the privacy policy.

Where it can be wrong: a PC rarely draws its full rated power for hours. Games load the parts unevenly, and a machine left idle draws far less, so enter the average draw you expect rather than the supply's label when you know it.

Compilation time estimator

Each language has a baseline time for a small (about 5,000 lines), medium (about 50,000) and large (about 500,000) clean build on a reference 6-core processor with an index of 5,000. The baselines are editorial estimates of typical builds, not measurements of a particular codebase. From there:

  • Speed factor = processor index ÷ 5,000.
  • Parallel boost = 1 + (cores ÷ 6 − 1) × the language's parallel factor, which runs from 0.05 for toolchains that barely use extra cores to 0.95 for ones that use nearly all of them.
  • Estimated time = baseline ÷ (speed factor × parallel boost).
  • Example: a medium Rust project (65 s baseline, parallel factor 0.7) on a Ryzen 7 9800X3D (index 9,200, 8 cores): 65 ÷ (1.84 × 1.23) ≈ 29 seconds.

Where it can be wrong: incremental builds, build caches, disk speed, memory and the build system itself often matter more than the processor. Treat the result as a way to compare processors, not as a prediction for your repository.

"Can it run" pages

These pages start from the only part that is a fact: the minimum and recommended hardware the publisher lists on the game's Steam store page, which each page links as its source.

  • The graphics cards named in those lists are placed on the performance index. When the publisher lists alternatives ("GTX 1060 or RX 580"), the weakest one sets the bar, because the publisher is saying any of them is enough. Older cards that are not in the catalogue are positioned by hand against their neighbours, and are used only for this.
  • A card below the minimum is reported as not meeting it. Above that, its index divided by the recommended card's index sets the settings tier: from 0.72 medium, from 1.0 high, from 1.4 ultra at 1080p, from 1.95 ultra at 1440p and from 2.9 ultra at 4K.
  • Video memory caps the result: ultra needs at least 8 GB, 1440p 10 GB and 4K 12 GB, and a card with less memory than the publisher asks for is held at medium.

No frame rates are printed, on purpose. Nobody benchmarked each card with each game, and a settings tier is the most the method can honestly support.

Comparison pages

  • The performance difference is expressed as a share of the slower part, which is how the question is usually asked: (faster index − slower index) ÷ slower index. An RTX 5080 (9,800) against an RTX 4080 (8,400) is about 17 % faster. Within 5 % the two are called even.
  • Only pairs someone could plausibly be choosing between get a page: parts within 35 % of each other, or the same tier one to three generations apart — the upgrade question.
  • Power figures are the manufacturer's ratings; the remaining specifications come from TechPowerUp.

PC building simulator

The simulator checks each part against the rest of the build as it is placed. It flags a processor on the wrong socket, memory of the wrong generation, a motherboard that does not fit the case, a graphics card or cooler too large for it, a radiator the case cannot mount, a cooler rated below the processor's TDP, a power supply that is too small or too close to its limit, a missing power cable, an SSD slower than its slot allows, and a case with no fans.

The temperatures it shows are estimates from the cooler's rated capacity, the case's airflow and the fan speed you set. They are there to show the direction a change pushes things, not to predict what a sensor would read.

Updates and corrections

The catalogue is updated when new parts launch and when better data for an existing part appears. If a result looks wrong, write to [email protected] with the page and the inputs you used; confirmed errors are fixed in the catalogue, which corrects every tool that reads it at once.