Running large language models locally is becoming practical on systems with high-memory integrated GPUs, but GPU speed is only part of the equation.

Note: If you buy something from our links, we might earn a commission. See our disclosure statement.

For Ollama, llama.cpp, LM Studio, MLX and vLLM, shared or unified memory capacity, memory bandwidth, software support and the amount of RAM left after the operating system and background services can determine which models will actually run well.

This guide compares AMD Radeon 8065S and Radeon 8060S, Intel Arc B390, Radeon 890M, Apple M5 Max and M5 Ultra for local LLM inference.

It covers installed RAM versus usable model memory, AMD Variable Graphics Memory, unified memory, memory bandwidth, ROCm, OpenVINO, MLX, Vulkan, KV cache and Q4 model sizes from 8B and 14B through 32B, 70B, 120B, 200B and larger models.

A 128 GB system, for example, does not give the LLM a full 128 GB for model weights. Windows or macOS, applications, inference runtimes, KV cache, temporary buffers and free-memory headroom all consume part of that capacity.

The comparison therefore looks at practical model-weight budgets alongside headline RAM figures, helping you estimate whether a system is suited to a 32B coding model, a 70B assistant, a larger quantized model or long-context RAG and agent workloads.

Running Local LLMs with iGPUs | RAM, Bandwidth and Model Size Guide | Faceofit.com

FFaceofit.com

PC hardware, mobile tech and local AI comparisons

Local AI hardware guide

Running Local LLMs with iGPUs

For local LLMs, shared memory capacity and memory bandwidth often matter more than gaming performance. This guide compares Radeon 8065S, Radeon 8060S, Intel Arc B390, Radeon 890M, Apple M5 Max and M5 Ultra for Ollama, llama.cpp, LM Studio, MLX, vLLM and related local inference workloads.

Current to September 2026RAM and model-fit planningInteractive filters and chartsNo hard-coded pricing

September 2026 ranking

Best integrated GPU platforms for local LLMs

Unified or shared memory capacity, bandwidth and usable inference software are weighted more heavily than NPU TOPS.

Check compatible systems and processors on AmazonAffiliate search links. Availability, seller and configuration can change. No fixed product pricing is shown on this page.

Check Intel Arc B390 on Amazon Check Intel Core Ultra Series 3 on Amazon Check AMD Radeon 8060S on Amazon Check AMD Ryzen AI Max on Amazon

Highest capacityApple M5 Ultra512 GB

Up to 1.2 TB/s bandwidth. Suited to very large local open-weight models.

Windows and Linux large-model choiceRadeon 8065S192 GB

Ryzen AI Max+ PRO 495, up to 160 GB configurable graphics memory.

128 GB x86 choiceRadeon 8060S128 GB

Ryzen AI Max+ family with ROCm, Vulkan and llama.cpp routes.

Intel high-memory iGPUArc B39096 GB

Xe3 and XMX hardware with strong OpenVINO support.

Rank	Integrated GPU platform	Max memory	Memory bandwidth	Local LLM software	Best use
1	Apple M5 Ultra GPU	512 GB	1.2 TB/s	MLX, llama.cpp, LM Studio, Core AI	70B to very large models
2	Apple M5 Max GPU	128 GB	614 GB/s	MLX, llama.cpp, LM Studio	32B, 70B, 100B-class quantized
3	AMD Radeon 8065S, Ryzen AI Max+ PRO 495	192 GB	256-bit LPDDR5X-8533	ROCm 10, llama.cpp, vLLM, PyTorch	Large x86 local LLMs
4	AMD Radeon 8060S, Ryzen AI Max+ 395, 392, 388	128 GB	256 GB/s	ROCm 10, llama.cpp, vLLM, Vulkan	32B and 70B local LLMs
5	Intel Arc B390, Core Ultra X7 and X9 Series 3	96 GB	About 154 GB/s	OpenVINO, IPEX-LLM, Intel GPU runtimes	7B to 32B, some larger quantized models
6	AMD Radeon 890M	Usually 32 to 64 GB	Lower than 8060S	ROCm, Vulkan, llama.cpp	7B, 14B and some 32B
7	AMD Radeon 780M	System dependent	Lower	ROCm, Vulkan, llama.cpp	Small local models

