Back to the blog
AIApplemacOSBun

Apple is building a Mac app to run local AI: what changes

November 12, 2026·6 min read·Diego Horvatti

Apple has a new Mac app on the way, and the pitch is to make life easier for anyone who wants to run AI models on their own machine. The report comes from 9to5Mac. If you have ever tried to run local AI on a Mac, you know installing was never the hard part. The hard part is picking the model, figuring out whether it fits in memory and plugging it into your code.

I won't retell the article here. You can check the name, date and requirements at the source. What interests me is a different question: what does this change for people who write code?

What Apple is building

The fact is simple. According to 9to5Mac, a Mac app made by Apple itself is coming, focused on making it easy to run local AI models.

This fits a story that was already being assembled piece by piece:

  • MLX: Apple's open source framework for running and training models on Apple Silicon. It has been around since late 2023 and became the community standard on the Mac.
  • Foundation Models: the framework introduced at WWDC 2025 that gives you access, through Swift, to the model running on the device itself.

The pieces were good, but all of them required a terminal or Xcode. A front door was missing. Today that space is filled by third-party tools like Ollama and LM Studio. An official app lands exactly there.

Why running local AI on a Mac makes sense

The reason is hardware. On Apple Silicon, memory is unified: CPU and GPU share the same RAM. On a PC, the model has to fit in the graphics card's VRAM, and a 24 GB card is expensive. On a Mac with 32 GB, a good chunk of those 32 GB is available to the model.

In practice, the math goes roughly like this:

  • A 7B model quantized to 4 bits takes up around 5 GB.
  • A 14B one sits in the 9 GB range.
  • A 32B one goes past 20 GB.

Since late 2024, the most basic Mac ships with 16 GB. That runs a 7B model comfortably and a 14B one with the browser closed. The 32B ones ask for 32 GB or more, and a fan that is up for the job.

The best local model is the one that fits in your RAM and answers before you lose your patience.

There is also the side no benchmark shows. Client code, production logs and personal data never leave the machine. There is no per-token bill. And it works on a plane.

How to run a local model today, without waiting for Apple

You don't need to wait for the app to test the idea. With Ollama, it takes three commands:

brew install ollama
ollama serve
ollama pull qwen2.5-coder:7b

Ollama starts a server on localhost:11434 with an API compatible with OpenAI's. That is the detail that matters: any code that speaks this format works without changes.

A real example with Bun. A script that reads the staged diff and suggests a commit message:

// commit-msg.ts
import { $ } from 'bun'

const baseURL = process.env.LLM_BASE_URL ?? 'http://localhost:11434/v1'
const model = process.env.LLM_MODEL ?? 'qwen2.5-coder:7b'

const diff = await $`git diff --staged`.text()

const res = await fetch(`${baseURL}/chat/completions`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model,
    messages: [
      { role: 'system', content: 'Write a short commit message, in English.' },
      { role: 'user', content: diff },
    ],
  }),
})

const { choices } = await res.json()
console.log(choices[0].message.content)

Run it with bun commit-msg.ts. No SDK, no API key, no dependencies.

Notice the two environment variables at the top. They are the most important part of the script. Today they point to Ollama. Tomorrow they can point to LM Studio, to a cloud provider or, if Apple's app exposes a local server in this format, to that. Your code doesn't need to know who is on the other side.

What changes in your workflow

Being honest: a local model won't replace the big model you use in your editor. A 7B doesn't refactor ten files with a long context. Anyone promising that is selling something.

Where it works well is on small, repetitive tasks:

  • Commit messages and diff summaries.
  • Classifying or extracting fields from text, like logs and tickets.
  • Generating embeddings for an internal semantic search.
  • Anything involving data that can't leave the company.

Where it struggles:

  • Agents with many tool calls in a row.
  • Large context, like an entire monorepo.
  • Tasks where mistakes are expensive and nobody reviews the output.

What an official app changes is friction. Today, suggesting local AI to your team means writing an install tutorial and hoping for the best. If it ships with the system, or sits one click away on the App Store, it becomes something you can assume your teammate has. That changes what you can put in a project script or a pre-commit hook.

What I want to see before I get excited

Three questions decide whether this app will be useful for devs or just pretty in the keynote.

Does it expose a local API? A chat window is nice for testing. To integrate with code, you need an endpoint. If it is compatible with the OpenAI format, even better, because the whole ecosystem already speaks it.

Can it run any open model? If the app only accepts a closed catalog, it loses to Ollama on day one. The fun of local AI is switching models when a better one comes out, and a better one comes out every month.

How does it handle memory? The classic beginner mistake is downloading a model bigger than your RAM and watching the Mac choke on swap. An Apple app knows the hardware better than anyone. Saying "this model won't fit on your machine" before the download would already be a huge step forward.

Is it worth waiting for Apple's app?

No. It is worth testing today, with what already exists, and leaving your code ready to switch servers.

My strong opinion: the problem with local AI was never installation. It was expectation. Someone downloads a 5 GB model, compares it with the best model in the cloud, gets disappointed and uninstalls it. An easier app solves the first step and doesn't change that comparison. What changes the game is knowing which task deserves a local model and which one doesn't.

That said, I hope it works out. When the hardware maker takes ownership of the experience, the floor rises for everyone, including the competitors. And competition in this space is good for people who write code.

If you want to see how I use these tools in real products, take a look at my projects.

LinkedIn summary

The problem with local AI was never installation. It was expectation.

Apple is working on a Mac app to make it easier to run models on your own machine, according to 9to5Mac. I hope it works out, but it only solves the first step.

A 7B model takes up around 5 GB and runs comfortably on a 16 GB Mac. But it won't refactor your monorepo. It does well on small, repetitive tasks: commit messages, diff summaries, log classification, data that can't leave the company.

If you download a 5 GB model, compare it with the best one in the cloud and uninstall it, you made the wrong comparison.

My advice: don't wait for Apple. Three commands with Ollama get you there today, and two environment variables leave your code ready to switch servers later.

On the blog, I wrote down the three questions I want answered before I get excited. If you already run local AI, tell me what you use it for.

#LocalAI #AppleSilicon #Ollama #Bun #SoftwareDevelopment