You can run Gemma 4 locally on a computer with integrated graphics. The important decisions are not simply “CPU or GPU.” Choose a quantized model that fits in memory, keep the context only as large as the task requires, and accept the speed-versus-capability tradeoff.
The Direct Answer
Start with the classic LM Studio download, select an official or trusted Gemma 4 GGUF variant, and let the application estimate whether it fits. On a 16GB system, E4B Q4 is the safer first model. Try 12B QAT Q4 only when LM Studio says it can load and there is enough memory left for the operating system, context, and attached images or documents.
Use thinking mode selectively. Keep LM Studio's defaults first, measure a real task, then adjust one setting at a time. The creator spent hours changing low-level options and saw little benefit compared with simply disabling thinking for easy work.
Watch the Full Gemma 4 Tutorial
Source and credit: The embedded tutorial and performance tests are by ExplainingComputers. The measurements below describe that one machine and configuration, not a universal benchmark. The current product documentation and implementation guidance are added by JQ AI SYSTEMS.
Download the Right Application: LM Studio or Bionic?
The LM Studio download page now presents LM Studio Bionic first and the classic LM Studio application second. The video uses the classic application: it provides model discovery, per-model settings, a chat interface, and programmable local APIs.
LM Studio describes Bionic as a separate agent application for coding and document work. Bionic can run local models, connect to another device through LM Link, or use cloud models. Choose the classic application when following this tutorial or when you need direct control over model loading, context, GPU offload, and the local server.
What Fits on Modest Hardware?
Google currently lists five Gemma 4 sizes: E2B, E4B, 12B, 31B, and 26B A4B. Smaller or lower-precision models require less memory and usually generate faster, while larger models generally offer more capability. The file size is only part of the memory requirement: the runtime, context or KV cache, vision inputs, and other applications also consume memory.
| Starting point | Why choose it | What to watch |
|---|---|---|
| E2B or E4B Q4 | Better fit for laptops, mini PCs, and first experiments. | Lower capability may show up on uncommon images, nuanced instructions, or complex code. |
| 12B QAT Q4 | More capability while remaining practical on some 16GB systems. | Leave headroom for Windows, LM Studio, context, and multimodal processing. |
| 31B or 26B A4B | Higher-capability local or workstation experiments. | Not sensible defaults for the modest 16GB integrated-graphics machine demonstrated. |
Google's official Gemma 4 documentation points to QAT Q4_0 GGUF variants for llama.cpp and LM Studio. In QAT, lower-precision behavior is simulated during training, allowing the model to compensate for quantization. PTQ instead compresses a trained model afterward and may lose more quality.
Five Sizes: Download Size Is Not RAM Required
The estimates below are Google's approximate Q4_0 memory to load base weights, including its stated loading overhead. They are not GGUF file downloads, minimum system RAM, or a promise that the full context and vision features will fit. Google says the runtime and KV cache add memory, and the operating system needs headroom too. The E2B and E4B names refer to effective parameters; their total stored weights are larger than the labels suggest. Source: Google model overview.
Gemma 4 E2B
Best starting role
The smallest edge-oriented option when memory is tight.
Check before choosing
The actual GGUF file and task quality; effective parameters do not equal total stored weights.
Gemma 4 E4B
Best starting role
A lighter laptop or mini-PC baseline for the tasks in this guide.
Check before choosing
Whether faster answers still meet your accuracy bar; the creator's E4B missed the okapi image.
Gemma 4 12B
Best starting role
The video's stronger 16GB integrated-graphics experiment.
Check before choosing
Leave room for Windows, LM Studio, context, and attached images. The creator's QAT download was 7.15GB.
Gemma 4 26B A4B
Best starting role
A higher-capability MoE experiment on substantially roomier hardware.
Check before choosing
Only 4B parameters are active per token, but the full model weights must still load.
Gemma 4 31B
Best starting role
A large dense model for a workstation rather than this 16GB tutorial PC.
Check before choosing
The weight estimate alone already exceeds the demo machine's total RAM, before runtime and context.
The tutorial's 7.15GB number is the specific 12B QAT file he downloaded in LM Studio, not Google's 6.7GB base-weight estimate. LM Studio's model listing can change with revisions, and Ollama's tags show different sizes for other packaged quantizations. Treat any chart promising a fixed minimum RAM requirement or a universal download size with caution: those numbers depend on the precise checkpoint, format, context, and runtime.
Where to Get the Model
- Follow this video: get the classic LM Studio app, the second download on its current page, then find Gemma 4 in Discover. Bionic is a separate agent app, shown first, and is not the interface used in the tutorial.
- Compare packaged versions: Ollama's Gemma 4 tags identify explicit sizes and formats. For example, its listed
gemma4:12bpackage is around 7.7-8.0GB as checked on 15 October 2026. Select an explicit tag instead of assuminggemma4will always mean the same variant. - Use source weights or GGUF files: Google's Gemma 4 collection contains the official model family; its QAT Q4_0 collection includes GGUF checkpoints for local runtimes. Choose the exact model and format your tool supports. Google also links Kaggle from its developer overview.
None of these apps turns a 16-bit checkpoint into a small Q4 file merely because you click Download: you select a prepared variant. After the model and runtime are installed, LM Studio can chat with local models and documents offline; searching or fetching new models requires a connection. Its current privacy policy distinguishes on-device chats from optional cloud services, so confirm the selected execution route before using private material.
Install LM Studio and Load Gemma 4
- Download the classic LM Studio application from the official download page. It appears below Bionic.
- Open Discover and search for
Gemma 4. Prefer Google's official QAT collection or a clearly identified, trusted GGUF publisher. - Open the available-downloads list and compare the model size, quantization, and LM Studio's fit warning.
- For the demonstrated 16GB computer, the creator downloaded a 7.15GB Gemma 4 12B QAT 4-bit file. E4B Q4 is a more conservative first download.
- Choose Use in New Chat, let the model load, and begin with a small, non-sensitive prompt.
- Enable Developer Mode if you want persistent timing and throughput statistics or need to verify detected hardware.
Thinking Mode Is the Largest Easy Speed Lever
With default thinking enabled, the creator's first 12B request spent about 18 seconds reasoning and reported 5.46 tokens per second. Disabling thinking made a simple conversational request begin answering almost immediately. That does not make the model intrinsically faster; it avoids generating an additional reasoning trace for a task that does not need one.
- Thinking off: simple rewriting, translation, short summaries, extraction, and routine formatting.
- Thinking on: difficult coding, planning, multi-step reasoning, and agentic work where the quality gain is measurable.
- Evaluate both: compare accepted results, time, and memory on ten representative examples instead of choosing by feel.
The Settings That Actually Matter
Context length
The demonstrated model loaded with an 8,192-token context. Reducing it to 4,096 saves memory and can improve responsiveness; increasing it allows larger documents but consumes more memory and can reduce performance. The 3,900-word chapter test used the 8,192-token setting and occupied 65.9% of the available context.
CPU thread pool
The creator increased the thread pool from four to six, matching the 5600G's physical cores, but saw only a small change within normal run-to-run variation. Do not assume every logical thread improves generation. Measure before keeping the change.
GPU and KV-cache offload
The 12B QAT model could not be partially offloaded in the creator's setup. A partial E4B Q_K_M offload to the integrated GPU provided no practical advantage, likely because CPU and GPU shared the same system memory and introduced another bottleneck. Offloading the KV cache with 2GB allocated to the integrated GPU did help. Current LM Studio builds can estimate memory and automatically choose GPU usage, so defaults are the correct baseline.
What the Creator Actually Tested
| Task | Result on 12B QAT | Useful lesson |
|---|---|---|
| Offline prose | Generated about 100 words on Southern Italy while the computer was disconnected. | Once downloaded, model inference can run without an internet connection. |
| Translation | Translated the answer into French. | Offline multilingual work is possible, but a fluent reviewer should verify important output. |
| Image understanding | Identified both a giraffe and a less-common okapi. | Multimodal capability is useful, but two images are a demonstration, not an accuracy benchmark. |
| Document summary | Reduced a 3,900-word book chapter to roughly 200 words. | Watch context use and compare summaries with the source before relying on them. |
| Python coding | Produced a working BMI calculator in about 1 minute 50 seconds. | Run and review generated code; one successful small program does not establish broader reliability. |
LM Studio can extract text from PDFs and documents for chat even when the model itself natively expects text and images. That convenience belongs to the application layer, so file support and model modality should not be treated as the same claim.
E4B Versus 12B: Faster Is Not Always Better
On the same machine, E4B produced about 11.75 tokens per second versus roughly 6 for 12B. It still recognized the giraffe but failed to identify the okapi, describing the image as an abstract texture. The larger model was slower and succeeded.
This is the central hardware lesson: select the smallest model that reliably completes your task. A fast failure is not useful, and a larger model that swaps memory or stalls may also be the wrong choice. Build a compact evaluation set containing common inputs, difficult edge cases, and the errors you cannot accept.
Practical Starter Settings
| Control | Begin with | Change it when |
|---|---|---|
| Model | E4B QAT Q4 GGUF | Move to 12B only if quality is insufficient and memory permits. |
| Context | 4K to 8K | Increase only when the actual input does not fit. |
| Thinking | Off for easy tasks | Enable for complex reasoning, coding, or agentic work. |
| Threads | LM Studio default | Test physical-core count and retain it only if measured performance improves. |
| GPU offload | Automatic | Adjust only after checking LM Studio's memory estimate and hardware detection. |
| Evaluation | Ten representative examples | Add every meaningful failure to the test set. |
LM Studio's current Windows requirements recommend at least 16GB RAM and 4GB dedicated VRAM, but the tutorial demonstrates that CPU and integrated-graphics inference can still be useful. Treat “recommended” as a performance target and the creator's test as evidence of feasibility, not a compatibility promise for every laptop.
Related Lesson: What Changes With Agentic AI?
The local chat workflow above produces answers. Agentic systems add tools, actions, files, and longer task loops, which increases both capability and risk. This companion ExplainingComputers episode provides the broader context.
Video Chapters
- 0:00 - Titles and introduction
- 0:56 - Choosing your model
- 4:25 - LM Studio
- 8:51 - Speed and application
- 13:55 - Images and text files
- 17:20 - Coding
- 18:57 - Gemma 4 E4B
- 21:31 - Wrap-up
Business Idea: A Private Document Workflow
The useful business angle is not selling "a local AI model." It is helping a team test one repetitive text workflow against clear quality and privacy requirements on hardware it already owns. This copy-ready prompt starts with a small pilot.
Test one private local-AI service
Measure answer quality, review effort, and speed before scaling.
Sources and Links
- ExplainingComputers: Running Gemma 4 Local AI
- ExplainingComputers YouTube channel
- LM Studio downloads: Bionic and classic LM Studio
- LM Studio: Introducing Bionic
- LM Studio: Get started
- LM Studio: System requirements
- LM Studio: Offline operation
- LM Studio: Per-model defaults
- Google AI for Developers: Gemma 4 overview and QAT guidance
- Google: Gemma 4 model card
- Google: official Gemma 4 collection on Hugging Face
- Google: official QAT Q4_0 files, including GGUF
- LM Studio: 12B QAT model listing
- Ollama: Gemma 4 tag sizes and formats
- LM Studio: current desktop app privacy policy
- ExplainingComputers: Explaining Agentic AI