Ollama v0.40.4-rc0 Released: What the MLX Version Upgrade Means

Ollama has released the pre-release version v0.40.4-rc0. This update may look like just a minor version bump, but the signal behind it is worth paying attention to.

A "low-key" version update

According to the release record on GitHub, v0.40.4-rc0 corresponds to commit 374d97d, tagged by developer dhiltgen. The entire release's changes can be summarized in one sentence: a version upgrade of MLX and MLX-C (PR #18956).

No new features, no API changes, no breaking changes. On the surface, this looks more like routine maintenance.

But if you understand Ollama's technical roadmap on Apple Silicon, you'll know that an MLX version upgrade is by no means a trivial matter.

Why MLX matters so much to Ollama

MLX is a machine learning framework built by Apple for its own chips (the M series), specifically optimized for the unified memory architecture. When Ollama runs local large models on macOS, MLX is one of the key inference backends.

MLX-C is the C language binding layer for MLX. Ollama's core is written in Go, but the inference part needs to call low-level high-performance computing libraries. MLX-C is that bridge.

In other words, a version upgrade of MLX and MLX-C directly affects Ollama's inference performance, memory usage, and model compatibility on Mac. For the large number of users running local models on MacBooks, the actual experience of this change may be far greater than what the version number suggests.

Unified Memory Architecture is a fundamental design of Apple Silicon: the CPU, GPU, and neural engine share the same physical memory pool, rather than moving data between CPU memory and discrete VRAM as in traditional PCs. This is hugely significant for local large model inference — after model weights are loaded, there's no need to repeatedly copy them between devices, avoiding the PCIe transfer bottleneck and freeing the available "VRAM" from the capacity limits of discrete graphics cards. MLX is precisely a framework designed around this characteristic. It uses lazy evaluation and unified memory addressing, allowing operator scheduling to utilize both CPU and GPU simultaneously without explicit data movement. This is also why Ollama on Mac can run relatively large models within comparatively limited unified memory, whereas the same amount of memory on a discrete GPU platform is often stretched thin. Only by understanding this can one grasp why an MLX version upgrade directly affects inference performance and memory usage.

MLX-C is the C language interface layer of MLX, and its existence solves the cross-language calling problem. Ollama's main body is written in Go, handling upper-layer logic such as model management, HTTP services, and scheduling, but high-performance tensor computation must rely on low-level libraries. Go calls C interfaces through the cgo mechanism, so MLX needs to first expose a stable set of C APIs, which Ollama's Go code then binds and calls. This layer of indirection has two consequences: first, if the MLX-C interfaces change, Ollama's binding code must be adapted in sync, otherwise compilation may fail or behavior may become abnormal; second, the abstraction of the C interface layer may shield some new MLX features, preventing underlying capabilities from being immediately leveraged by the upper layer. Therefore, each synchronized upgrade of MLX and MLX-C is in fact a coordinated effort spanning three layers — Python, C, and Go — and its verification complexity is far higher than a mere version number change.

The signal of a pre-release version

The -rc0 suffix indicates that this is the first release candidate. The Ollama team choosing to release an RC version first usually means the changes need more real-world validation — especially when low-level compute library upgrades are involved, as different Apple chip models (M1/M2/M3/M4) may exhibit different compatibility behavior.

From an engineering practice perspective, this caution is reasonable. MLX itself iterates very quickly, and each version jump may introduce API changes or fine-tuning of numerical precision, which are hard to fully cover in a CI environment.

Numerical precision is the most easily overlooked yet most directly impactful issue in low-level compute library upgrades. Large model inference involves a huge amount of floating-point operations, and MLX may adjust operator implementations, accumulation order, or adopt different low-precision formats (such as rounding strategies for bf16 and fp16) between versions. These changes are mathematically equivalent, but under finite precision they produce tiny differences, which after accumulating through dozens of network layers may manifest as changes in output text wording, repetition, or garbled text. This is also why low-level library upgrades must undergo validation on long text and multiple models in real environments; unit tests and CI with short prompts alone cannot cover this. The M1 through M4 chip generations differ in matrix units, memory bandwidth, and instruction sets, and the same MLX code may trigger different operator paths on different chips, further amplifying regression risk.

What users should do now

If you're using Ollama to run local models, especially as a Mac user, there are a few things worth noting:

• It's not recommended to upgrade to an RC version immediately in production environments. The value of a pre-release version lies in helping developers find problems, not in pursuing stability.
• Pay attention to changes in the MLX version number. If you've previously encountered abnormal inference, garbled output, or performance fluctuations with certain models on Mac, the new version may have fixed these issues.
• Performance may differ across Apple Silicon chip generations. The M4 series and earlier M1 do not have entirely identical optimization paths on MLX, so after upgrading it's worth watching for changes in actual inference speed.

For teams using Ollama as a development tool or AI application infrastructure, it's fine to wait for the official release before following up. But if your project is sensitive to Mac local inference performance, validating the RC version in a test environment in advance is worthwhile.

Summary

v0.40.4-rc0 is a typical "small version, big dependency" update. The version number only jumped in the patch position, but the MLX upgrade may have a considerable impact on the actual experience of Apple Silicon users. Ollama continues to polish Mac-side performance on the path of local inference, and this direction itself demonstrates the importance of Apple chips in local AI inference scenarios.

One-line Summary

Although Ollama v0.40.4-rc0 only upgrades MLX, it affects Mac local inference performance and compatibility.

Paragraph Summary

Ollama has released the pre-release version v0.40.4-rc0. On the surface it's just a patch-position version bump, with the core change being only a version upgrade of MLX and MLX-C, with no new features or breaking changes. But MLX is a machine learning framework built by Apple for M-series chips and optimized for the unified memory architecture, and it is a key backend for Ollama's inference on macOS; MLX-C is its C language binding, connecting the Go main body with low-level computation. Therefore this upgrade directly affects Mac users' inference performance, memory usage, and model compatibility, and its actual impact may be far greater than the version number suggests. The RC suffix means real-world validation is needed, and performance may differ across Apple chip generations. The article recommends not upgrading to the RC in production for now, but Mac users can watch for fixes to inference anomalies, and teams should wait for the official release.