Running Blender and a local AI on one graphics card: measured VRAM sharing on 8 GB

Based on: Blender 5.2 LTS (measured with 5.2.1), llama.cpp (build 11870, Vulkan), the Gemma 4 E4B model (Q4_K_M), and an NVIDIA GeForce RTX 4070 Laptop GPU with 8 GB (driver 610.62). Measured on my PC on November 4, 2026. The screenshot is a real capture of the llama.cpp web page. Charts are drawn from the measured values.

You have one graphics card. Can Blender and a local AI stay open at the same time? This comes up often when you let an AI drive Blender, for example through Blender MCP. The AI model runs on your own computer, and Blender renders on the same graphics card. The two programs have to share graphics memory (VRAM) and compute.

So I measured it. On my laptop with 8 GB of graphics memory, I kept a local AI model running while rendering in Blender. I logged how full the memory got, how much the render and the AI slowed each other down, and what changed when the AI ran on the graphics card versus the CPU. The basics of running AI locally are in Running AI on your own computer, and connecting a local AI to Blender is in Driving Blender with AI on your own computer. This post gives the numbers for running both on the same graphics card at the same time, and the steps to plan memory on your own PC.

1. The short answer

In short, a small AI model (Gemma 4 E4B) and a Blender scene of this size fit together in 8 GB. But when both work at once, they take compute from each other and both slow down. Working at the same time was a bigger problem than memory.

2. Two people sharing one workbench

Graphics memory is a workbench right next to the graphics card. Only what sits on the bench can be handled quickly. More detail is in What VRAM means.

Running Blender and a local AI together is like two people sharing one workbench. Two things collide.

