On October 28, 2026, the team behind Draw Things quietly released something that Mac owners had been asking for for years: Local Code Mac, a free, open-source AI assistant that runs entirely on your own computer. There is no monthly subscription for the core app, no account to create before you start, and, when you use a local model, no cloud server ever sees your prompts or your files. You download a model once, and the assistant works from your Mac, even when your internet connection is down.
That combination, free, private, and genuinely useful, is rare in the AI world. Most assistants that feel powerful live in the cloud, which means your documents, your notes, and your questions travel to someone else’s servers. The assistants that run locally have often felt like hobby projects, slow, fiddly, and limited to a single job. Local Code Mac tries to close that gap. It is a full assistant, not a single-purpose tool: it can write documents, build slide decks, analyse spreadsheets, edit images and video, write code, and even visit websites on your behalf, all with the tools it needs built in.
This guide explains what Local Code Mac actually is, how it works, which Mac you need to run it well, what it costs, and where its limits honestly sit. If you own a Mac and you care about privacy, or you simply do not want another monthly AI bill, this is one of the most interesting launches of October 2026, and it is worth understanding properly before you download anything.

Table of Contents
- What Is It?
- At a Glance
- How It Works
- What It Can Do
- Which Model Should You Download? The Memory and Storage Guide
- Privacy: What Stays on Your Mac and What Does Not
- How to Get Started
- Pricing
- Vs Cloud AI Assistants
- Who Should Use It, and Who Should Wait
- Limitations and Honest Caveats
- FAQ
- The Verdict: A Serious Free Assistant With One Big Download
What Is Local Code Mac?
Local Code Mac is an open-source AI assistant for the Mac, built by Draw Things, the team behind the well-known image and video generation app of the same name. The idea is simple to state and hard to build: give ordinary Mac users a capable AI agent that runs on their own machine, with everything it needs included in the download, so they never have to install developer tools, configure servers, or hand their data to a cloud provider.
When you first open Local Code Mac, you pick a model from a built-in selector and download it to your Mac. The app then suggests a model based on how much memory your machine has, so you do not have to guess which one will run well. Once the download finishes, you can start asking it to do things, in plain language, just as you would with a cloud chatbot. The difference is where the thinking happens. With a local model, the model runs on your Mac’s own processor, and your prompts and files are processed locally rather than sent to an AI company’s servers.
Local Code Mac followed a public beta that began on September 12, 2026, and its full release post is dated October 28, 2026. MacRumors covered the launch on October 30, 2026, and several independent guides followed within days, which is a good sign for a new tool: it means people outside the company have actually tried it and found it worth writing about. A direct Mac download is available now from the official site, and the developers say a Mac App Store release is coming soon, though at the time of writing it had not yet appeared there.
It is also worth understanding what Local Code Mac is not. It is not a chatbot that lives in your browser, not a plugin for another app, and not a stripped-down demo designed to push you toward a paid plan. The core local experience is the product, and it is free. Optional cloud models exist for people who want them, but they are an addition, not the point. And because the whole app is open source, anyone can inspect the code, adapt it, or build on it, which matters a great deal when you are trusting a tool with your documents.
Local Code Mac at a Glance
If you only have a minute, here is the short version of Local Code Mac, the facts that matter most before you decide whether to try it.
| Feature | Local Code Mac |
|---|---|
| Price for local use | Free, no account or payment details needed |
| Platform | Mac only (Apple silicon Macs; download direct, Mac App Store coming soon) |
| Models available | Qwen 3.8 27B, DeepSeek 4 Flash 0731, DeepSeek 4.1 Flash 1017 |
| Minimum memory | 16GB of RAM for the smallest recommended model |
| Internet needed? | Only to download the app and the model; everyday local tasks work offline |
| Open source? | Yes, the full app is open source under the GPL-3.0 licence |
| Optional cloud use | Your own API keys, or prepaid credits starting at $9.99 |
| Built-in tools | Python, Node.js, a shell, and the Draw Things command-line tool |
The single most important row in that table is the first one. Local Code Mac is free for local use in the full sense of the word: you do not create an account, you do not enter a credit card, and you do not hit a trial limit that quietly converts into a subscription. That is unusual for an AI assistant in 2026, and it is the main reason this launch has attracted so much attention from Mac users who are tired of stacking monthly AI subscriptions.

