MacBook Air M5: 21 Local LLMs Benchmarked for Coding Speed & Quality

Local LLMs refer to large language models that run inference locally on a user’s PC in a closed environment.

A post circulating within the overseas Reddit community (r/LocalLLaMA) has garnered significant attention. It details a simultaneous verification of 21 local LLMs using a MacBook Air M5, evaluating coding performance via HumanEval+ and inference speed. The pass@1-based evaluation metrics established under identical conditions are attracting interest as primary data to reduce the confusion surrounding the selection of local LLMs. We use these benchmark results as a starting point, juxtaposing them with our own site’s measured data accumulated from our desktop GPU environment (RTX 5080 16GB / RTX 5060 Ti 16GB / i7-14700F / RAM 96GB), to organize the information into a format that allows for determining which model should run on which hardware.

Verification of 21 Models on MacBook Air M5 Reveals Three Trends

The core message of the viral post is clear. It subjected 21 models to HumanEval+ (a pass@1 metric for a set of 164 coding problems) under identical conditions, comparing accuracy, speed, and memory usage on a MacBook Air M5. The author has adopted a policy of avoiding subjective evaluations in favor of visualizing pros and cons through numerical data.

The trends discernible from the results can be summarized into three points: top-tier coding precision is concentrated within the Qwen series; among medium-sized models (7B class), an “hidden honor student” emerges that balances accuracy, speed, and memory usage well; and some models expected as next-generation contenders scored lower than anticipated.

How to Interpret Evaluation Metrics and Assumptions

HumanEval+ is described as a metric extending the original HumanEval with an expanded problem set for greater coverage. There are also indications that scores tend to be stricter, as models must withstand exceptional inputs on identical problems to be considered correct. pass@1 represents “the proportion of times the model reaches the correct solution in a single generation” and is treated as a stringent metric closer to real-world operations.

Conversely, speed (tok/s) depends heavily on model weight and architecture, while memory usage correlates directly with quantization levels. Since these factors are presented side-by-side in the original Reddit post, one must look beyond simply selecting from top-down rankings; it is crucial to determine “what can realistically run on your local hardware.” Benchmarks serve not as answers but as maps—materials for deciding which destination to aim for based on the reader’s PC environment.

The Power of Top-Ranked Qwen3-Coder-30B-A3B-Instruct and the Upper Group

The model that took first place in the post is Qwen3-Coder-30B-A3B-Instruct (MoE / Mixture of Experts). It is distributed through the official Hugging Face repository and Ollama’s official library (qwen3-coder:30b), and its official total parameter count is 30.5B (3.3B active). The post wrote it as “35B,” but be careful not to confuse it with Qwen3.6-35B-A3B, a different model with a similar name (released in April 2026, 35B total parameters with 256 experts, a multimodal model that also handles images and video). The model this article measures and recommends is the coding-focused Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b).

The defining characteristic of this model is a duality created by its MoE structure: “heavyweight in total parameters, mid-weight in the weights used for computation per token.” No layer sits idle. Instead, each layer holds many experts, and only a few of them are selected and computed for each token. Because fewer weights are read for each token, it runs far faster than its total size would suggest.

Qwen3-Coder-30B-A3B is a Mixture-of-Experts (MoE) model with 30.5B total parameters and 3.3B activated parameters, designed for agentic coding tasks.
— Hugging Face Official Model Card Qwen/Qwen3-Coder-30B-A3B-Instruct

In other words, only about 3.3B worth of weights are used to compute each token. However, “3.3B active” does not mean “3.3B worth of memory is enough.” Which experts are selected changes from token to token and from layer to layer, so all 30.5B worth of weights must be kept in memory. MoE reduces the amount of computation, not the memory required. In fact, the file for Ollama’s standard tag qwen3-coder:30b (Q4_K_M) is about 19GB, which does not fit on a single 16GB VRAM card. Fast yet heavy: that is the character of this model (what to do on a 16GB setup is summarized after the measured comparison below).

Installation Steps via Ollama

To run Qwen3-Coder-30B-A3B in our site’s environment, using Ollama proved the most straightforward method. You can acquire and execute the model with the following commands:

ollama pull qwen3-coder:30b ollama run qwen3-coder:30b "Write a Python function to compute Fibonacci"

The initial pull downloads about 19GB (the Q4_K_M quantized version), as shown in Ollama’s official library. On a single 16GB card, it runs with part of the model offloaded to the CPU. To check how much actually landed on the GPU, look at the PROCESSOR column of ollama ps (a placement ratio such as 100% GPU or 48%/52% CPU/GPU), or the ratio of size_vram to size returned by /api/ps.

Roster and Specialization of the Upper Group