1. Space: The bench has a fixed size. If the AI model takes a lot of space, there is less room for the Blender scene. If space runs out, the render stops or fails.
2. Hands: There is also only one pair of hands at the bench (the graphics card's compute units). While one person works, the other waits. So when both work at once, both slow down.

If the AI model only sits on the bench, it takes space but does not use the hands. You can see this difference clearly in the results below.

3. Test setup and method

I loaded the model two ways. Giving llama-server an -ngl value (number of layers to put on the graphics card) of 99 puts the whole model on the card. A value of 0 keeps it off the card and runs it on the CPU.

On test day this laptop had Windows Energy saver turned on. On my PC, programs running without a window slowed down a lot with Energy saver on. So I took both Blender and the AI server out of Windows power throttling before measuring. That effect is covered separately in Finding the bottleneck in your computer. A few other programs were also running, and whole-PC CPU use was 15–20% before each test.

4. How full does graphics memory get

Figure 1. Graphics memory use in each situation. Values are the highest total use on the card (chart)

Read Figure 1 from the top.

• With nothing running, 754 MiB is already in use. That is the share for drawing the screen. On a laptop you need to plan without it.
• Loading the AI model onto the card raised it to 3,946 MiB. The model and its conversation memory took about 3.1 GB.
• Rendering in that state went up to 5,162 MiB with EEVEE and 5,721 MiB with Cycles GPU. About 2.4 GB of the card's 8,188 MiB was left.
• With the AI on the CPU only, a Cycles render used 2,618 MiB. That is about the same as Blender alone.

The model file was about 5 GB, but graphics memory grew by less than that. Do not decide "it won't fit" from file size alone. It is more accurate to load it and measure how much memory grows. On the other hand, a larger context limit (-c) makes the conversation memory bigger and uses more VRAM. This post only measured 8,192 tokens.

One thing to know when reading the values. If you just run nvidia-smi on a Windows laptop, the process list at the bottom shows Blender and the AI server, but the memory column for each program says "N/A". Because of how Windows manages graphics memory, it does not show per-program values. So this post counted each program's share by how the whole card's use changed: turn one thing on and measure how much it grew. You can also get a rough per-program value in Task Manager: on the Details tab, right-click a column header and add the "Dedicated GPU memory" column.

The test scene has 383 objects and no textures, so it is small. Scenes with many textures, 4K renders, or hundreds of thousands of objects need a bigger Blender share. Then the remaining 2.4 GB may not be enough.

5. How much slower does the Blender render get

Figure 2. Blender render time per frame by AI state. Median (chart)

With the AI only loaded, render time barely changed. It takes space but not hands. So as long as the memory fits, you can keep the AI open while you use Blender.

Once the AI starts writing, things change. The two programs share the compute units, and Cycles became almost 3x slower. Cycles slowed down more than EEVEE, most likely because Cycles keeps the graphics card's compute units busy for longer and more fully.

Keeping the AI on the CPU still made renders 1.5–1.6x slower. The graphics card was free, but the AI took many CPU threads. The CPU is also what feeds work to the graphics card, so when the CPU is busy, the GPU render waits too.

6. How much slower does the AI get

Figure 3. The speed shown on the llama.cpp web page after one answer. 298 tokens in 4.6 seconds, or 64.23 tokens per second (llama.cpp web page screenshot)

AI speed is measured in tokens per second (tok/s). A token is the unit the AI writes in, about one English word or part of a word. When you get an answer on the llama.cpp web page, the token count, time, and tokens per second appear under the answer, as in Figure 3.

Follow along: Check the speed on your PC.

1. Start llama-server and open http://127.0.0.1:8080 in a web browser (how to start it is in section 5 of Driving Blender with AI on your own computer).
2. Type a question in the box at the bottom and press Enter.
3. When the answer ends, write down the t/s number under it.
4. Start a render in Blender, send the same question again, and compare the numbers.

Figure 4. AI writing speed in each situation. Median; the CPU bars come from few answers (the bottom bar is 1 answer) (chart)

On the graphics card, the AI wrote 63.5 tokens per second when alone. Overlapping with a render cut that nearly in half. On the CPU it wrote about 8 tokens per second even alone, about 1/8 of the graphics card speed. But overlapping with a GPU render barely changed it. The CPU numbers moved between 7 and 13 depending on answer length, and I measured only a few, so treat them as rough values.

Turning the numbers into waiting time makes the gap clearer. For the same question, one answer usually took 3–4 seconds on the graphics card and 21–33 seconds on the CPU. Over a few rounds of conversation, this adds up. If you give an AI a multi-step job through Blender MCP, you wait this long at every step.

Reading the question (the step before writing, where the model reads the whole prompt) was also very different. About 373 tokens per second on the graphics card, about 22 on the CPU. In jobs that send long scene information to the AI, as Blender MCP does, you feel this gap even more. The CPU can take tens of seconds just to read one long prompt.

7. Put the AI on the graphics card or the CPU

In my measurements, putting the AI on the graphics card is usually better. The AI is 8x faster, and while the AI is idle there was almost no cost to the render. If you take turns, asking the AI first and starting the render after the answer ends, both programs run at full speed.

Keeping it on the CPU is a fallback for when the Blender scene is big and VRAM runs short. You can also give -ngl a value between 99 and 0 to put only part of the model on the card. I did not measure those in-between values this time. Also, if you leave out -ngl entirely, the default is auto (llama.cpp server guide). The program then decides how many layers to load by itself, so it is hard to know how much of the model ended up on the graphics card versus the CPU. If you plan to use it with Blender, give the number yourself and check how much memory grew with nvidia-smi. That makes planning easier. Results from putting part of a bigger model on the card are in the measurement section of Driving Blender with AI on your own computer.

8. Plan memory on your own PC

Numbers from your own PC are more accurate than anyone else's. Use these steps to make a plan.

Starting point: Start with both Blender and the AI server closed.

Follow along:

1. Open a terminal and run this line to see VRAM every second.

nvidia-smi --query-gpu=memory.used,memory.total,utilization.gpu --format=csv -l 1

2. Write down memory.used with nothing running. That is the screen share (754 MiB on my PC).
3. Load the model you want to use with llama-server and write down how much memory grew. That is the AI share (about 3.1 GB on my PC).
4. Close the AI, render a scene you normally work on in Blender, and write down the highest value. Subtract the screen share to get the Blender share.
5. Add screen share + AI share + Blender share and compare with the card total (memory.total).
6. If the sum is close to the total, lower the context limit (-c), use a smaller quantized file, or move the AI to the CPU.

Even if the sum is below the total, leave some room. Browsers, video playback, and other 3D programs also use graphics memory. The Blender share also changes when the scene changes.

9. Choosing a VRAM size

If you are choosing a new graphics card or laptop, use the plan above in reverse. Add the AI share for the model you want and the Blender share for your usual scenes, then add the screen share and some room. Pick a card with more VRAM than that sum.

• 8 GB: As in this post, a small model (about 4.5 billion effective parameters, about 8 billion including embeddings, 4-bit quantized) and a medium scene fit together. Bigger models have to keep part of themselves in RAM, and they get slower for it.
• Cards larger than 8 GB: You get room to load a bigger model fully, or to load a big scene and the AI together. The official tables in Running AI on your own computer help estimate the memory each model size needs.

Even with more VRAM, there is still only one set of compute units. If both work at once, they slow each other down, no matter how much memory is free. If you need both to run for long stretches at the same time, splitting them across devices (for example, the AI on another PC or in the cloud) can help more than adding memory. The cost of sending renders out is in Blender render cost. Choosing a graphics card in general is in Computer specs for AI, Blender, and game engines.

I did not measure image-generating AI models this time. They use memory differently from text models, so measuring them the same way on your own PC is the most accurate.

10. The order of work when using both

Here are the measurements turned into a working order. The example is the flow where a local AI builds a scene through Blender MCP and you render the result.

The key is not to overlap the AI's writing time with render time. In the test, renders while the AI was idle were almost the same as alone (0.46 s and 0.47 s). When they overlapped, a Cycles frame went from 3.43 s to 9.86 s.

Before jobs that use the graphics card for hours, such as a long animation render, it is better to close the AI server. Starting the AI again means reading the model again. On my PC, reading a model stored on an external SSD took about 2 minutes. Keeping the model file on a fast internal SSD shortens this.

The AI server also often runs without a window. If Energy saver is on, the AI server can slow down too. On my PC, before removing power throttling, the web page sat at "Processing 0%" for more than 25 seconds after I sent a question. After removing it and sending the same question, the answer came back, and it wrote at 64 tokens per second as in Figure 3. If renders or the AI are slow for no clear reason, check Energy saver first.

Practice

1. With nvidia-smi, write down VRAM use with nothing running. That is your PC's screen share.
2. Load a local AI model and write down how much VRAM grew. Compare it with the model file size.
3. Render the same scene with F12 while the AI is idle and while it is writing, and compare the Time value in the render window.
4. Restart llama-server with -ngl 0 and write down what fraction of the -ngl 99 speed the t/s value is.
5. Follow section 8 to add screen share + AI share + Blender share and compare with the card total. Write down how much is left.

Common mistakes and fixes

Summary

A small AI model and Blender fit together in 8 GB, but there is only one set of compute units: measure memory to split it, and let them take turns.

References

• llama.cpp server guide (options -ngl, -c): https://github.com/ggml-org/llama.cpp/blob/master/tools/server/README.md
• Gemma 4 E4B GGUF (model card, license Apache-2.0): https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF
• Blender manual, GPU rendering: https://docs.blender.org/manual/en/5.2/render/cycles/gpu_rendering.html
• NVIDIA, nvidia-smi documentation: https://docs.nvidia.com/deploy/nvidia-smi/index.html
• Images: the web page is a screenshot of llama.cpp on my PC; charts are drawn from values measured on my PC.