How Local Code Mac Works
Most AI assistants hide a complicated setup behind a simple chat window. Local Code Mac does the opposite: it bundles the complicated parts into the app itself, so the simple chat window is all you ever see. Understanding the three layers underneath that window will help you use it well and avoid its pitfalls.
Local Code Mac Downloads a Model Onto Your Mac
The first layer is the model itself. A modern AI model is a very large file, and Local Code Mac downloads a specially prepared, compressed version of one, known as a quantized build, from its built-in selector. Quantization shrinks the model so it fits on a consumer machine, at some cost to precision, and the app’s own builds are tuned for Apple silicon hardware. You choose a model once, wait for the download, and from then on the model lives on your drive. That is why the storage numbers in this guide look so large: you are literally carrying a frontier-class model around on your own computer.
The app helps you choose sensibly. During setup it suggests a model based on your Mac’s memory, rather than leaving you to research parameter counts and quantization levels. If you have a Mac with 16GB of RAM, it points you toward the smallest option. If you have a large-memory machine, it offers the bigger, more capable models. This matters because a model that is too large for your machine will run slowly or not at all, while a model that is too small for your task will give weaker answers. Matching the model to the machine is the single most important setup decision, and Local Code Mac tries to make it for you.
Local Code Mac Builds the Tools In, So You Install Nothing Else
The second layer is the tooling. A language model on its own can only produce text. To do useful work, an assistant needs tools: a way to run code, read files, make charts, generate images, and open web pages. Normally, setting those tools up is the part that stops ordinary users from running local AI agents. You would need to install Python, Node.js, a command-line environment, and various libraries, and keep them all working together.
Local Code Mac removes that step entirely. Python, Node.js, and a shell are compiled into the app, along with the Draw Things command-line tool for image and video generation. You do not install them separately, you do not manage versions, and you do not debug broken dependencies. When you ask the app to analyse a spreadsheet, build a chart, or generate an image, it uses the tools already inside the app. That single design choice is what turns the app from a developer project into something a non-technical Mac user can realistically try.
Local Code Mac Keeps the Agent Inside a Sandbox
The third layer is safety. An AI agent that can run code and edit files is powerful, and power needs boundaries. According to the app’s documentation, Apple’s App Sandbox restricts what Local Code Mac can reach. The agent can read and write only inside the workspace folder you choose, it cannot see the rest of your disk, and it cannot launch other apps on its own. That is a deliberate trade-off: it makes the assistant safer, at the cost of some convenience, because you must place the files you want it to work on inside its workspace.
You can also grant the app access to your Photos, Messages, Mail, Notes, and Calendar, and let it summarise their contents or edit and reorganise them where the system allows. Those permissions are optional, and you should think carefully before granting them. The privacy story of Local Code Mac is strongest when you use a local model and keep the agent inside its workspace. Every extra permission you grant widens what the agent can touch, so grant them one at a time, only for jobs that genuinely need them, and review them regularly in your Mac’s system settings.
What Local Code Mac Can Do
Local Code Mac is a general-purpose assistant, which means its job list is broad rather than deep. Here is what the release post and early coverage say it handles, grouped by the kind of work most people actually do.
For Documents, Spreadsheets, and Slides
This is where Local Code Mac earns its keep for most users. You can ask it to update a spreadsheet, read a Word document, or make changes to a PowerPoint file. You can ask it to build a presentation from scratch, or to turn a rough set of notes into a structured slide deck. Because the agent has Python and a shell built in, it can do the arithmetic and the formatting itself, rather than just describing what you should do. For students, freelancers, and small-business owners, this is the everyday work that otherwise eats up evenings.
The same capability extends to analysis. Ask Local Code Mac to look at a spreadsheet of expenses, sales, or survey results, and it can summarise the patterns, calculate totals, and build charts. The release post specifically highlights sophisticated infographics with precise pie charts and bar charts, built locally with Python. If you have ever pasted a spreadsheet into a cloud chatbot and wondered where your numbers went, doing that same job on your own Mac feels noticeably different.
For Images, Video, and Creative Work
Draw Things built its reputation on image generation, and that experience shows up in Local Code Mac. The assistant can generate images and videos, and build explainer videos and motion graphics from HTML, using the built-in Draw Things command-line tool. It can also publish a finished static site to a temporary public web address, which is handy for sharing a quick prototype or a presentation without setting up hosting.
For creators, this means one assistant can take a job from draft to finished visual: write the script, build the slides, generate the supporting images, and assemble a short video. The quality will depend on the model you run and the size of your Mac, and a small local model will not match the largest cloud image generators frame for frame. But for social posts, internal presentations, thumbnails, and drafts, local generation is fast, private, and free after the download, which changes how often you are willing to experiment.
For Code, Websites, and Everyday Tasks
Local Code Mac can write Python or JavaScript, review code you paste in, and help you build small software projects. It can also visit a website, log in with credentials you provide, and make an appointment, which is the kind of multi-step agent task that usually requires a cloud service. You can ask it to summarise the contents of your Notes, Mail, or Messages, or to reorganise them, where the permissions you granted allow it.
There is a practical lesson here. Local Code Mac is at its best on jobs with a clear deliverable: a finished deck, a cleaned-up spreadsheet, a chart, a short video, a piece of code that runs. It is less impressive as a general knowledge chatbot, because a local model, even a large one, does not have the live web knowledge or the sheer scale of the biggest cloud models. Use it for work on your own files, and it shines. Use it as a replacement for web search, and you will notice the difference quickly.