Following Qwen3-Coder-30B-A3B-Instruct at the top are other models from the same family: Coder 32B, Coder 14B, and Coder 7B. The trend that “top-tier accuracy belongs to the Qwen series” remains consistent here. It is a natural result that models specifically tuned for coding excel in this domain, holding an advantage over general-purpose models when it comes to code generation.

However, as one moves up the rankings, required memory jumps significantly. There are also concerns regarding continuous operation on fanless designs like the MacBook Air M5. Note up front that “first place does not equal ‘optimal for everyone'”.

Comparison with Our Site’s GPU Measured Values

Since the original Reddit post uses a MacBook Air M5 as its baseline, it is worth examining how results differ in a desktop GPU environment. The following table presents our measurement results using identical conditions (Ollama 0.23.x / Q4_K_M quantization / average of 30 short prompts) for top/mid-tier and small models from the original post within our verification environment (RTX 5080 16GB + RTX 5060 Ti 16GB / i7-14700F / RAM 96GB).

The difference between the RTX 5080 and RTX 5060 Ti manifests as a speed gap of roughly 30–40%. Although both possess 16GB VRAM, results indicate that differences in memory bandwidth and CUDA core counts directly impact inference speeds. The Qwen 2.5 Coder 32B does not fit entirely within the 16GB VRAM, triggering CPU offloading which causes a significant drop in tok/s. It is considered that VRAM of at least 24GB class is a realistic threshold for running full 32B-class models.

Cost-Performance Options, Small Honor Students, and Gemma 4’s Slump

Gazing at the post’s numbers reveals several noteworthy positions beyond just the top tier.

The Cost-Performance Option: Qwen 2.5 Coder 7B

The model easiest to evaluate as a “MVP candidate for the overall benchmarks” is the Qwen 2.5 Coder 7B. Its accuracy approaches that of the top tier, yet memory usage remains within mid-range levels, and speed falls into an area suitable for daily use. Even on our site’s RTX 5060 Ti 16GB, we consistently observed measured speeds of 56–68 tok/s; it is a range where models can realistically run even on laptops with system memory around the 16GB class. For those seeking coding assistance in their daily workflow, finding a better balance than this would be difficult.

The Small Honor Student: Phi 4 Mini 3.8B

Another model worth noting is the Phi 4 Mini 3.8B. Despite ranking low in parameter count, it secured a position capable of outperforming mid-tier models on the post’s accuracy table and belongs to the high-speed group. In our site’s RTX 5080 environment, measured speeds reached 128–145 tok/s with VRAM usage contained at approximately 3.1GB. This is a strong option for environments where memory is tight or when response speed is the top priority.

Small Classes Can Still Be Practical Depending on Use Case

In r/LocalLLaMA, voices from the community suggest that even small models in the 1.7B class can be sufficiently operational if they align well with specific use cases. For lightweight chatbot assistance, code autocompletion, or automation of routine tasks, there are scenarios where response speed and low memory usage outweigh raw accuracy; it appears this is an area where “benchmark ranking = adoption priority” cannot simply apply.

What Is Happening with Gemma 4’s Slump?

A striking observation is the poor performance of the Gemma 4 series. The author emphasized that they reproduced results where “Gemma 4 31B scored lower than Llama 3.2 1B” multiple times, leaving a divided opinion on whether this reflects an inherent weakness in the model itself or incompatibility with benchmark measurement conditions.

There is also a view that it is too early to definitively state “Gemma 4 is weak.” New generation models may handle pre-processing layers and templates differently than previous generations; there have been past reports where execution environments like llama.cpp failed to keep up with updates, causing scores to appear unfairly low. While the author’s stance is sound, rather than concluding this low score as a “defect in model performance,” it would be more honest to interpret “benchmark results as an evaluation inclusive of execution environment and quantization.”

Practical Perspectives: Fanless Design and Overall Environment

In r/LocalLLaMA, the view that peripheral execution environments determine user experience more than individual model superiority is repeatedly discussed. Similar trends are consistently reflected in reactions to the original post as well.

The Impact of MacBook Air M5’s Fanless Design

The M5 MacBook Air features a fanless structure. The fact that this hardware was used for verification has an undeniable impact on how one interprets the numbers. While speeds close to published values may be achieved during short inference sessions, continuous generation over long periods could cause chassis temperatures to reach thresholds, leading to thermal throttling and reduced effective performance—a characteristic repeatedly reported in similar thin-form-factor devices.

Benchmark tok/s figures tend toward “peak burst speed,” meaning different numbers might emerge for real-world operations involving heavy processing throughout the day. Drawing conclusions solely from this post’s data is difficult; separate continuous operation tests are desirable here.

In our site’s desktop GPU environment (RTX 5080 16GB + RTX 5060 Ti 16GB / i7-14700F / RAM 96GB), there is ample cooling headroom, making speed degradation during long-term operation less likely; the user experience differs even with identical models. In a case where we ran continuous generation for two hours using Qwen3-Coder-30B-A3B, GPU temperatures remained around 60°C, and tok/s fluctuations stayed within ±5%. Whether to consolidate on a laptop or offload to a desktop machine—a choice that impacts practicality more than the weight of the model itself—is often decisive.

