Local Code is now available as a free, open-source AI assistant for Mac, built by the team behind Draw Things. Its central pitch is straightforward: download a compatible model, run it on the Mac, and handle prompts and files locally instead of automatically sending that material to a cloud AI service.

That distinction will matter to anyone who wants an assistant to work with documents, spreadsheets, presentations, messages or notes without making cloud processing the default. Local Code is designed to install the pieces it needs alongside the model workflow, rather than asking users to separately set up the usual technical tools. The trade-off is that local AI still needs meaningful Mac memory and storage, particularly for the larger DeepSeek options.

What Local Code is built to do

Local Code is positioned as a broad assistant rather than a narrowly focused chat window. Its listed capabilities include creating presentations; generating images and videos; analyzing spreadsheets; and working with Microsoft Word and PowerPoint files. It also has a browser that the assistant can use to navigate websites and carry out online tasks.

The browser feature is important because it moves the tool beyond a request-and-response model. A conventional AI chat interaction might produce text explaining how to find information on a website. An assistant with browser access is intended to navigate the site itself as part of the requested task. That can be useful, but it also makes permission awareness more important: users should be clear on what task they are authorizing and what information the assistant may encounter while doing it.

For Mac users who spend time bouncing between documents, slides, calendars and browser tabs, the appeal is less about a single headline feature than a consolidated workflow. Local Code says it can operate across several common work formats while allowing local model processing. The practical value will depend on whether a user’s Mac has the capacity for the selected model and whether the task truly benefits from an AI assistant with access to the relevant material.

Local processing, explained

A local model is an AI model whose inference work happens on the user’s own machine. Inference is the stage where a trained model reads a prompt and produces an answer or other output. In Local Code’s local mode, prompts and files are processed on the Mac instead of being sent to a cloud AI provider.

That does not mean every action is offline. If the assistant is instructed to use its browser to visit a website, it obviously needs network access for that web activity. The local-processing claim concerns where the AI model handles the prompt and associated files: on the Mac rather than at a remote model provider.

This setup offers a clear privacy-oriented benefit for users whose work includes personal or sensitive material. It also provides a more direct sense of control over which model is being used. But local processing shifts responsibility to the computer. Memory capacity determines which options are viable, downloaded models consume storage, and a user needs to choose an appropriately sized model rather than expecting every capability to run comfortably on every Mac.

Local Code does include cloud model choices. Selecting one changes the data path: prompts and relevant files are sent to the chosen provider. That may be a worthwhile choice for someone who wants a particular cloud model or does not have the hardware resources for a larger local download, but it is a materially different privacy decision from local use.

Permissions are a core part of the product

With permission, Local Code can read information in Mail, Messages and Notes. It can also make changes in Calendar and Photos. Those are substantial capabilities, and they should be understood as optional permissions rather than background access users must grant merely because the app is installed.

Its documentation says Apple’s App Sandbox limits access to files and other parts of the system. The App Sandbox is an Apple security framework that restricts what an app can reach unless the user grants relevant access. In everyday terms, it is a boundary around an application rather than a blanket promise that an app cannot work with sensitive information. If a user permits access to Mail or Messages, the assistant may read the information needed for the requested task within that granted scope.

The sensible approach is to treat AI permissions as task-specific. A person asking for help turning a document into a presentation may decide document access is appropriate, while someone simply drafting an idea may not need to expose Mail, Messages, Calendar, Notes or Photos at all. Similarly, the ability to modify Calendar and Photos is useful only when the requested outcome calls for it.

A practical permission checklist

  • Choose local processing when the task involves material you do not want sent to a cloud provider.
  • Grant access only to the application or data category needed for the job at hand.
  • Remember that browser-based tasks can interact with live websites even when the selected AI model runs locally.
  • Check the selected model and its download size before committing storage space.
  • Use a cloud option only with the understanding that prompts and relevant files will go to that provider.

Mac memory and storage requirements

Local Code offers Qwen and DeepSeek model options aimed at Macs with varying amounts of memory. Its listed minimum for Qwen 3.8 27B is 16GB of memory. The “27B” label refers to a model with 27 billion parameters: parameters are the internal values a model uses to generate outputs. Larger parameter counts are not, by themselves, a guarantee that a model is the right pick for a specific task, but they commonly come with heavier hardware demands.

The recommended downloads listed for Local Code range from roughly 10GB to 21GB of storage. The larger DeepSeek models require far more room: approximately 89GB or 376GB depending on the version. Those numbers turn the choice of model into a practical storage-planning issue, not merely a menu selection.

A Mac meeting a stated minimum is not necessarily the same as a Mac that is ideal for every demanding workload. Users considering a local assistant should account for the room needed by their existing apps and files alongside the model download. The 376GB DeepSeek option in particular deserves deliberate consideration before downloading. Local models are not tiny utilities, and the cost of privacy-focused, on-device processing is often measured in disk space and hardware capacity rather than a recurring service fee.

This is also why Local Code’s range of model choices is notable. Rather than offering one universal download, it gives Mac users options tied to their available memory and willingness to allocate storage. For people weighing hardware needs more generally, Joking Joystick has also covered Apple’s upcoming device plans and Macs.

Free local use, with paid cloud flexibility

Using Local Code with a local model is free. Cloud access is optional and can be used through a user’s own API keys or prepaid credits that start at $9.99. An API key is a credential that connects software to an online service account, typically allowing usage to be associated with that account and its billing arrangement.

The split makes the product’s trade-offs relatively easy to understand. Local use avoids a required cloud subscription and keeps model processing on the Mac, but requires compatible hardware and local storage. Cloud use may offer another route for users who prefer it, but it entails sending prompts and relevant files to the selected provider and can involve paid credits or the user’s own API account.

There is no universally superior option. A short, non-sensitive request may be a comfortable fit for a cloud model for some users. A workflow involving private correspondence, notes or documents is where a locally processed model could be especially compelling, provided the user has enough capacity and grants access thoughtfully.

Availability and the bigger implication

Local Code follows a public beta that began on September 12. A direct download for Mac is available now, while a Mac App Store release is planned for a later date.

The release is part of a wider shift in how AI tools can be approached on personal computers: not only as remote services, but as software that can run models near the user’s own files. Local Code’s feature list also shows that “local AI” does not have to mean a stripped-down text utility. It can encompass office documents, media generation, browser activity and permissioned access to personal apps.

That breadth is precisely why users should take the setup seriously. Local model selection, storage requirements, browser actions and app permissions are all parts of the same decision. For Mac owners with 16GB or more of memory and sufficient free disk space, Local Code offers a free route to experiment with on-device Qwen and DeepSeek models. For everyone else, the most useful detail may be the reminder that an AI assistant’s convenience, privacy model and hardware footprint are inseparable.