Which Model Should You Download? The Memory and Storage Guide
This is the section to read before you click download, because the model you choose decides both how well Local Code Mac works and how much of your drive it will occupy. The app offers three main options, each aimed at a different size of Mac. The figures below come from the official site and from MacRumors and independent coverage of the launch, and they are worth quoting carefully because different sources round them slightly differently.
| Model | Minimum RAM | Download size | Best for |
|---|---|---|---|
| Qwen 3.8 27B | 16GB | About 10GB to 21GB | Everyday Macs; documents, slides, and general assistance |
| DeepSeek 4 Flash 0731 | 48GB | About 89GB | Large-memory Macs; heavier coding and analysis work |
| DeepSeek 4.1 Flash 1017 | 64GB | 376GB (2-bit) or 412GB (3-bit) | High-end Macs; the most capable local option available |
Read that last row twice. DeepSeek 4.1 Flash 1017 is a 763-billion-parameter model, compressed into a 376-gigabyte package at 2-bit precision, or 412 gigabytes at 3-bit precision. On a Mac with a 512GB drive, that single download would leave very little room for anything else. It is a genuine frontier-class local model, and it is remarkable that it runs on a consumer machine at all, but it is not a casual download. Check your free disk space before you choose it, and remember that the download itself will take a long time on most home connections.
For most people, the sensible starting point is Qwen 3.8 27B. It needs 16GB of RAM, which covers a large share of modern Macs, and its download is a manageable 10GB to 21GB depending on the exact build. It will handle documents, slides, spreadsheets, and general assistance comfortably. If you have a Mac with 48GB or more and you do heavier coding or analysis work, DeepSeek 4 Flash 0731 is the step up. Reserve DeepSeek 4.1 Flash 1017 for a high-end machine with plenty of free storage, and treat it as a serious commitment rather than a quick try-out.
One more practical point: model downloads are not the only storage cost. The app itself, your workspace files, and any images or videos you generate all take space too. Before you start, check how much free space your Mac actually has, and leave a comfortable margin. Running a large model on a nearly full drive is a recipe for slow performance and failed jobs, and it is an avoidable one.
Privacy: What Stays on Your Mac and What Does Not
Privacy is Local Code Mac’s headline promise, and it is mostly a true one, but it comes with a condition that every user should understand clearly. When you use a local model, your prompts and files are processed on your Mac and are not sent to a cloud AI provider. That is the core of the pitch, and it is what separates the app from every cloud assistant that routes your work through someone else’s servers.
The condition is the model choice. If you switch to a cloud model instead, your prompts and the relevant files go to the provider you selected. That is normal for cloud AI, and it is clearly disclosed, but it means the privacy benefit depends on which model is active, not just on which app you opened. If you are working with sensitive material, a contract, a medical document, a client’s financial records, or anything you would not paste into a public chatbot, make sure a local model is selected before you start, and check that setting again if you ever switch models for a particular job.
Two other privacy features deserve mention. First, because the app is fully open source, independent developers can inspect how it handles data, which is a stronger guarantee than a marketing page alone. Second, the App Sandbox limits the agent to your chosen workspace folder, so a local model cannot wander across your whole disk. Neither feature makes the app magic. You still need to choose your workspace carefully, grant app permissions sparingly, and remember that an agent that can edit files can also make mistakes with them. Keep backups of anything important before you let any AI agent reorganise it, local or not.
How to Get Started With Local Code Mac
Getting started with Local Code Mac is deliberately simple, and that simplicity is part of the product. Here is the process, step by step, in the order you will actually do it.
- Check your Mac first. Confirm how much RAM your Mac has and how much free disk space is available. You need at least 16GB of RAM for the smallest recommended model, and you need comfortably more free storage than the model download size.
- Download Local Code Mac from the official site. The release post points to getlocalcode.app, and the download is a direct Mac file. A Mac App Store version is coming soon, but at the time of writing the direct download is the way to get it. Download only from the official site, not from a mirror or a re-uploaded copy.
- Pick a workspace folder. Choose a folder where the agent is allowed to work, and put the files for your first project inside it. Remember that the sandbox limits the agent to this folder, so files elsewhere on your Mac will not be visible to it.
- Let the app suggest a model. During setup, Local Code Mac suggests a model based on your Mac’s memory. Accept its suggestion for your first run, unless you have a specific reason to choose differently. Start small if you are unsure; you can download a larger model later.
- Wait for the download, then start with a small job. Model downloads are large, so start the download when you do not need your connection for anything urgent. Once it finishes, try a low-stakes job first: summarise a document, build a simple chart, or draft a slide deck. Learn how the assistant behaves before you hand it anything important.
- Review permissions before you expand access. Only grant access to Photos, Mail, Messages, Notes, or Calendar when a specific job needs it, and check what you granted afterwards. You can always add a permission later; you cannot un-share something you already handed over.
That is the whole setup. There is no account creation, no API key to paste in for local use, and no separate tool installation. If you have used a local AI tool before, the contrast is striking: the usual afternoon of setup is replaced by a single download and a model choice. That ease of setup is arguably Local Code Mac’s biggest achievement, even more than any single feature.