Sources: AMD ROCm compatibility, Intel OpenVINO 2025.4, Apple M5 Max.

What matters for inference

Local LLM sizing starts with memory, not NPU TOPS

Ollama, llama.cpp, LM Studio, MLX and vLLM commonly use the GPU for inference. A large model first needs enough memory for weights, KV cache and runtime buffers.

LLM memory budget

Total RAM

minus

OS, apps, runtime, KV cache and buffers

minus safety headroom

CapacityCan the model fit?

Weights, KV cache, temporary tensors and runtime buffers all need memory.

BandwidthHow fast can weights move?

Token generation often moves large volumes of weights through memory.

SoftwareCan the backend use the GPU?

ROCm, Vulkan, MLX, OpenVINO and vendor runtimes determine the software path.

Platform details

Radeon 8065S, 8060S, Arc B390 and Apple Silicon

The attached Faceofit comparison identifies Arc B390 as a 12-Xe-core Xe3 iGPU and Radeon 8060S as a 40-CU RDNA 3.5 iGPU. The local-LLM comparison adds memory capacity, bandwidth and inference software.

AMD x86 high-memory tierRadeon 8065S, Ryzen AI Max+ PRO 495

40 RDNA 3.5 CUs
3.0 GHz GPU
192 GB unified LPDDR5X
256-bit LPDDR5X-8533
Up to 160 GB configurable graphics memory
ROCm 10 support

AMD product page

AMD 128 GB tierRadeon 8060S, Ryzen AI Max+ 395

40 RDNA 3.5 CUs
128 GB unified memory
256-bit LPDDR5X-8000
256 GB/s bandwidth
ROCm, Vulkan and llama.cpp routes
Up to 96 GB VGM on 128 GB systems

AMD product page

Intel client iGPUArc B390, Core Ultra X9 388H

12 Xe3 cores
122 INT8 GPU TOPS
2.5 GHz GPU
LPDDR5X-9600
Up to 96 GB system memory
OpenVINO and Intel GPU runtimes

Intel specifications

Apple 128 GB tierApple M5 Max

Up to 40 GPU cores
Neural Accelerators inside the GPU
128 GB unified memory
614 GB/s bandwidth
MLX, llama.cpp and LM Studio

Highest unified-memory tierApple M5 Ultra

Up to 80 GPU cores
Up to 512 GB unified memory
1.2 TB/s bandwidth
MLX and Core AI support

Observed Radeon 8060S inferenceQwen3.8-27B Q5

A supplied 2026 test reports about 16.5 generated tokens per second on Ryzen AI Max+ 395 using llama.cpp and Vulkan with a 128K context.

Benchmark repository

Installed RAM versus usable LLM RAM

How much memory is really available to model weights?

The operating system, browser, inference runtime, KV cache, working buffers and free-memory margin all consume RAM.

Platform	Installed memory	OS and normal services	Runtime, buffers and KV reserve	Practical model-weight budget	Good model class
Regular iGPU PC	32 GB	7 to 10 GB	5 to 8 GB	14 to 20 GB	7B, 14B
Regular iGPU PC	64 GB	8 to 12 GB	8 to 12 GB	40 to 48 GB	14B, 32B, some 70B Q4
Arc B390	96 GB	10 to 16 GB	10 to 18 GB	About 60 to 75 GB	32B, 70B Q4
Radeon 8060S	64 GB	12 to 16 GB CPU side	GPU allocation up to 48 GB	About 35 to 42 GB	27B or 32B, tight 70B Q4
Radeon 8060S	128 GB	About 32 GB remains CPU-side with max VGM	Up to 96 GB VGM	About 75 to 85 GB	70B comfortably, larger Q4 models
Radeon 8065S	192 GB	About 32 GB remains CPU-side with max allocation	Up to 160 GB graphics memory	About 135 to 150 GB	120B, 200B-class Q4
Apple M5 Max	128 GB unified	10 to 18 GB	8 to 20 GB	About 90 to 105 GB	70B, 100B or 120B Q4
Apple M5 Ultra	512 GB unified	16 to 24 GB	20 to 40 GB or more	About 440 to 470 GB	Very large models

