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 taking first place in the post is described as a MoE (Mixture of Experts) model also known within the community as “Qwen 3.6 35B-A3B.” Its official name is Qwen3-Coder-30B-A3B-Instruct, and it has been confirmed for distribution via Hugging Face’s official repository and Ollama (tag: qwen3-coder:30b). While the post cites a figure of 35B parameters, the official total parameter count is based on 30B. Although naming conventions vary by habit, there should be no issue in viewing them as referring to the same lineage.

The defining characteristic of this model lies in its MoE structure, which presents a duality: “heavyweight in terms of total parameters but mid-weight regarding weights actually active during inference.” It is designed such that only specific layers relevant to a given task are selectively activated, often resulting in surprisingly light and fast speeds despite the large overall size.

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 weights equivalent to approximately 3.3B are active during inference. It is considered a size that can realistically fit even on VRAM like the RTX 5060 Ti 16GB if quantization is applied effectively, making it an ideal design for those seeking to balance both accuracy and speed.

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 download size during the initial pull is approximately 18GB (for the Q4_K_M quantized version). During execution, monitor VRAM usage via nvidia-smi; if necessary, you can adjust the number of GPU offloaded layers using the OLLAMA_NUM_GPU environment variable, allowing for smooth operation even in a 16GB VRAM environment.

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

The Qwen3-Coder-30B-A3B-Instruct holds value as a first-choice option. Thanks to its MoE structure, it runs surprisingly lightly relative to its total parameter count. Our site’s measurements showed 26–32 tok/s on an RTX 5060 Ti 16GB; with either high-end laptop configurations or desktop machines equipped with ~16GB VRAM GPUs, daily use is feasible. For environments where memory is tight, a straightforward fallback to the cost-performance option of Qwen 2.5 Coder 7B is the practical solution.

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 highest accuracy with Qwen3-Coder-30B-A3B-Instruct, seek daily balance with Qwen 2.5 Coder 7B, or choose the small high-speed category of Phi 4 Mini 3.8B.” By centering your choice on these three and adjusting for local hardware and use cases, you are unlikely to go far off course. Simultaneously, it is crucial not to 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