OpenAI released gpt-oss as open-weight models, and the obvious question is whether you can run them yourself instead of going through a cloud API. You can, but you have to be honest about the hardware. gpt-oss comes in two sizes, gpt-oss-20b and gpt-oss-120b, and both are desktop and workstation class, not phone class: the smaller one needs roughly 16 GB of memory and the larger one roughly 80 GB. This gpt-oss local guide covers what each size needs, which Mac or PC handles it, which runtime and format to use, and why phone users should reach for a small 1B to 3B model instead. If you are shopping open weights more broadly, our best open-source LLM in 2026 and best local LLM models in 2026 roundups give the wider picture.
Want the short version? Jump to the summary table. Want private AI that actually fits on your phone? PocketLLM runs small models fully on-device with zero telemetry on your chats: join the launch list.
gpt-oss is real and open, but it is not a phone model. gpt-oss-20b wants about 16 GB of memory and gpt-oss-120b about 80 GB, so you run them on a capable Mac or PC, not on an iPhone. Use Ollama or LM Studio for the easy path, or llama.cpp and MLX if you want more control. If your goal is on-device AI on a phone, skip gpt-oss entirely and run a 1B to 3B model like Llama 3.2 3B or Phi-3.5 Mini at a 4-bit quant, which is exactly what PocketLLM is built for.
PocketLLM is launching soon. Private, on-device AI, starting on iPhone and iPad with more platforms planned. No account, no tracking, no cloud. Join the launch list and be first in.
Join the launch listgpt-oss is desktop-class: read this first
The most important thing to understand is that gpt-oss is not a small model. Open weights make it free to download and free of a cloud account, but they do not shrink the memory it needs. gpt-oss-20b targets a high-memory desktop or a well-specced Apple Silicon Mac; gpt-oss-120b targets workstation-class hardware, think 64 GB to 128 GB of memory, not a laptop. Headlines calling gpt-oss "small" or "efficient" mean relative to frontier cloud models, not relative to a phone.
What a gpt-oss local setup actually needs
The memory figures are the anchor for planning a gpt-oss local install. Per OpenAI's model card, gpt-oss-20b is designed to run within about 16 GB of memory and gpt-oss-120b within about 80 GB, assuming the native low-bit quantization the models ship with. Two caveats follow. First, you want headroom above the minimum: the KV cache grows as your conversation gets longer, and the runtime and operating system need their own memory, so treat 16 GB as a floor for the 20b model and prefer 24 GB or more. Second, file size on disk is not the same as memory needed while running; a model wants meaningfully more free memory than its download size once loaded. Our how much RAM for a local LLM guide breaks down how these numbers translate to your machine.
Both gpt-oss sizes are mixture-of-experts models, so only a portion of their parameters are active for any given token, which is part of how they stay runnable at 16 GB and 80 GB rather than needing memory proportional to their full parameter count. Treat any specific tokens-per-second claim with skepticism unless it names the exact hardware and quant, because those numbers vary enormously.
Which machine can run gpt-oss
For gpt-oss-20b, a modern Apple Silicon Mac with 24 GB or more of unified memory is a comfortable target, as is a PC with enough GPU VRAM or system RAM. gpt-oss-120b is workstation territory: a high-memory Mac Studio or Mac Pro, or a PC with a large-VRAM GPU or a lot of system memory. Our best Mac for local LLM in 2026 guide compares the Apple Silicon options by memory and value. The rule holds across platforms: unified or graphics memory is the bottleneck, not clock speed, so buy for memory first.
GGUF, MLX, and which runtime to use
Two terms come up constantly and they are not interchangeable. GGUF is a model file format used by llama.cpp-style runtimes such as Ollama and LM Studio; it is portable across macOS, Windows, and Linux. MLX is Apple's machine-learning framework for Apple Silicon, with its own model format often converted from the original weights. So the fair comparison is not "GGUF vs MLX" but "GGUF with llama.cpp vs MLX," two different runtime paths. On Apple Silicon, MLX can be very efficient; GGUF with llama.cpp is the most portable and widely supported route. Quantization is the lever that makes large models fit at all: our quantization explained and what are GGUF models posts cover it, and Ollama vs LM Studio vs PocketLLM compares the desktop apps.
Steps to run gpt-oss locally
The commands below are representative; check your runtime's model library for exact tag names, since these change over time.
- Confirm your memory. Aim for at least 16 GB free for gpt-oss-20b, or a workstation-class machine (roughly 80 GB) for gpt-oss-120b. If you are short, stop here and pick a smaller model.
- Install a runtime. Ollama or LM Studio are the easiest starting points and both run fully offline once the model is downloaded. For more control, use llama.cpp directly, or MLX on Apple Silicon.
- Download the model. In Ollama, pull the gpt-oss model by its tag (for example, the 20b size); in LM Studio, search for gpt-oss and download a quantized build that fits your memory.
- Run and chat offline. Once the weights are local, disconnect from the network to prove nothing is leaving the machine. Everything runs on your own hardware from here.
Why phone users should pick a small model instead
If you found this page hoping to run gpt-oss on an iPhone or iPad, the honest answer is that you cannot, and that is fine, because you do not need it. A phone has a fixed, modest memory budget, and iOS caps how much any single app may use. Recent iPhone "Pro" models carry roughly 8 GB of RAM, with base tiers in the 6 GB to 8 GB range (Apple does not always publish per-model figures, so treat those as approximate). That is nowhere near the 16 GB gpt-oss-20b wants. The right pick for a phone is a 1B to 3B model: Llama 3.2 3B at a 4-bit quant lands around 2 GB on disk and runs at roughly 30 or more tokens per second on M2-class hardware, and Phi-3.5 Mini (about 3.8B) sits near 2.2 GB. Both are genuinely useful for chat, drafting, and summarizing. For the phone-class landscape, see best small language models in 2026 and best on-device LLM apps for iPhone.
The summary table
| Model | Approx memory / size | Class | Fits a phone? | PocketLLM | Source |
|---|---|---|---|---|---|
| gpt-oss-120b | ~80 GB | Workstation | No | Out of range | Model card |
| gpt-oss-20b | ~16 GB | High-RAM desktop / Mac | No | Out of range | Model card |
| Qwen 2.5 7B (Q4) | ~4.5 GB file, wants ~8 GB RAM | 16 GB laptop / Mac | Marginal | Edge of range | Estimate |
| Phi-3.5 Mini ~3.8B (Q4) | ~2.2 GB file | Phone / Mac | Yes | In range (GGUF) | Estimate |
| Llama 3.2 3B (Q4) | ~2 GB file | Phone / Mac | Yes | In range (GGUF) | Estimate |
File sizes above are on-disk figures at a 4-bit quant, not the memory a model needs while running; the running footprint is higher once you add the KV cache, runtime, and OS. Verify current specifications on each model's official card before committing hardware.
Keeping a local model private
The privacy upside of running gpt-oss yourself is real: an open-weight model on your own machine, used offline, never sends your prompts to anyone, unlike a hosted API where your inputs travel to a provider's servers. The catch is purely practical: the hardware. On a phone you get the same offline privacy from a small on-device model, without the workstation. That is the design behind PocketLLM: models run locally through llama.cpp on your device, there is no account, and we collect zero telemetry on your prompts or responses. gpt-oss does not ship in PocketLLM and is not a phone model; the point of this guide is to route the right model to the right hardware.
Frequently asked questions
Can I run gpt-oss on my iPhone?
No. Both gpt-oss models are desktop and workstation class. gpt-oss-20b needs roughly 16 GB of memory and gpt-oss-120b needs roughly 80 GB, which is far beyond what any current iPhone can dedicate to a single app. On a phone you want a 1B to 3B model instead, such as Llama 3.2 3B or Phi-3.5 Mini at a 4-bit quant, which fit in a couple of gigabytes and still leave headroom for the KV cache and the operating system. Those small on-device models are what PocketLLM is built around.
How much memory do I need for a gpt-oss local setup?
For a gpt-oss local setup, plan for about 16 GB of free memory to run gpt-oss-20b and about 80 GB to run gpt-oss-120b, per OpenAI's model card. Those figures assume the native low-bit quantization the models ship with. In practice you want headroom above the minimum for the context window and the runtime, so a 24 GB or larger machine is more comfortable for the 20b model, and the 120b model realistically wants a workstation or a high-memory Apple Silicon Mac. File size on disk is not the same as the memory needed while the model is running.
What is the difference between gpt-oss-20b and gpt-oss-120b?
They are two sizes of the same open-weight family. gpt-oss-20b is the smaller model that targets a single high-memory desktop or Mac and needs around 16 GB of memory. gpt-oss-120b is the larger model that targets workstation-class hardware and needs around 80 GB. The larger model is generally stronger on hard reasoning, but it is far heavier to host. Both are mixture-of-experts designs, so only a portion of their parameters are active for any given token, which is part of how they stay runnable at those memory figures. Confirm the exact specifications on the official model card before you commit to hardware.
Should I use GGUF or MLX to run gpt-oss on a Mac?
It depends on your runtime. GGUF is a model file format used by llama.cpp-style runtimes such as Ollama and LM Studio, and it runs across many platforms. MLX is Apple's machine-learning framework for Apple Silicon and uses its own model format, often converted from the original weights. On an Apple Silicon Mac, MLX can be very efficient, while GGUF with llama.cpp is the most portable and widely supported path. Either can work; pick the one your chosen app supports and that matches your Mac's memory.
Does PocketLLM run gpt-oss?
No. PocketLLM focuses on models that fit comfortably on a phone, which means roughly 1B to 3B parameter models in the GGUF format running through llama.cpp on-device. gpt-oss-20b and gpt-oss-120b are desktop and workstation class and are far too large for that. PocketLLM is pre-launch and runs fully on-device with no account and zero telemetry on your conversations. If you want gpt-oss specifically, run it on a capable Mac or PC using a desktop runtime; if you want private AI on your phone, a small on-device model is the right tool.