Local Code Mac Pricing: Free Local Use, Optional Cloud Credits
Local Code Mac’s pricing is refreshingly short, which is part of its appeal. Local use is free, in full, with no account and no payment details. There is no free tier that runs out after a set number of prompts, and no feature that quietly requires a subscription. If you run a local model, the only costs are the ones you already pay: your Mac, your electricity, and your internet connection for the download.
Optional cloud access is where money can enter the picture, and it works in two ways. You can use your own API keys with a cloud provider of your choice, in which case you pay that provider’s rates directly. Or you can buy prepaid credits from Local Code Mac, starting at $9.99, and use cloud models through those credits. Both options exist for jobs where a cloud model is genuinely better, for example a task that needs the very latest model or live web knowledge that a local model lacks.
For a US user comparing monthly AI subscriptions, the arithmetic is striking. A single cloud assistant subscription often costs $20 per month, or $240 per year, and many people now pay for two or three. Local Code Mac replaces the everyday portion of that spending with a one-time download, and leaves cloud spending as an occasional, prepaid choice rather than a standing bill. That is not a reason to cancel every subscription on day one, but it is a reason to ask, honestly, how much of your AI use actually needs the cloud, and how much could happily run on the machine already sitting on your desk.
Local Code Mac vs Cloud AI Assistants
Local Code Mac does not beat cloud assistants at everything, and pretending otherwise would mislead you. Here is an honest comparison, so you can decide where each kind of assistant belongs in your workflow.
| Question | Local Code Mac | Cloud assistants |
|---|---|---|
| Privacy | Prompts and files stay on your Mac with a local model | Your data travels to the provider’s servers |
| Cost | Free for local use; optional cloud credits from $9.99 | Often $20 per month per service |
| Works offline? | Yes, once the model is downloaded | No, needs an internet connection |
| Raw capability | Strong, but limited by your Mac’s memory and the model size | Usually stronger, with the largest models available |
| Live web knowledge | Limited; a local model knows what it was trained on | Generally current, with web search built in |
| Setup effort | One download plus a model download; nothing else to install | Sign up and start immediately, no download |
| Speed | Depends on your Mac; large models on small machines are slow | Usually fast, but depends on server load |
The pattern is clear. Local Code Mac wins on privacy, cost, and offline use. Cloud assistants win on raw power, current knowledge, and instant setup. The smart approach for most people is not to pick one side permanently, but to split the work: run everyday document, spreadsheet, and creative jobs locally for free, and reach for a cloud model only when a job genuinely needs its extra power or its knowledge of recent events. That split saves money, keeps your private files private, and still leaves the cloud available when it earns its keep.
It is also worth comparing Local Code Mac with the site’s recent coverage of local and private AI tools. Readers who liked our guides to Granola dictation for private meeting notes, or our best AI coding assistant roundup, will recognise the same question running through all of them: how much of your AI work can you do without sending your data away? The app is the broadest answer to that question yet, because it covers documents, code, images, and everyday tasks in a single free app rather than a single-purpose tool.
Who Should Use Local Code Mac, and Who Should Wait
Local Code Mac is an excellent fit for several kinds of user. If you are a student working on essays, slides, and data for coursework, it gives you a capable assistant without a subscription you cannot afford. If you are a freelancer or a small-business owner handling client documents, invoices, and presentations, it keeps that work on your own machine. If you are a writer, a creator, or a marketer, its image, video, and slide tools cover a large share of your weekly output. And if you are simply privacy-conscious, it is the first free Mac assistant that is genuinely usable without sending your files to a cloud provider.
Developers will also find it interesting, though for a different reason. Because the whole app is open source, you can inspect it, adapt it, and learn from how a complete local agent is put together. Readers following our DeepSeek Super-agent guide will recognise the same open-source agent trend from a different angle: where DeepSeek’s prototype is code for engineers to study and adapt, Local Code Mac is a finished app for ordinary users to simply run. Together, the two releases show how fast open local agents are maturing.
Who should wait? If your Mac has less than 16GB of RAM, Local Code Mac’s recommended models will not run well, and you should wait or stick with cloud tools for now. If your drive is nearly full, do not start a 376GB download. If you need the very latest web knowledge, live research, or the absolute strongest model available, a cloud assistant remains the better tool. And if you need a Windows or Linux version, the app is Mac-only at launch, so you will need to look elsewhere for now.
Limitations and Honest Caveats
No honest guide to Local Code Mac should skip its limits, and there are several worth stating plainly before you commit a large download to it.
- Mac only. Local Code Mac is built for Apple silicon Macs. There is no Windows or Linux version at launch, and no announced date for one.
- Very large downloads. The top model is 376GB or 412GB depending on precision. Even the mid-range model is about 89GB. These are not downloads to start five minutes before a deadline.
- Performance depends on your machine. A small model on a modest Mac will be slower and less capable than a cloud flagship model. Set your expectations by your hardware, not by the marketing.
- Local knowledge has a cutoff. A downloaded model knows what it was trained on, not what happened yesterday. For recent news, prices, or fast-changing facts, verify with a web source.
- Mac App Store version is still coming. At launch, the download is direct from the official site, and the App Store release is described as coming soon. Do not search the App Store for it and download a lookalike.
- Building from source is not yet straightforward. Independent coverage notes that the Mac app is a Mac Catalyst build needing a patched version of Bazel that has not been published, so it cannot yet be built from source even though the code is open. That does not affect ordinary users who download the finished app, but developers should know it before they plan to build it themselves.
- Agent mistakes are still your responsibility. A local agent can edit files, reorganise notes, and change spreadsheets. Check its work, keep backups, and do not hand it your only copy of anything important.
None of these limits makes Local Code Mac a bad tool. They make it a tool with a clear shape: excellent for private, everyday work on a capable Mac, less suited to cutting-edge research, to small machines, or to anyone who needs a cross-platform assistant today. Knowing that shape before you download is what turns a good launch into a good decision.

