What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Choose the model and workload first, then size the workstation around memory, performance, software support and sustained power. For most developers, that means a single GeForce RTX GPU with enough VRAM for the quantized model, 64GB of system RAM and a 2–4TB NVMe SSD. Larger models or long contexts may require an RTX PRO card, two GPUs, or a system with unified memory. Capacity figures are planning bands rather than guarantees: quantization, context length, batch size, runtime overhead, drivers and thermals all change what will actually run.
The practical buying order is model and context target → inference backend and operating system → VRAM or unified-memory requirement → system RAM → PCIe, storage, power and cooling → benchmark on your real workload. Starting with a fashionable GPU and checking compatibility later is the fastest way to buy an expensive workstation that cannot load the model you need.
As an Amazon Associate I earn from qualifying purchases.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →What should you decide before buying hardware?
Define the model, context length, users and response-speed target before comparing workstations. A model used interactively by one developer has very different requirements from a server handling concurrent requests or a fine-tuning pipeline.
Specify the model and format
Write down the exact model family, parameter count, quantization or precision, maximum context window and runtime. A 70B model in a 4-bit format does not have the same memory footprint as the same model in 8-bit or full precision. The runtime also needs memory for the key-value cache, temporary tensors, tokenizer, libraries and operating-system overhead.
#1 Best Overall
- High-Performance AI Processor: The MS-02 Ultra features an Intel Core Ultra 9 285HX (24C/24T, up to 5.5 GHz, 13 TOPS NPU), delivering fast and efficient performance for AI inference, algorithm development, and media workloads. A PCIe x16 expansion slot supports desktop-class GPU upgrades for advanced model training and accelerated computing tasks, suitable for creators, engineers, and teams handling intensive parallel workloads
- Expandable Memory and Storage Configuration: Four DDR5 SODIMM slots support up to 256 GB of memory, while ECC helps maintain data integrity in mission-critical environments. Four PCIe 4.0 M.2 slots support up to 24 TB of storage, supporting RAID 0/1/5/10, combining high-speed performance with data protection. It allows for the creation of independent scratch disks, media libraries, and project drives, providing high-throughput for production workflows
- Advanced PCIe and USB Connectivity: Up to three PCIe slots can be equipped, including a dual-slot x16 GPU. The main slot supports PCIe 5.0, meeting the needs of high-bandwidth creative and computing workloads. USB 4.0 v2 (80Gbps) supports high-bandwidth external storage and displays
- Ultra-fast Networking Capabilities: Wi-Fi 7 further enhances wireless performance with next-generation speeds and low-latency stability. Intelligent bandwidth switching optimizes throughput in different network environments, ensuring optimal performance for enterprise or local networks. Dual 25GbE ports (providing up to approximately 3.125 GB/s bandwidth, about 25 times faster than traditional 1GbE), enabling seamless large-scale file transfers and parallel computing. 10GbE and 2.5GbE ports, with support for Intel vPro technology, ensure enterprise-grade remote management and deployment flexibility
- Server-grade Thermal Architecture: Utilizing a dedicated CPU/GPU airflow design, equipped with a 6-pipe dual-fan cooler, it maintains stable performance even under sustained loads, delivering up to 140W Turbo power while maintaining a 100W TDP, and operating with noise levels as low as 36 dB. An integrated 350W power supply ensures stable and reliable output for demanding computing tasks and fully loaded extended configurations
Describe the workload
- Interactive inference: one person, short prompts and a premium on low latency.
- Long-context work: document analysis, coding repositories or retrieval workloads where the KV cache grows substantially.
- Batch inference: many prompts processed together; throughput and total memory matter more than first-token latency.
- Fine-tuning or training: gradients, optimizer states and activations can require several times the memory needed for inference.
- Multimodal or image generation: the model may have separate vision, diffusion or video components with their own memory demands.
NVIDIA’s local-AI guidance starts with “Determine the target VRAM and performance requirements.” Treat that as a sizing rule, not a suggestion to shop by GPU name.
Choose the software path early
List the inference backend, model format, operating system and driver branch you intend to use. NVIDIA’s backend guidance notes that developers must consider hardware, model types, invocation method, operating system, supported GPU architecture, memory requirements, API and optimization path before choosing a deployment route. A card that looks ideal on paper can be unusable if the backend lacks support for its architecture or the required quantization.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsFor example, Ollama documents NVIDIA compute-capability and driver requirements and allows GPU selection with the CUDA_VISIBLE_DEVICES environment variable. Confirm those requirements for the exact operating system and release you will install rather than assuming that a newer card automatically works with every packaged runtime.
How much VRAM or unified memory do you need?
VRAM is usually the first hard limit. The model weights, KV cache and runtime must fit in the memory available to the backend; if they do not, the software may offload part of the workload to system RAM or fail to load it. Offloading can work for experimentation, but it normally reduces performance and makes latency less predictable.
NVIDIA’s capacity bands
NVIDIA’s Developer guidance (accessed October 26, 2026) gives these broad planning bands:
| Platform family | Memory cited by NVIDIA | Model-size band cited by NVIDIA | How to interpret it |
|---|---|---|---|
| GeForce RTX | Up to 32GB VRAM | Models up to 50B | Consumer workstations for quantized models and development; verify the exact card and runtime. |
| RTX PRO | Up to 96GB VRAM | Models up to 150B | Higher-memory professional configurations for workloads that exceed consumer capacity or need professional drivers and certification. |
| DGX Spark | Up to 128GB unified memory | Models up to 200B per device | Compact unified-memory systems; check application support, operating system, availability and upgrade limits for the exact model. |
These are vendor guidance bands, not promises that every model in the stated range will run. Quantization level, context length, batch size, multimodal components and backend overhead can move a workload outside the band. A model that barely fits may still be impractical if it leaves no room for a long conversation or concurrent requests.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Allow headroom instead of targeting the exact weight size
Estimate memory for the complete runtime, then leave room for the largest context and batch you will actually use. If a model’s weights consume nearly all available VRAM, expect one or more of these compromises: a shorter context, a smaller batch, CPU offload, lower throughput or an out-of-memory error. Headroom also protects you when a driver, library or model revision changes temporary allocations.
When is unified memory useful?
Unified memory lets the CPU and accelerator address a shared pool rather than dividing the model between discrete VRAM and system RAM. That can make a large model easier to load in a small footprint, but it is not automatically equivalent to the bandwidth of dedicated GPU memory. Verify the operating system, supported applications, memory bandwidth, upgrade ceiling and cooling of the exact unified-memory system before treating its capacity as a performance guarantee.
Is 32GB or 64GB of system RAM enough?
Thirty-two gigabytes can be workable for a small single-GPU development machine, but 64GB is the more comfortable baseline for local AI development because the operating system, containers, editor, browser, datasets and model runtime all compete for memory. Larger models, CPU offload and multi-GPU systems need more.
Use the GPU plan to set RAM
NVIDIA’s Certified Systems guidance recommends at least 2× total GPU memory in system memory for inference servers. This is a capacity guideline, not a requirement that every desktop must follow exactly. It becomes especially relevant when the backend uses CPU offload, memory-mapped weights, multiple workers or large datasets.
NVIDIA’s dual-GPU consumer reference calls 64GB a minimum and 128GB best for demanding builds. For a pair of cards with a large combined VRAM pool, 128GB leaves room for the operating system and data while reducing the chance that a model spills into swap.
Signs that RAM, not VRAM, is the bottleneck
- The model loads only when other applications are closed.
- System memory remains near full and the operating system starts paging to disk.
- CPU offload causes long pauses even though the GPUs are not fully occupied.
- Two models or several workers cannot stay resident at the same time.
Choose matched memory modules supported by the motherboard and leave empty slots or capacity for a later upgrade when the platform permits it. Do not count swap space as a substitute for physical RAM.
Should you buy one big GPU or two smaller GPUs?
One large GPU is usually simpler and more predictable. Two GPUs can provide more aggregate memory and throughput, but only when the backend can distribute the model efficiently and the motherboard, power supply and cooling are designed for the pair.
| Decision factor | One high-memory GPU | Two GPUs |
|---|---|---|
| Usable memory | One contiguous pool; easiest for models that must fit on one device. | Potentially larger aggregate pool, but partitioning and backend support are required. |
| Setup complexity | Lower: one driver target, one thermal zone and fewer cables. | Higher: topology, slot spacing, power connectors, airflow and device selection all matter. |
| Performance consistency | Generally easier to benchmark and keep cool. | Varies with model parallelism, communication overhead, PCIe bandwidth and card balance. |
| Upgrade path | Replace the card later; the existing card may have resale value. | Add capacity only if the board, PSU and cooling were sized for a second card. |
| Noise and power | Lower total draw in many builds. | Higher draw, heat and fan noise; chassis ventilation becomes a design constraint. |
When a single GPU is the better choice
Choose one card when your target model fits within its VRAM with practical context headroom, you value easy software setup, or the workstation will sit on a desk where noise and heat matter. A single card also avoids cross-device communication for every layer split.
When two GPUs make sense
Consider two cards when no single card offers enough memory at an acceptable cost, when your backend supports tensor or pipeline parallelism, or when you need higher throughput for several users. Confirm that the two cards have compatible memory sizes and architecture support; mixed cards can force the workload to behave like the smaller or slower device.
What PCIe layout does a dual-GPU workstation need?
Use a motherboard with balanced root ports and enough lanes for both cards. NVIDIA’s multi-GPU reference favors x8/x8 PCIe Gen 5 for two GPUs; a board that electrically runs the second slot at a much lower link can limit transfers and reduce scaling.
Check lane sharing before installing drives
Motherboard manuals often show that an M.2 slot shares lanes with a full-length PCIe slot. Populating that M.2 connector can drop a GPU slot’s link width or disable it. Read the block diagram and test the negotiated link speed after assembly rather than relying on the slot’s physical length.
Measure physical clearance
- Count the card’s slot thickness, not just its length.
- Leave an intake path between cards; two adjacent open-air coolers can recirculate hot air.
- Check front radiator, drive-cage and side-panel clearance.
- Use a chassis whose top and bottom slots align with the motherboard’s spacing.
PCIe bandwidth is only one part of multi-GPU scaling. The backend’s communication pattern, model partitioning and synchronization overhead can matter more than the nominal link speed.
Recommended Free Tools
How much storage should a local-AI workstation have?
Keep active model files on fast local NVMe storage. Loading from a network share or a slow secondary disk adds startup time and can create contention when several workers read weights simultaneously.
Capacity recommendations
For a single-GPU developer workstation, a 2–4TB NVMe SSD gives room for the operating system, tools, several model variants, caches and datasets. Puget Systems recommends 2–8TB NVMe for LLM servers. NVIDIA’s dual-GPU reference specifies a single 4TB-or-larger PCIe Gen 5 NVMe drive.
Rank #2
- EVOLUTION RYZEN AI MAX+ 395 MINI PC - GMKtec EVO-X2 is the next evolution in AI mini PC Ryzen Strix Halo series. Thanks to AMD Simultaneous Multithreading (SMT) the core-count is effectively doubled, to 32 threads. Ryzen AI Max+ 395 has 64 MB of L3 cache and can boost up to 5.1 GHz, depending on the workload. The Ryzen AI Max+ 395 is currently rated as the "most powerful x86 APU" on the market for AI computing.
- AI NPU with XDNA 2 ARCHITECTURE - Powered by 16 “Zen 5” CPU cores, 50+ peak AI TOPS XDNA 2 NPU and a truly massive integrated GPU driven by 40 AMD RDNA 3.5 CUs, the Ryzen AI MAX+ 395 is a transformative upgrade and delivers a significant performance boost over the competition. The Ryzen AI Max+ 395 excels in consumer AI workloads like the llama.cpp-powered application: LM Studio. Shaping up to be the must-have app for client LLM workloads, LM Studio allows users to locally run the latest language model without any technical knowledge required and unleash their creativity and productivity.
- AMD RADEON 8090S iGPU GAMING PC - The AMD Radeon RX 8060S offers all 40 CUs with up to 2.9 GHz graphics clock and uses the new RDNA 3.5 architecture. The powerful iGPU is positioned between an RTX 4060 and 4070 laptop GPU and therefore enables gaming in FHD at maximum details in most demanding games. The 8060S can also utilize the full 128GB pool, which is perfect for running LLMs such as Deepseek 70B Q8, which runs comfortably on this machine.
- EIGHT CHANNEL LPDDR5X - LPDDR5X is a new ground breaking memory small form factor installed on-board. With blazing speeds up to to 8000MT/s, it runs 1.5x faster than the DDR5 SODIMMs; 90% better performance over DDR5 SODIMMs in video conferencing and photo editing; 30% better performance in productivity apps; 12% better performance in digital content workloads.
- QUAD SCREEN 8K DISPLAY SUPPORT - EVO-X2 AI Mini PC support 4-screen 4K/8K output via HDMI 2.1 (8K@60Hz), DisplayPort 1.4 (4K@60Hz), and dual USB 4 40Gbps Transfer speed (supporting PD3.0/DP1.4/DATA). Ideal for gaming, video editing, and multitasking, it provides expansive and crisp multi-display support.
Those figures describe capacity and placement, not a guarantee of model speed. Keep free space for filesystem overhead and temporary downloads, and back up irreplaceable datasets separately. A second drive can isolate scratch data from the active model library, but avoid disabling a GPU’s PCIe lanes to obtain it.
What power supply and cooling do local-AI GPUs require?
Size the power supply for sustained accelerator load, not the graphics card’s gaming average. Add the CPU, pumps, fans, drives and transient headroom, then verify the connector and chassis requirements.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchReference power figures
NVIDIA’s dual-GPU playbook specifies 1200–1400W for dual RTX 5080 configurations and 1800W or more for dual RTX 5090 configurations, depending on the exact cards and system design. It also states that a single RTX 5090 can draw up to 575W under load. These are reference values; check the board manufacturer’s rated power and the rest of your component list.
Use the correct connectors
Give each GPU a dedicated 12V-2×6 cable and use a power supply compliant with CEM 5.1, as specified in NVIDIA’s reference build. Do not daisy-chain high-power connectors or leave a plug partially seated. Route cables without sharp bends at the connector and confirm that the side panel does not press on them.
Plan for sustained heat
Local inference can keep the GPUs busy for minutes or hours. Provide front-to-back airflow, a CPU cooler rated for the chosen processor and enough exhaust capacity for the combined heat. Watch temperatures, clock speeds and power limits during a long run; a short benchmark can hide thermal throttling that appears after the system reaches equilibrium.
Which workstation configuration pattern fits your workload?
Use these patterns as starting points, then validate the exact model, backend and parts list. They are not substitute specifications for a particular card or prebuilt system.
Mainstream single-GPU developer workstation
- GeForce RTX card sized to the target model’s VRAM requirement.
- 64GB system RAM for comfortable development.
- 2–4TB NVMe SSD.
- Power supply matched to the exact GPU and CPU.
- One-card chassis airflow and a motherboard with a straightforward upgrade path.
This is the simplest route for one user running quantized models, coding tools and local services.
High-memory single-GPU workstation
- RTX PRO or another professional card when consumer VRAM is insufficient.
- System RAM sized to the total GPU memory and offload plan.
- Professional drivers or certification when your application requires them.
- Storage and cooling sized for long-running jobs.
Verify the actual card’s memory, architecture and software support. A product-family label does not tell you whether a specific model format or backend is supported.
Dual-GPU local-AI workstation
- Motherboard with x8/x8 or x16/x16 PCIe Gen 5 capability and balanced root ports.
- 128GB RAM for demanding work; 64GB is NVIDIA’s stated minimum for its dual-GPU consumer reference.
- 4TB-or-larger NVMe, preferably PCIe Gen 5 in the reference design.
- 1200–1800W-class power supply selected for the exact cards.
- Two dedicated 12V-2×6 cables, correct slot spacing and a chassis designed for the heat.
- Manual verification that M.2 population does not steal GPU lanes.
Unified-memory small-form-factor system
NVIDIA positions its Spark systems, including DGX Spark, as compact options with up to 128GB of unified memory. They can simplify memory capacity and footprint, but confirm operating-system support, application compatibility, upgrade limits, cooling and availability for the exact configuration before buying.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How do you compare two viable workstations?
Score both systems against the workload rather than comparing isolated specifications. The following checklist keeps the decision tied to outcomes.
| Axis | Question to answer |
|---|---|
| Total usable memory | Can the complete model, context, runtime and batch fit without unacceptable offload? |
| Model and context headroom | What remains after loading the weights for longer prompts or multiple requests? |
| Single- versus multi-GPU complexity | Will the backend distribute work efficiently, and can you maintain the topology? |
| Tokens per second | What does the target model produce on your prompt lengths, batch size and context? |
| Software compatibility | Are the operating system, drivers, architecture, quantization and API supported? |
| Upgrade path | Can you add RAM, storage or a second GPU without replacing the platform? |
| Power and noise | Can the room, circuit and chassis handle sustained load? |
| Physical constraints | Do slot spacing, connector bends and radiator or drive placement work? |
| Storage | Is there enough fast local capacity for active models and datasets? |
| Total cost | Have you included the motherboard, PSU, cooling, RAM and storage needed to make the GPU usable? |
How should you benchmark before committing?
There is no universal tokens-per-second figure for a workstation. Throughput changes with model architecture, quantization, context length, batch size, backend, drivers and thermals, so benchmark the exact workload.
- Freeze the test case. Record the model file, quantization, prompt length, expected output length, context window and concurrency.
- Use the intended backend and driver. Do not compare one card with an optimized runtime against another using a different software stack.
- Test cold and warm starts. Measure model-load time, first-token latency and steady-state generation after the card reaches operating temperature.
- Test realistic context. Include the longest prompt and document set you expect; a short prompt can hide KV-cache pressure.
- Test concurrency. Run the number of simultaneous users or jobs you actually need and record memory use, queueing and errors.
- Repeat after sustained load. Monitor GPU temperature, clocks, power, VRAM and system RAM for at least a long enough run to expose throttling or paging.
- Record the configuration. Save driver version, backend version, operating system, PCIe link status and power limits so a later result is comparable.
For NVIDIA-backed runtimes, use the documented CUDA_VISIBLE_DEVICES setting to expose a specific GPU or pair during a controlled comparison. Keep the variable and device order in your benchmark notes.
What commonly goes wrong, and how do you recover?
Most failed builds are caused by a mismatch between the model plan and the platform, not by a defective GPU.
The model does not load
- Check available VRAM or unified memory after the operating system and runtime start.
- Reduce context or batch size temporarily to confirm that capacity is the issue.
- Use a smaller quantization only if its quality is acceptable.
- Verify that the backend supports the model format and GPU architecture.
The second GPU is missing or slow
- Read the motherboard lane-sharing diagram and inspect the negotiated PCIe link width.
- Confirm both cards receive separate power cables and are fully seated.
- Check that the backend sees both devices and supports multi-GPU partitioning.
- Improve spacing and airflow if clocks fall under sustained load.
Generation becomes extremely slow
- Look for CPU offload, swap activity or a nearly full memory pool.
- Check thermals and clock throttling after several minutes, not just at startup.
- Compare a single-GPU run with a multi-GPU run; communication overhead can erase the expected gain.
- Move active model files from network or slow storage to local NVMe.
The system shuts down under load
- Recalculate sustained and transient power for the exact cards and CPU.
- Inspect 12V-2×6 seating and cable routing.
- Check PSU compliance, wall-circuit capacity and thermal protection logs.
- Do not solve an undersized PSU by lowering software limits until the electrical design is safe.
What is the practical buying sequence?
Follow this order to avoid paying for capacity you cannot use.
Free tools Windows power users keep installed
One-click scans. No signup required.
- Name the target model and format. Include context, batch and concurrency.
- Set a memory floor. Add model weights, KV-cache needs and runtime headroom; decide whether discrete VRAM or unified memory is appropriate.
- Select the backend and operating system. Check architecture, driver, API and quantization support before choosing a card.
- Choose one GPU or multiple GPUs. Prefer one card when it fits comfortably; use two only when the backend and platform justify the complexity.
- Size system RAM. Use 64GB as a comfortable single-GPU development baseline, 128GB for demanding dual-GPU work, and the 2× total-GPU-memory rule as a server planning check.
- Design the platform. Verify PCIe lanes, M.2 sharing, slot spacing, connectors, chassis airflow and CPU cooling.
- Add local NVMe capacity. Plan 2–4TB for a developer machine, 2–8TB for an LLM server, or 4TB or more in NVIDIA’s dual-GPU reference configuration.
- Size power and cooling. Use the exact card specifications and include sustained-load headroom.
- Benchmark the finished configuration. Measure the target model under realistic context and concurrency before declaring the workstation ready.
Frequently Asked Questions
Can I run a 70B model on a 32GB graphics card?
A 70B model is outside NVIDIA’s cited GeForce planning band of models up to 50B, so a 32GB card should not be treated as a dependable 70B solution. Whether a heavily quantized 70B variant can load depends on its exact memory footprint, context and backend; expect compromises or consider a higher-memory or multi-device design.
Does adding a second GPU double local-LLM speed?
No. Scaling depends on how the backend partitions layers, how often devices communicate, PCIe bandwidth, card balance and the prompt and batch shape. Benchmark the exact model; two cards can provide capacity without delivering twice the tokens per second.
Is unified memory the same as having 128GB of VRAM?
No. Unified memory describes a shared addressable pool, while dedicated VRAM has its own bandwidth and latency characteristics. A unified-memory system may load a larger model in a compact chassis, but application support and memory bandwidth determine practical performance.
Should model files live on a separate SSD from the operating system?
A separate NVMe drive can reduce contention for model-heavy servers, but it is not mandatory for a single-user workstation. The important point is keeping active models on fast local storage and preserving enough free capacity for caches, temporary files and additional quantizations.
Can I use CPU RAM as overflow when VRAM is full?
Many runtimes support partial CPU offload, but transfer overhead usually increases latency and lowers throughput. Treat offload as a deliberate fallback for testing or capacity, not as an equivalent replacement for sufficient GPU memory.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
