Een praktische gids voor engineering leads en developers die grote taalmodellen (LLM's) willen draaien op de eigen laptop van de developer, onder Linux, in plaats van op een gedeelde server of een cloud-GPU. De gids behandelt wat er past in 16 GB en 24 GB laptop-GPU-geheugen, de berekening daarachter, de open modellen die in november 2026 de moeite waard zijn, het inrichten van Ubuntu 26.04 met de NVIDIA-stack, modellen draaien met Ollama, llama.cpp en vLLM, ze koppelen aan codeertools, fine-tunen met LoRA, stroom en warmte, beveiliging, en wanneer een job naar een server of de cloud moet.
Deze technote hoort bij ons blogbericht AI-developerlaptops: waarom elk AI-team developers een eigen GPU zou moeten geven, dat de businesscase maakt. De voorbeeldmachine is de Juno Neptune 18", een 18-inch Linux-laptop die wij verkopen. Modelgroottes komen uit de Ollama-bibliotheek en GPU-cijfers van NVIDIA, gecontroleerd op 18 november 2026. Snelheden hangen af van het model, de kwantisatie, de context en de stroominstellingen, dus wij leggen uit hoe u meet in plaats van benchmarkcijfers te noemen.
1. Waarom de GPU op het bureau van de developer zetten
De meeste AI-ontwikkeling is een inner loop: een prompt, een retrievalstap, een tooldefinitie of een paar regels code wijzigen, draaien, de uitvoer lezen, herhalen. Die loop draait honderden keren per dag. Als elke run moet wachten op een gedeelde GPU, een cloudinstance die moet opstarten of een API met rate limits, bundelen developers hun wijzigingen en leren ze langzamer. Een lokaal model antwoordt in seconden, werkt offline en kost niets per aanroep.
- Privacy. Broncode, klantgegevens en prompts verlaten nooit een door het bedrijf beheerd apparaat. Dat vereenvoudigt UK GDPR-beoordelingen en klantcontracten die het verzenden van data naar API's van derden verbieden.
- Realisme. Developers zien de echte grenzen van open modellen (contextlengte, kwantisatie, geheugen) eerder dan productie.
- Gelijkheid. Linux, de NVIDIA-driver, CUDA en containers zijn hetzelfde als op uw GPU-servers, zodat een prototype zonder wijzigingen naar een server gaat.
- Beschikbaarheid. Geen wachtrij, geen quotum, geen afhankelijkheid van storingen tijdens de ontwikkeling.
Een laptop vervangt geen servers. Training, grote fine-tunes, lange evaluatieruns en productieserving horen op een gedeelde GPU-server of een cluster (sectie 11).
2. De machine
De cijfers die ertoe doen voor AI-werk, voor de Neptune 18" zoals geconfigureerd in onze shop. GPU-cijfers zijn van NVIDIA; de rest is van de fabrikant.
| Onderdeel | Specificatie | Waarom het ertoe doet |
|---|---|---|
| GPU (standaard) | NVIDIA GeForce RTX 5080 Laptop GPU: 16 GB GDDR7, 256-bit, 7.680 CUDA-cores, 1.334 AI TOPS | Houdt modellen van 8–20B en hun KV-cache op de GPU |
| GPU (op aanvraag) | NVIDIA GeForce RTX 5090 Laptop GPU: 24 GB GDDR7, 256-bit, 10.496 CUDA-cores, 1.824 AI TOPS | Voegt de klasse van 27–32B en langere context toe |
| GPU-vermogen | 150 W + 25 W Dynamic Boost in dit chassis (bereiken volgens NVIDIA: 80–150 W voor de RTX 5080, 95–150 W voor de RTX 5090 Laptop GPU) | Duurzame snelheid hangt af van het vermogen; draai lange jobs met de stekker erin |
| CPU | Intel Core Ultra 9 290HX Plus, 24 cores (8P + 16E), tot 5,5 GHz; 55 W basis, 160 W max | Tokenisatie, data laden en CPU-offload van modellagen |
| Geheugen | 32 tot 192 GB DDR5 (2 modules op 5600 MHz tot 96 GB; 4 modules op 4000 MHz voor 128 en 192 GB) | Ruimte voor modellen die groter zijn dan het GPU-geheugen (sectie 4) |
| Opslag | 1 × PCIe Gen 5 + 3 × PCIe Gen 4 M.2 2280, tot 16 TB | Modelbestanden zijn elk 5–140 GB; houd lokaal een bibliotheek aan |
| Scherm | 18" 16:10, QHD+ 240 Hz (RTX 5080) of UHD+ 200 Hz (RTX 5090), 100% DCI-P3 | Ruimte voor code, terminal en notebook naast elkaar |
| Poorten | 2 × Thunderbolt 4 / USB-C, 2 × USB-A, HDMI en Mini DisplayPort (verbonden met de NVIDIA-GPU), 2,5 Gb Ethernet, Wi-Fi 7 | Snelle overdracht van modellen en datasets |
| Stroom | Accu van 99 Wh, lader van 330 W | GPU-werk doet u met de stekker erin |
| Software | Kubuntu of Ubuntu 26.04 LTS voorgeïnstalleerd | Dezelfde OS-familie als de meeste GPU-servers |
3. Wat past: GPU-geheugen beslist
Wanneer de gewichten van een model, de KV-cache en de runtime allemaal in het GPU-geheugen passen, gaat het genereren snel. Als dat niet zo is, draait een deel van het model vanuit het systeemgeheugen via PCIe en vanaf de CPU, en daalt de snelheid sterk. De eerste vraag bij elk model is dus de grootte ervan.
| Model (Ollama-tag) | Download | RTX 5080 (16 GB) | RTX 5090 (24 GB) | Goed voor |
|---|---|---|---|---|
| qwen3:8b | 5,2 GB | Op de GPU, lange context | Op de GPU | Snelle algemene assistent, agents, RAG |
| qwen3:14b | 9,3 GB | Op de GPU | Op de GPU | Sterker redeneren met goede snelheid |
| gpt-oss:20b (OpenAI, MoE) | 14 GB | Op de GPU, korte tot middellange context | Op de GPU, langere context | Redeneren, toolgebruik, algemeen programmeren |
| gemma3:27b (Google) | 17 GB | Deels geoffload | Op de GPU | Schrijven, meertalig, afbeeldingen als invoer |
| qwen3.8:27b | 18 GB | Deels geoffload | Op de GPU | Programmeren, onderzoek en agenttaken, tekst en afbeeldingen |
| qwen3-coder:30b (MoE, ongeveer 3B actief) | 19 GB | Experts geoffload, nog bruikbaar | Op de GPU | Codeaanvulling en codeeragents |
| nemotron-3.5-lightning:30b (NVIDIA, MoE, 3B actief) | 19–25 GB | Experts geoffload | Kleinere kwantisatie op de GPU | Altijd actieve agents, tot 1M context |
| qwen3:32b | 20 GB | Deels geoffload | Op de GPU, korte context | Dichte 32B-kwaliteit |
| llama3.3:70b (Meta) | 43 GB | GPU + systeem-RAM (64 GB of meer): traag, prima voor controles | Vergelijken met een model van serverklasse | |
| gpt-oss:120b (OpenAI, MoE, 5,1B actief) | 65 GB | GPU + systeem-RAM (96 GB of meer): bruikbaar dankzij MoE | Bijna-frontier open redeneren op een laptop | |
| qwen3:235b (MoE) | 142 GB | GPU + 192 GB RAM: experimenteel | Een zeer groot model uitproberen voordat u een server koopt | |
De groottes zijn de standaard Ollama-tags, meestal 4-bitkwantisaties. Licenties verschillen (Apache 2.0, de Gemma-voorwaarden, de Llama-licentie van Meta, de open-modellicentie van NVIDIA en andere): controleer elke modelkaart voordat u een model commercieel gebruikt.
4. De geheugenberekening
Drie dingen delen het GPU-geheugen: de gewichten, de KV-cache en de runtime.
Gewichten
weights ≈ parameters × bits per weight ÷ 8. Een 14B-model is 28 GB in 16-bit, ongeveer 14–15 GB in 8-bit en ongeveer 8–9 GB in 4-bit (4-bitformaten slaan per blok iets extra op, dus echte bestanden zijn iets groter dan een halve byte per parameter). Het kwaliteitsverlies bij een goede 4-bitkwantisatie is voor het meeste ontwikkelwerk klein; 8-bit ligt dicht bij het origineel. Blackwell-GPU's, waaronder de RTX 50-serie, ondersteunen FP4 en FP8 ook in hardware, wat runtimes zoals TensorRT-LLM en vLLM kunnen benutten.
KV-cache
Voor elk token in de context slaat elke laag een key en een value op: KV bytes per token = 2 × layers × KV heads × head size × bytes per value. Voor Llama 3.1 8B is dat 2 × 32 × 8 × 128 × 2 = 131.072 bytes (128 KiB) in 16-bit. Het groeit lineair met de contextlengte en met het aantal verzoeken dat tegelijk wordt bediend.
Een 8B-model dat 5 GB op schijf is, heeft dus ongeveer 23 GB nodig bij zijn volledige context van 128K. Drie manieren om het te laten passen:
- Gebruik de context die u nodig hebt. Het meeste programmeer- en RAG-werk gaat prima met 16–32K. Runtimes reserveren de cache voor de context die u instelt, dus stel die in.
- Kwantiseer de cache. Een 8-bit-KV-cache halveert die met weinig kwaliteitsverlies; 4-bit brengt hem terug tot een kwart. Stel in Ollama
OLLAMA_FLASH_ATTENTION=1enOLLAMA_KV_CACHE_TYPE=q8_0in; gebruik in llama.cpp--cache-type-k q8_0 --cache-type-v q8_0. - Geef de voorkeur aan modellen met grouped-query- of andere compacte attention. Minder KV-heads betekent een kleinere cache; de modelkaart vermeldt ze.
Runtime
Reken op 1–2 GB voor de CUDA-context, activaties en buffers, en onthoud dat ook de desktop wat GPU-geheugen gebruikt wanneer schermen via de NVIDIA-GPU lopen. Controleer met nvidia-smi voordat u een model laadt.
Snelheid, en waarom systeemgeheugen nog steeds belangrijk is
Voor elk gegenereerd token wordt elk actief gewicht één keer gelezen, dus de generatiesnelheid wordt vooral begrensd door de geheugenbandbreedte: GDDR7 op de GPU is meerdere keren sneller dan het DDR5 in de laptop. Daarom vertraagt een model dat naar het systeemgeheugen overloopt, en daarom zijn mixture-of-experts-modellen (MoE) de uitzondering: gpt-oss-120b heeft 117B parameters, maar slechts ongeveer 5,1B zijn per token actief, dus de gedeelde lagen op de GPU houden en de experts in het systeemgeheugen geeft nog steeds bruikbare snelheid. Voor dat soort werk helpt meer en sneller systeemgeheugen: twee modules op 5600 MHz zijn sneller dan vier op 4000 MHz, dus kies 96 GB (2 × 48 GB), tenzij u 128 of 192 GB nodig hebt voor de capaciteit.
Meet op uw eigen werk: ollama run <model> --verbose drukt de snelheden van promptverwerking en generatie af in tokens per seconde, en llama-bench doet hetzelfde voor llama.cpp.
5. Ubuntu 26.04 inrichten voor AI-werk
Machines van ons worden geleverd met de NVIDIA-driver geïnstalleerd en gecontroleerd. Om er een te controleren of opnieuw op te bouwen:
# Is the NVIDIA GPU visible, and which driver is in use?
nvidia-smi
# Ubuntu's recommended NVIDIA driver (signed for Secure Boot)
sudo ubuntu-drivers list
sudo ubuntu-drivers install
sudo reboot
# Laptops with two GPUs: run everything on the NVIDIA GPU, or only what asks for it
prime-select query
sudo prime-select nvidia # or: on-demand
Met Secure Boot aan moet bij een lokaal gebouwde driver de ondertekeningssleutel bij de volgende start worden ingeschreven (MOK); de verpakte drivers van Ubuntu vermijden die stap. Haal de driver uit het archief van Ubuntu of uit de repository van NVIDIA, niet uit beide.
Containers met de GPU
Containers houden CUDA-versies per project gescheiden en komen overeen met wat op servers draait. Installeer Docker (of Podman), daarna de NVIDIA Container Toolkit uit de apt-repository van NVIDIA volgens de installatiehandleiding van NVIDIA, en koppel hem:
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
# Test: the container should list the laptop GPU
docker run --rm --gpus all ubuntu nvidia-smi
Python
Gebruik één virtuele omgeving per project (uv of venv) en installeer PyTorch met de CUDA-build die de installatiepagina voor uw driver aanbeveelt. Controleer het met python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))".
6. Modellen draaien
Ollama: de snelste start
curl -fsSL https://ollama.com/install.sh | sh
ollama run gpt-oss:20b # downloads once, then runs locally
ollama ps # shows how much of the model is on the GPU vs the CPU
ollama ps is de eerste controle: "100% GPU" is wat u wilt zien. Als er een CPU-aandeel staat, verklein dan de context, kwantiseer de KV-cache of kies een kleiner model. Ollama luistert op 127.0.0.1:11434 en biedt een OpenAI-compatibele API op /v1, dus de meeste tools kunnen het ongewijzigd gebruiken.
llama.cpp: volledige controle
# All layers on the GPU, 32K context, 8-bit KV cache, OpenAI-compatible server on :8080
llama-server -m qwen3-14b-q4_k_m.gguf --n-gpu-layers 99 --ctx-size 32768 \
--cache-type-k q8_0 --cache-type-v q8_0 --host 127.0.0.1 --port 8080
# A MoE model bigger than GPU memory: keep shared layers on the GPU, put experts in system RAM
# (recent llama.cpp builds; raise the number until it fits)
llama-server -m gpt-oss-120b.gguf --n-gpu-layers 99 --n-cpu-moe 24 --ctx-size 16384
vLLM: het dichtst bij productieserving
pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 16384 --gpu-memory-utilization 0.85
# OpenAI-compatible API on http://127.0.0.1:8000/v1
vLLM reserveert vooraf GPU-geheugen voor de KV-cache, dus houd modellen op een laptop-GPU van 16 GB klein en stel --max-model-len in. De waarde zit in de gelijkheid: dezelfde server, vlaggen en API als op uw GPU-servers.
LM Studio is een desktopapp voor hetzelfde werk, met een modelbrowser en een lokale API, handig voor mensen die niet in een terminal leven.
7. Codeerassistenten en agents op een lokaal model
De meeste IDE-assistenten, codeeragents en agentframeworks accepteren een OpenAI-compatibele base-URL. Laat ze wijzen naar http://127.0.0.1:11434/v1 (Ollama), :8080/v1 (llama.cpp) of :8000/v1 (vLLM). Praktische keuzes in november 2026:
- Aanvulling tijdens het typen: een klein, snel model (qwen3:8b of vergelijkbaar). Latentie telt meer dan grootte.
- Chat en refactoring: gpt-oss:20b op 16 GB; qwen3-coder:30b of qwen3.8:27b op 24 GB.
- Agents met tools: modellen die zijn getraind voor tool calling (gpt-oss, de Qwen3-familie, Nemotron 3.5 Lightning), met genoeg context voor de toolresultaten, doorgaans 32K of meer.
Houd een gehost frontier-model aan voor de moeilijkste problemen als uw beleid dat toestaat; het lokale model verwerkt het dagelijkse volume privé. Veel teams routeren per taak: standaard lokaal, gehost op verzoek.
8. Fine-tunen op een laptop
Volledige fine-tuning van zelfs een 7B-model vereist veel meer dan 24 GB. LoRA en QLoRA trainen kleine adaptermatrices bovenop bevroren gewichten (QLoRA houdt het basismodel in 4-bit), waardoor fine-tuning op een laptop mogelijk wordt:
- 16 GB (RTX 5080): QLoRA op 7–8B-modellen bij bescheiden sequentielengtes; tot ongeveer 14B met geheugenbesparende tooling en korte sequenties.
- 24 GB (RTX 5090): QLoRA op 14B zonder problemen, en tot ongeveer 30B met korte sequenties.
- Daarboven: fine-tunes van 70B en volledige fine-tunes gaan naar een server (sectie 11).
Gebruik Hugging Face PEFT en TRL, of Unsloth voor een lager geheugengebruik, met gradient checkpointing en een batchgrootte van één of twee plus gradient accumulation. Deze bereiken hangen af van sequentielengte, rank en tooling: begin klein, houd nvidia-smi in de gaten en groei. De laptop is ideaal om dataformaten, hyperparameters en evaluatiescripts op een kleine run te controleren voordat u voor een lange betaalt.
9. Stroom, warmte en accu
- Sluit de stroom aan voor GPU-werk. Op de accu draait de GPU met verminderd vermogen; de lader van 330 W houdt GPU-belastingen van 150 W+ vol.
- Houd het in de gaten:
nvidia-smi dmon -s pucmstreamt vermogen, bezetting, kloksnelheden en geheugen;nvidia-smi -q -d POWER,TEMPERATUREtoont de limieten. - Lange jobs: houd de ventilatieopeningen vrij, gebruik het prestatieprofiel en reken op ventilatorgeluid. Voor jobs van meerdere uren is een desktop of server het betere gereedschap.
10. Beveiliging en governance
- Versleutel de schijf. Volledige schijfversleuteling (LUKS) beschermt code, data en modelbestanden als de laptop verloren raakt; wij richten die vóór verzending in als dat is besteld.
- Houd modelservers lokaal. Ollama, llama.cpp en vLLM hebben standaard geen gebruikersauthenticatie. Bind ze aan
127.0.0.1; stel ze nooit beschikbaar op0.0.0.0op kantoor- of openbare wifi zonder een proxy die authenticeert. - Weet waar modellen vandaan komen. Download uit de officiële repositories van de uitgever, geef de voorkeur aan safetensors en GGUF boven formaten die bij het laden code kunnen uitvoeren, en houd een lijst bij van goedgekeurde modellen en hun licenties.
- Beheer het apparaat. Updates, schijfversleuteling en schermvergrendeling vallen onder uw normale apparaatbeheer; lokaal verwerkte data blijft persoonsgegevens onder de UK GDPR.
11. Wanneer werk van de laptop af moet
| Signaal | Verplaatsen naar |
|---|---|
| Het model heeft op volle snelheid meer dan 24 GB nodig, of lange context voor veel gebruikers | Een workstation of server met RTX PRO 6000 (96 GB) of een DGX-systeem |
| Een job draait urenlang, of blokkeert de machine van de developer | Een gedeelde GPU-server, ingepland |
| Meerdere developers hebben de hele dag hetzelfde model nodig | Eén inferentie-endpoint voor het team in plaats van veel kopieën |
| Training over meerdere GPU's of productieserving | Cluster of cloud, met dataresidentie in het Verenigd Koninkrijk waar nodig |
Nog niet klaar om te kopen? Workstation Rentals verhuurt AI-laptops en GPU-workstations per week of per maand, en GPU Leasing legt uit hoe leasen werkt.
12. Welke configuratie voor welke developer
| Rol | GPU | Systeemgeheugen | Opslag |
|---|---|---|---|
| Applicatiedeveloper die AI gebruikt (RAG, agents, assistenten) | RTX 5080, 16 GB | 64 GB | 2 TB |
| AI-engineer (evaluatie, fine-tuning, modellen van 27–32B) | RTX 5090, 24 GB | 96 GB (2 × 48 GB, snelst) | 4 TB |
| Onderzoeker die zeer grote MoE-modellen lokaal uitprobeert | RTX 5090, 24 GB | 128–192 GB | 4 TB of meer |
| Data scientist (notebooks, klassieke ML, kleine modellen) | RTX 5080, 16 GB | 64–96 GB | 2–4 TB |
13. Veelgestelde vragen
Kan een laptop echt een model van 120B draaien? gpt-oss-120b wel, met 96 GB of meer systeemgeheugen, omdat per token maar ongeveer 5,1B parameters actief zijn. Dichte 70B-modellen draaien ook, maar langzaam; gebruik ze om antwoorden te vergelijken, niet voor interactief werk.
16 GB of 24 GB? 16 GB dekt de klasse van 8–20B, die het meeste ontwikkelwerk aankan. Kies 24 GB als u werkt met modellen van 27–32B, lange contexten of fine-tuning boven 8B.
Waarom Linux en niet Windows? Servers, containers en de meeste AI-tooling zijn Linux-first. Ontwikkelen op hetzelfde OS neemt een hele klasse "werkt op mijn machine"-problemen weg.
Vervangt een lokaal model gehoste frontier-modellen? Niet voor de moeilijkste taken. Het neemt het dagelijkse volume privé en goedkoop voor zijn rekening; houd een gehost model aan voor wat dat nodig heeft, waar het beleid dat toestaat.
En Apple silicon? Macs met veel unified memory draaien grote modellen goed met MLX, maar zonder CUDA. Als uw servers NVIDIA en Linux zijn, houdt een NVIDIA-Linux-laptop de stack identiek.
Bronnen
- NVIDIA, specificaties van de GeForce RTX 50-serie voor laptops (CUDA-cores, AI TOPS, geheugen, interfacebreedte, GPU-vermogensbereik), gecontroleerd op 18 november 2026.
- Pagina's in de Ollama-bibliotheek voor qwen3, gpt-oss, gemma3, qwen3.8, qwen3-coder, nemotron-3.5-lightning en llama3.3 (downloadgroottes en beschrijvingen), gecontroleerd op 18 november 2026.
- OpenAI, modelkaart van gpt-oss (117B parameters in totaal en ongeveer 5,1B actief voor gpt-oss-120b).
- Meta, configuratie van Llama 3.1 8B (32 lagen, 8 KV-heads, headgrootte 128), gebruikt voor het voorbeeld van de KV-cache.
- Juno Computers, specificaties van de Neptune 18"; vermelding in de Workstation-shop (configuratie, prijs en verzendtijd).
- De commando's volgen de documentatie van Ubuntu, de NVIDIA Container Toolkit, Ollama, llama.cpp en vLLM; vlaggen veranderen tussen releases, dus controleer de actuele documentatie.
Erkenning van rechten: NVIDIA, GeForce, RTX, CUDA, cuDNN, NCCL, TensorRT, DGX, Blackwell en Nemotron zijn handelsmerken van NVIDIA Corporation. Intel en Core Ultra zijn handelsmerken van Intel Corporation. Ubuntu en Kubuntu zijn handelsmerken van Canonical Ltd. Juno en Neptune zijn namen van Juno Computers Ltd. Llama is een handelsmerk van Meta Platforms, Inc.; Gemma van Google LLC; Qwen van Alibaba Cloud; gpt-oss en OpenAI van OpenAI. Andere namen zijn eigendom van hun respectieve eigenaren. Dit artikel is onafhankelijk en wordt door geen van deze bedrijven onderschreven.