Memory budget visual

B390, 96 GB

96 GB

8060S, 128 GB

128 GB

8065S, 192 GB

192 GB

M5 Max, 128 GB

128 GB

M5 Ultra, 512 GB

512 GB

Model weightsRuntime, KV and buffersOS and appsFree margin

These bars are planning visuals, not fixed firmware partitions.

Example, Radeon 8060S with 128 GB

Memory use	Approximate allocation
Windows 11, drivers and services	7 to 10 GB
Browser, LM Studio UI and background apps	3 to 6 GB
CPU-side inference and runtime needs	3 to 6 GB
Safety and free RAM	8 to 12 GB
CPU-side total reserved	About 21 to 34 GB
AMD VGM maximum	96 GB
Model weights	About 60 to 85 GB, depending on model
KV cache and buffers inside GPU pool	About 5 to 25 GB or more
Total system memory	128 GB

AMD VGM references: Ryzen AI Max local AI guide, AMD VGM FAQ.

Model size planning

How much memory do 8B, 32B, 70B and larger Q4 models need?

Quantized files include scales, metadata and block overhead. KV cache and runtime allocations sit on top of model weights.

Model size	Typical Q4-class model weights	Comfortable total accelerator memory
8B	About 4.5 to 5.5 GB	8 to 12 GB
14B	About 8 to 10 GB	14 to 18 GB
27B	About 15 to 18 GB	24 to 32 GB
32B	About 18 to 22 GB	28 to 36 GB
70B or 72B	About 39 to 45 GB	55 to 65 GB
100B	About 55 to 65 GB	70 to 85 GB
120B	About 68 to 80 GB	85 to 105 GB
200B	About 110 to 130 GB	135 to 160 GB
300B	About 165 GB or more	190 GB or more preferred

Practical platform fit by model tier

Platform

14B

32B

70B

100B

120B

200B

Radeon 890M 64 GB

Good

Tight

Arc B390 96 GB

Good

Tight

Radeon 8060S 128 GB

Good

Tight

M5 Max 128 GB

Good

Radeon 8065S 192 GB

Good

M5 Ultra 512 GB

Good

Fit labels assume Q4-class weights and reasonable headroom. Long context, VLM components, larger quantization formats or multiple concurrent models can move a platform into the next memory tier.

KV cache and context length

Long context can consume the headroom you thought you had

Model weights stay mostly fixed after load. KV cache grows with context length. A system that handles a 70B Q4 model at 8K context can become memory constrained at 128K or 256K.

8KChat and short tasks

Lower KV memory use.

32KLonger documents

More KV cache, but still manageable on high-memory systems.

128KCoding and RAG

Repository context and retrieved documents can consume several more GB.

256KHigh-memory workloads

Context memory can become a major part of total usage.

Coding assistants, RAG systems and tool-using agents deserve more RAM headroom than simple chat.

Interactive comparison

Switch between installed memory, model budget and bandwidth

Use the platform filters above to hide systems. Radeon 8065S bandwidth is charted at about 273 GB/s from the stated 256-bit LPDDR5X-8533 interface, only for this comparison chart.

RAM tiers for local LLMs

Choose the memory tier by the model class you expect to run

For coding assistants, RAG and agent workloads, moving one RAM tier above the bare model-file requirement gives more room for KV cache, runtime allocations and background services.

32 GB7B to 14B

Suitable for smaller quantized models.

64 GB14B to 32B