Local Code Mac FAQ
Is Local Code Mac really free?
Yes, for local use. You download the app and a model, and you use them without an account, a subscription, or payment details. Optional cloud models cost money, either through your own API keys or through prepaid credits starting at $9.99, but local use itself is free.
Does Local Code Mac work without the internet?
Yes, once the app and your chosen model are downloaded, everyday local tasks work offline. You need the internet for the initial downloads, and for any job that uses a cloud model or visits a website, but ordinary document, spreadsheet, slide, and image work does not need a connection.
How much RAM and storage does Local Code Mac need?
The smallest recommended model, Qwen 3.8 27B, needs 16GB of RAM and a download of about 10GB to 21GB. DeepSeek 4 Flash 0731 needs 48GB of RAM and about 89GB of storage. DeepSeek 4.1 Flash 1017 needs 64GB of RAM and a download of 376GB or 412GB depending on precision. Check both figures for your Mac before you choose.
Is Local Code Mac private?
With a local model, your prompts and files are processed on your Mac and are not sent to a cloud AI provider. If you switch to a cloud model, your prompts and relevant files go to that provider, so check which model is active before working with sensitive material. The app’s sandbox also limits the agent to your chosen workspace folder.
Can Local Code Mac replace ChatGPT or other cloud assistants?
For everyday work on your own files, it can replace a large share of what most people use cloud assistants for, and it does so for free and privately. For the latest news, live research, or the most demanding tasks, cloud models remain stronger. Most users will get the best result by using Local Code Mac for everyday jobs and a cloud model only when a job genuinely needs it.
Is Local Code Mac available on the Mac App Store?
Not yet at the time of writing. The developers say a Mac App Store release is coming soon, and the current download is direct from the official site. Download only from the official site to avoid imitation apps.
Is Local Code Mac open source?
Yes. The full app is open source under the GPL-3.0 licence, and the source is available on GitHub. Independent coverage notes one practical caveat: the Mac app itself cannot yet be built from source because it needs a patched version of Bazel that has not been published, though ordinary users downloading the finished app are unaffected.
The Verdict: A Serious Free Assistant With One Big Download
Local Code Mac is one of the most useful free launches of October 2026, and its appeal is easy to summarise. It takes the most common AI jobs, documents, spreadsheets, slides, images, video, and code, and moves them onto your own Mac, privately and for free, with all the tools built in and no account required. For Mac owners with 16GB of RAM or more, it is a genuine alternative to a monthly AI subscription for everyday work, and a serious privacy upgrade for anyone handling sensitive files.
Its costs are equally easy to summarise. The downloads are large, the best model is enormous, performance depends on your hardware, and it is Mac-only. None of those are hidden, and none of them should surprise you if you have read this guide. The right way to try Local Code Mac is to start small: download the app, accept its model suggestion, and give it one real job from your own work. If that job comes back well, and it stays on your Mac while doing it, you will understand why this launch matters far better than any review can explain.
For the latest details, check the official release post from Draw Things and the MacRumors launch coverage, and verify the model sizes and the Mac App Store status before you download, since both can change as the app is updated. If you try Local Code Mac, start with the smallest model your Mac supports, keep your workspace tidy, and keep a backup of anything important. The future of personal AI may well look like this: capable, local, private, and free. The app is the clearest sign of that future yet.