Overall Environment Design Determines Experience

A prominent trend in comments from r/LocalLLaMA is an increasing number of users discussing configurations rather than specific model names, such as “Ollama + Open WebUI + SearXNG.” There are indications that if even one component—execution runtime (e.g., llama.cpp or Ollama), frontend interface, presence of RAG, quantization choice, GPU offload ratio, or maximum input length—is incompatible, daily use can become difficult even for top-ranked benchmark models. Rather than chasing the #1 spot in benchmarks, users are likely to achieve higher satisfaction by selecting based on “which configuration will still be usable after two weeks.”

Recommendations and Selection Guidelines by Use Case

We abstractize benchmark values into performance tiers while organizing selection guidelines for different use cases.

If Image Generation (Stable Diffusion, ComfyUI, etc.) is the Main Focus

This discussion moves beyond just language models. If image generation is your primary use case, these benchmark results are largely irrelevant. Image generation relies primarily on VRAM capacity and bandwidth; it should be selected with a desktop GPU environment in mind. Running entirely on a MacBook Air is not realistic; securing at least an RTX 5060 Ti 16GB class or higher desktop machine would be the rational approach.

If Local LLM Inference (Ollama, etc.) is the Main Focus

Qwen3-Coder-30B-A3B-Instruct is worth making your first choice. Thanks to its MoE structure, its strength is that it runs fast for its total parameter count. But speed and lightness are different things. To load it fully onto the GPU, you need two 16GB cards (32GB total) or a 24GB-class card (the standard tag’s file is about 19GB and does not fit on a single 16GB card). Dropping to a Q3_K_M-class quantization (about 15GB) might let it fit on a single 16GB card, but memory for the context is also needed, so check on your own machine whether it actually fits. Lowering the quantization also lowers output quality. If memory is tight, the practical answer is to simply fall back to the cost-performance pick, Qwen 2.5 Coder 7B.

If AI Coding Tools (Claude Code / Copilot, etc.) are the Main Focus

In this use case, cloud API-based tools remain more mainstream than local LLMs; on the PC side, performance depends less on GPUs and more on CPU/RAM/SSD speed. If using a configuration that includes local completion assistance, small high-speed models like Phi 4 Mini 3.8B are strong candidates. Since immediate response times dictate the working experience, prioritizing speed over top-tier accuracy is often the rational choice.

If Budget and Low Memory Usage Are Top Priorities

This points almost exclusively to Qwen 2.5 Coder 7B. Its accuracy approaches that of the upper tier while keeping memory usage in check, allowing it to run realistically even on laptops with system memory around the 16GB class. If asked “which one should be installed as a single choice,” this would likely be the first candidate.

Summary and Questions for Readers

The conclusion drawn from this verification is clear: “Aim for the highest accuracy with Qwen3-Coder-30B-A3B-Instruct, a balanced daily setup with Qwen 2.5 Coder 7B, or the small, fast, memory-light option with Phi 4 Mini 3.8B.” That said, the top-accuracy pick, Qwen3-Coder-30B-A3B, does not fit on a single 16GB VRAM card with its standard tag (Q4_K_M, about 19GB). Using it means accepting one of three trade-offs: accept CPU offload, drop the quantization a step, or prepare two 16GB cards (32GB total) or more. If you choose among these three models and adjust for your hardware and use case, you are unlikely to go far wrong. At the same time, do not forget that benchmark winners are merely ‘winners at this specific moment in a specific environment’. The user experience changes significantly if any element—quantization settings, execution runtime, frontend interface, or cooling conditions—is lacking.

Our site continuously measures local LLMs on desktop environments with RTX 5080 16GB and RTX 5060 Ti 16GB; we observe that the focus of model selection differs clearly between thin-form-factor machines and dedicated GPUs. Environments with effective cooling tend to lean toward “stably running heavier models,” while thinner devices trend more towards “selecting lighter models prioritizing response speed.”

We ask readers: Are you choosing based on “Benchmark #1” or are you selecting a configuration that will still be in use after two weeks?” There is no single correct answer; it depends on which fits your workflow rhythm better. We would love to hear from you via the comments section or search feedback.

This site is a participant in the Amazon Services LLC Associates Program. As an Amazon Associate, we earn from qualifying purchases.

References

• Hugging Face Official: Qwen3-Coder-30B-A3B-Instruct Model Card
• Ollama Official: qwen3-coder Library
• GitHub Official: EvalPlus (HumanEval+ Benchmark)
• NVIDIA Official: GeForce RTX 5080 Product Page
• Apple Official: MacBook Air Product Page