Dedicated vs Shared GPU Memory: What Task Manager Shows and Why It Slows Rendering
What the two Task Manager numbers mean and what they tell you about a heavy scene:
- What Task Manager shows: Dedicated GPU memory is the VRAM on the graphics card. Shared GPU memory is system RAM the GPU may borrow, capped at half of physical memory (Microsoft).
- Why renders slow down: data that spills into shared GPU memory is read over PCIe. A PCIe 4.0 x16 link moves about 31.5 GB/s each way, against 1,792 GB/s of VRAM bandwidth on an RTX 5090 (our calculation from published specs).
- What to check: Dedicated GPU memory sitting at its limit while Shared GPU memory climbs during a render. Several GPUs do not add VRAM for one scene: each card needs its own copy.
- On iRender: 1x to 8x RTX 4090 (24 GB) or RTX 5090 (32 GB) servers with 256 GB ECC RAM, so you can open the scene and watch both counters before the final render.
Open Task Manager, click your graphics card, and you see two memory numbers: Dedicated GPU memory and Shared GPU memory. For gaming they rarely matter. For GPU rendering they often explain why a heavy scene that rendered fine yesterday now crawls, or stops with an out-of-memory error.
This guide explains what each number means according to Microsoft, how much shared GPU memory Windows allows, why spilling into it costs so much speed, how Cycles, Octane, Redshift and Karma XPU react when VRAM runs out, and how to decide where to render a scene that no longer fits.
Checked against Microsoft, NVIDIA, Blender, OTOY, Maxon and SideFX documentation, November 2026.
What dedicated and shared GPU memory mean in Task Manager
Microsoft’s DirectX team splits video memory in Task Manager into two categories. Dedicated memory is memory reserved for the GPU alone and managed by the Windows video memory manager (VidMm). On a discrete graphics card such as an RTX 4090 or RTX 5090, dedicated memory is the VRAM on the card. On an integrated GPU it is a slice of system RAM set aside for graphics, and many integrated GPUs reserve none at all.
Shared memory is ordinary system RAM that both the CPU and the GPU can use, and it moves between them as the workload changes. Discrete and integrated GPUs both use it. The GPU memory line is the sum of the two, and a small amount reserved by the driver appears separately as Hardware Reserved Memory.
The Performance tab shows what is used right now across all processes. The Details tab can also show Dedicated GPU memory and Shared GPU memory per process: right-click a column header and choose Select columns. Those per-process figures add up to more than the real total, because memory shared between processes is counted once for every process that uses it. That is why dwm.exe can look much bigger than it is.
| Task Manager line | What it is | What it tells a 3D artist |
|---|---|---|
| Dedicated GPU memory | VRAM on a discrete card; reserved RAM on some integrated GPUs | How full the card is with your scene, the viewport and other apps |
| Shared GPU memory | System RAM the GPU is allowed to borrow | Whether data has overflowed out of VRAM |
| GPU memory | Dedicated plus shared | The total the GPU can address, not the size of your VRAM |
| Hardware Reserved Memory | A small amount reserved by the driver | Normally nothing to act on |
Source: Microsoft DirectX Developer Blog, GPUs in the Task Manager.
How much shared GPU memory Windows allows
Windows has a policy that the GPU may use at most half of physical memory at any instant. Microsoft’s own example is a 16 GB system, where the GPU can use up to 8 GB of system RAM at once. This is a ceiling, not a reservation: until the GPU needs it, that RAM stays available to other programs, and VidMm releases pages of idle surfaces over time. Video memory on Windows is also virtualized, so an application can allocate more than the ceiling, up to the system commit limit (installed RAM plus the page file).
| Installed system RAM | Shared GPU memory ceiling |
|---|---|
| 16 GB | 8 GB |
| 32 GB | 16 GB |
| 64 GB | 32 GB |
| 128 GB | 64 GB |
| 256 GB (iRender servers) | 128 GB |
Our calculation from Microsoft’s half-of-physical-memory policy. The ceiling says how much RAM the GPU may borrow, not how fast it can read it.
A large Shared GPU memory figure does not mean the card has more VRAM. A 24 GB graphics card in a PC with 64 GB of RAM shows 24 GB dedicated and 32 GB shared, and the scene still has 24 GB of fast memory to work in.
Why rendering slows down when VRAM spills into shared memory
VRAM sits on the graphics card, right next to the GPU. Shared GPU memory sits on the motherboard, so every read crosses the PCIe link. The two paths are very different in bandwidth. Published specifications give the RTX 4090 1,008 GB/s and the RTX 5090 1,792 GB/s of memory bandwidth. PCIe 4.0 runs at 16 GT/s per lane; an x16 slot delivers about 63 GB/s counting both directions after encoding overhead, so roughly 31.5 GB/s each way (Rambus).
How to read the figure. The top half is the graphics card: the GPU reads its own VRAM, which Task Manager calls dedicated GPU memory, at up to 1,792 GB/s on an RTX 5090. The bottom half is the motherboard: anything that spilled out of VRAM sits in system RAM as shared GPU memory and has to cross the PCIe 4.0 x16 link at about 31.5 GB/s each way. The width of the two paths is the point of the figure: the same texture is far slower to reach once it leaves the card.
In short: a texture or mesh that stays in VRAM is read at up to 1,792 GB/s on an RTX 5090, while the same data in shared GPU memory arrives over PCIe at about 31.5 GB/s each way on a PCIe 4.0 x16 slot.
| GPU on a PCIe 4.0 x16 link | VRAM bandwidth | Link to system RAM (each way) | VRAM vs link |
|---|---|---|---|
| RTX 4090 (24 GB) | 1,008 GB/s | about 31.5 GB/s | about 32 times |
| RTX 5090 (32 GB) | 1,792 GB/s | about 31.5 GB/s | about 57 times |
Our calculation from published peak figures; not a speed test. How much a render slows down depends on what spilled and how often the renderer reads it.
Microsoft’s Direct3D 12 documentation says the Windows kernel can move memory on discrete GPUs from video memory to system memory only as an extreme last resort, and warns that the wrong resource sitting in system memory can severely hurt performance. Render engines see the same effect. Blender’s Cycles developers put textures read from system RAM at roughly 20–30% slower, and other scene data that spills out at much slower than that.
NVIDIA added a second layer on Windows. Since driver 536.40, the NVIDIA driver can let CUDA applications fall back to system memory when VRAM is full, instead of stopping with an out-of-memory error. The behaviour is set by CUDA – Sysmem Fallback Policy in NVIDIA Control Panel > Manage 3D Settings, globally or per program, with the options Driver Default, Prefer Sysmem Fallback and Prefer No Sysmem Fallback. SideFX developers point to the same mechanism when OptiX memory spills over to system RAM on Windows. The fallback keeps a render running, but it runs at PCIe speed for the data that no longer fits.
How each render engine handles a scene bigger than VRAM
Windows and the NVIDIA driver decide where memory can go, but each render engine decides what to do when the scene does not fit. This is what the developers document:
| Render engine | When the scene does not fit in VRAM | What to watch |
|---|---|---|
| Cycles (CUDA / OptiX) | Uses system RAM automatically and leaves at least half of RAM for other software. Textures outside VRAM cost roughly 20–30% speed; other scene data costs more. | Each GPU can only use its own memory, so a second card adds speed, not room. |
| OctaneRender | With Enable Out of Core Textures/Geometry turned on in the Out of Core tab, Octane keeps assets that no longer fit in system RAM. Out-of-core memory is shared between GPUs. | The RAM Usage Limit you set is taken away from Windows and other apps; leave enough for the system. |
| Redshift | Goes out of core for geometry and textures and keeps rendering, more slowly. VDB volumes and irradiance cache / point cloud data cannot go out of core and stop the render with an error if VRAM is short. | In the Redshift log, a PCIe-transferred amount larger than the cache size means the frame went out of core. |
| Karma XPU | Uses every compatible device, each GPU with its own memory. If a GPU fails, for example by running out of VRAM, the remaining devices, including the CPU, carry on. | The render can slow down sharply without an error; KARMA_XPU_DISABLE_EMBREE_DEVICE=1 turns off the CPU device so a GPU failure shows up. |
Sources: Blender Manual, GPU Rendering; OTOY, Out of Core Tab (Cinema 4D); Maxon, Managing VRAM issues with Redshift; SideFX, Karma XPU.
Two Maxon sources describe Redshift on several GPUs differently. Maxon’s support article states that Redshift does not combine the VRAM when using multiple GPUs, while its 3D rendering product page lists multi-GPU memory pooling and says Redshift shares out-of-core memory across cards. This article follows the support article: plan for every GPU holding the scene in its own VRAM, and check Maxon’s latest documentation for your Redshift version.
The practical rule is the same for all four engines: more GPUs make a frame render faster, but the largest scene you can keep fully in VRAM is set by one card. Eight RTX 5090s still give you 32 GB per scene, not 256 GB.
How to read the figure. Each of the four boxes is one RTX 5090 holding its own full copy of the scene. The middle row shows why more GPUs help: all four render, so frames finish faster. The right column shows what does not change: the largest scene that fits is still 32 GB, set by one card. If your scene does not fit on one card, adding GPUs does not fix it; reducing the scene or using a card with more VRAM does.
How to check whether your render is using shared GPU memory
- Open Task Manager > Performance > GPU and select the card that renders. On a multi-GPU machine each GPU has its own page.
- Note Dedicated GPU memory before you open the scene. Windows, the 3D app viewport, browsers and video players also use VRAM, and Task Manager counts all of it.
- Render the heaviest frame at final settings and watch both graphs. Dedicated GPU memory pinned at the card’s limit while Shared GPU memory climbs means the scene is overflowing into system RAM.
- Open the Details tab and add the Dedicated GPU memory and Shared GPU memory columns to see which process is using it.
- Read the engine’s own report. Redshift writes GPU memory statistics to its log; Octane shows device memory usage; Cycles shows memory use in the render window.
- Optional test: set CUDA – Sysmem Fallback Policy to Prefer No Sysmem Fallback for your renderer’s program. If the render now stops with an out-of-memory error, the scene did not fit. Set it back afterwards if you prefer a slow finish to a stopped render.
How to read the figure. The left pair of graphs is a scene that fits: dedicated memory rises and levels off below the card limit, shared memory stays flat. The right pair is a heavier scene on the same card: dedicated memory is pinned at the limit and shared memory keeps climbing. If your own Task Manager looks like the right pair during a render, the scene is spilling into system RAM, and that is the first thing to fix when renders slow down.
Ways to bring a scene back under your VRAM
- Close other GPU apps while rendering. Dedicated GPU memory is counted across all processes, so a browser or second 3D app takes room from the render.
- Lower texture resolution where the camera cannot see detail. In Blender, Render Properties > Simplify has a Texture Limit. Maxon’s own advice for Redshift is to use 4K textures instead of 16K where possible, especially with UDIMs.
- Use instances for repeated objects instead of full copies, so the mesh is stored once.
- Turn on out-of-core on purpose in Octane or Redshift and accept the slower frame, rather than letting the driver spill data you cannot control.
- Move to a card with more VRAM when the scene is simply bigger than the card: the jump from 24 GB (RTX 4090) to 32 GB (RTX 5090) is often enough to keep a heavy frame in core.
VRAM overflow checklist
Tick each item on the machine that will render the heaviest frame.
SaaS or IaaS render farm for a scene that overflows VRAM?
Both kinds of render farm render the same scene file, and how much memory a scene needs comes from the file, not from the farm. What differs is where you find out whether it fits and how you fix it. On a SaaS render farm you submit the job and read the result and the logs. On an IaaS render farm such as iRender you open the scene yourself on the target GPU and watch Task Manager while you change it.
| Your situation | SaaS render farm | IaaS render farm (iRender) |
|---|---|---|
| The scene already fits in VRAM on your PC and you only need final frames | A good fit: upload, submit and collect frames, with no machine to manage | Works too, but you set up the server and software yourself |
| You have a deadline and need to know when rendering starts and ends | Jobs join the farm’s queue, so the start time depends on how busy the farm is; many farms sell higher-priority plans to start sooner | The server runs only your job from the moment it boots, so you control when rendering starts and can time the whole job |
| The scene spills into shared memory at home and renders slowly | The job runs on the farm’s hardware; you learn whether it fitted from the log and the render time | Open the scene on a 24 GB or 32 GB GPU, watch Dedicated and Shared GPU memory live, and adjust textures in the same session |
| You want to test a driver setting such as CUDA - Sysmem Fallback Policy | Driver settings are managed by the farm | Full administrator access: change the setting, restart the server yourself if needed, and compare |
| A long animation that already fits | Splits frames across many nodes automatically | Rent several servers and give each one a frame range |
| You prefer not to operate a machine | Submission presets and farm support handle it | Elite Support helps, but you run the machine |
A comparison of how the two farm models work for this task, not a speed test.
A simple rule: if the scene already fits and you only need frames, a SaaS farm is the shorter path. If you still need to find out whether the scene fits in 24 or 32 GB, or why it slows down, you need a machine you can watch and change, which is what an IaaS server gives you.
A VRAM test workflow on an iRender server
How to read the figure. The left box is your own workstation and the right box is an iRender server; the rows between them are what stays the same: the desktop, your software version, plugins, licenses and render settings. The only row that changes is the GPU count, 1, 2, 4 or 8 RTX 5090 or RTX 4090. Note that each card keeps its own VRAM, so the memory limits in this guide apply per GPU on the server too.
- Upload first. Put the scene and textures in iRender Drive before you start a server; transfer and storage are free and no rental time runs while you upload.
- Pick by VRAM per GPU, then by GPU count. RTX 4090 servers (3S, 4S, 5S, 9S) have 24 GB per GPU; RTX 5090 servers (3i, 4i, 5i, 9i) have 32 GB per GPU. More GPUs speed up Octane, Redshift and Cycles but do not add memory per scene. For Karma XPU, 4-GPU servers scale best.
- Measure. Start the server, open Task Manager, render the heaviest frame and note peak Dedicated GPU memory and whether Shared GPU memory rises. 1-GPU servers have a one-hour minimum; multi-GPU servers are billed per minute.
- Fix or move up. If the frame overflows on an RTX 4090, try the same frame on an RTX 5090 or reduce textures. With 256 GB ECC RAM, out-of-core in Octane or Redshift has room to work when you choose to use it.
- Render. When the frame fits, render the sequence. For a deadline, run several servers on separate frame ranges; because billing is per minute, the total cost stays close to one server running longer.
Frequently asked questions
1. What is the difference between dedicated and shared GPU memory?
Dedicated GPU memory is memory reserved for the GPU; on a graphics card it is the VRAM on the board. Shared GPU memory is system RAM that the GPU can borrow, managed by Windows and capped at half of physical memory.
2. Can I increase shared GPU memory?
Adding system RAM raises the ceiling, because Windows allows the GPU up to half of physical memory. It does not add VRAM, and data in shared memory is read over PCIe, far more slowly than VRAM.
3. Is high shared GPU memory usage bad for rendering?
It is a warning sign when Dedicated GPU memory sits at its limit and Shared GPU memory keeps rising during a render. Part of the scene is then read over PCIe and the render slows down.
4. Do two GPUs double my VRAM for one scene?
No. Each GPU keeps its own copy of the scene, so two 24 GB cards still give you 24 GB per scene. The second card adds rendering speed, not memory.
5. Should I turn off the CUDA Sysmem Fallback Policy?
Setting it to Prefer No Sysmem Fallback makes a CUDA renderer stop with an out-of-memory error instead of slowing down. That is useful for testing whether a scene fits; keep the default if you would rather the render finish slowly.
6. How can I test whether my scene fits in 24 GB or 32 GB before buying a GPU?
Render the heaviest frame on a machine with that GPU while watching Task Manager. On iRender you can rent an RTX 4090 server with 24 GB or an RTX 5090 server with 32 GB for a single session and compare.
7. What is shared GPU memory in Task Manager?
It is system RAM that the GPU can borrow, shown under Task Manager › Performance › GPU next to Dedicated GPU memory. Windows manages it and caps it at half of physical memory, so a PC with 64 GB of RAM shows a limit of about 32 GB. Data the GPU reads from there is much slower to reach than VRAM.
Render heavy scenes on iRender
iRender is an IaaS GPU render farm: you rent a bare-metal server with 1, 2, 4 or 8 NVIDIA RTX 4090 (24 GB) or RTX 5090 (32 GB) GPUs, an AMD Ryzen™ Threadripper™ PRO CPU, 256 GB ECC RAM and a 2 TB NVMe SSD, connect by remote desktop and work on it like your own workstation, with full administrator access. Your server image is saved between sessions, and you can restart the server yourself after changing a Windows or driver setting.
Multi-GPU servers are billed per minute (1-GPU servers have a one-hour minimum), and sessions of 3 hours or more get 10% off. Our 4-GPU and 8-GPU servers are liquid-cooled; in our own measurements the GPUs hold 60–70°C under sustained render load. Elite support is available 7 days a week by hotline, live chat, Skype, WhatsApp and email.
This quick start shows how to start a server and connect to it:
To see what the extra 8 GB per GPU and the faster memory of the RTX 5090 mean in practice, here are two of our recorded RTX 5090 vs RTX 4090 comparisons, in Cinema 4D with Octane and in Blender:
New users get a 100% bonus on the first top-up (minimum $50). See all plans on the price page or download the iRender GPU app.
Sources: Microsoft DirectX Blog: GPUs in the Task Manager · Microsoft Learn: Direct3D 12 Residency · NVIDIA: System Memory Fallback · SideFX forum: OptiX memory spill-over on Windows · Rambus: PCIe 4.0 bandwidth · Blender Manual: GPU Rendering · Blender Manual: Simplify · OTOY: Out of Core Tab · Maxon: Managing VRAM issues with Redshift · Maxon: Is memory combined on multiple GPUs? · Maxon: 3D rendering · SideFX: Karma XPU. GPU memory bandwidth figures as listed on our price page; Cycles out-of-core figures from Blender developer notes (2018).