32B becomes practical. Some 70B Q4 configurations can fit with limited context room.

96 GB32B to 70B

This is the useful high-memory Arc B390 tier.

128 GB70B and larger Q4

Radeon 8060S can provide up to 96 GB VGM on a 128 GB system. M5 Max uses one unified pool.

192 GB100B to 200B

Radeon 8065S can dedicate up to 160 GB to graphics.

512 GBVery large models

M5 Ultra has enough unified memory for models beyond ordinary consumer GPU VRAM limits.

Desktop and laptop ranking from the supplied comparison

Desktop and workstation

Apple M5 Ultra, 256 or 512 GB
Ryzen AI Max+ PRO 495 with Radeon 8065S, 192 GB
Ryzen AI Max+ 395 with Radeon 8060S, 128 GB
Intel Arc B390, preferably 96 GB

Laptop

Apple M5 Max, 128 GB
Ryzen AI Max+ 395 with Radeon 8060S, 128 GB
Ryzen AI Max+ 392 with Radeon 8060S
Arc B390 with 64 or 96 GB
Radeon 890M systems

Template formats

Three ways to use this page

Pick the view that matches the decision you are making.

Format 1Model-first sizing

Start with the model-fit table, then choose a RAM tier that leaves room for KV cache and the OS.

Open model-fit view

Format 2Platform comparison

Start with memory, bandwidth and backend support when comparing B390, 8060S, 8065S and Apple Silicon.

Open platform view

Format 3RAM planning

Use the RAM-budget section when sizing a machine for coding, RAG or long-context inference.

Open RAM-budget view

FAQ

Local LLM questions about iGPUs and unified memory

Why does RAM capacity matter more than NPU TOPS for many local LLM tools?

Ollama, llama.cpp, LM Studio, MLX and vLLM commonly run model inference on the GPU. A large model first needs enough memory for weights, KV cache and runtime buffers.

Is 128 GB of system RAM the same as 128 GB available to a model?

No. The OS, apps, runtime, KV cache, working buffers and free-memory margin all consume RAM. On a 128 GB Radeon 8060S system with a 96 GB VGM setting, the supplied planning range puts comfortable model weights around 75 to 85 GB.

Can Radeon 8060S run a 70B Q4 model?

The supplied capacity estimates say yes on a 128 GB Max+ system. A 70B or 72B Q4 model is estimated around 39 to 45 GB of weights, with 55 to 65 GB of comfortable accelerator memory after adding runtime and context headroom.

Can Arc B390 with 96 GB run 70B?

The supplied planning range puts Arc B390 at about 60 to 75 GB of sensible model-weight budget on a 96 GB system. Capacity can be sufficient, but backend support, bandwidth and context length still affect the experience.

Why is M5 Max strong for local LLMs?

The supplied comparison lists 128 GB unified memory and 614 GB/s bandwidth. The CPU and GPU use one memory pool, and MLX gives Apple Silicon a direct local-inference path.

Why does long context need more RAM?

KV cache grows as context length increases. Large coding repositories, RAG documents and long chat histories can consume several GB or tens of GB beyond model weights.

What RAM tier should I buy for local coding assistants?

Choose one tier above the minimum model-file requirement when possible. Coding assistants can keep source files, retrieval results, tool output and long histories in context.

Does a 300B 4-bit capacity claim mean every 300B model will run comfortably?

No. Capacity claims do not guarantee fast interactive inference or large-context fit. Model architecture, quantization, KV cache, runtime buffers and available graphics allocation still matter.

Faceofit.com local AI note

Buy RAM and bandwidth for the model you plan to keep loaded

A large unified-memory iGPU can run models that exceed the VRAM capacity of many discrete consumer GPUs. Decode speed still depends heavily on memory bandwidth and software support. Model fit and model speed are separate questions.

Affiliate Disclosure: Faceofit.com is a participant in the Amazon Services LLC Associates Program. As an Amazon Associate we earn from qualifying purchases.