Draw Things released Local Code for general download and made the app open source on October 28, 2026. The Mac agent combines local language models with code execution, media generation, browser control and integrations with supported Mac apps. In its local configuration, it needs no account, API key or cloud model calls, according to the company’s release announcement.
The hardware choices are substantial. Draw Things lists a 10 GiB Qwen package for Macs with at least 16 GiB of memory, an 89 GiB DeepSeek package for 48 GiB machines, and a 376 GiB DeepSeek build for Macs with 64 GiB or more.
That last pairing needs explanation: a 376 GiB download cannot fit entirely into 64 GiB of memory. Local Code’s documentation describes how it keeps frequently used model components in RAM and streams others from storage. That makes storage capacity and memory separate buying considerations.
What You Can Download Now
The direct download is available; the macOS App Store version is still coming. The announcement directs users to getlocalcode.app, where they can download the app, then select models inside it. Draw Things has not supplied an App Store release date in the announcement.
The general release follows a public beta launched on September 12, 2026. That beta introduced the same basic architecture: an Apple Silicon inference engine, model-specific agent harnesses and a runtime packaged inside the application.
The public GitHub repository contains the app’s source, command-line tools, libraries and vendored dependencies. The project is written mostly in Swift. Developers can inspect or modify the application without first assembling an equivalent agent environment from separate projects.
For most readers, the direct download is the practical starting point. Building from source is an option for customization, not a requirement for using the release.
What the Agent Can Actually Work With
Local Code packages the tools an agent needs to act on files, not simply discuss them. Its technical documentation lists:
- Code and data tools: Python 3.14, Node.js 24, a shell, Git and familiar command-line utilities.
- Analysis libraries: NumPy, pandas, Matplotlib and other bundled Python packages.
- Document tools: Libraries for spreadsheets, Word documents, PowerPoint files and PDFs, plus LibreOffice conversion and rendering.
- Media tools: FFmpeg, HTML-to-video tooling and the Draw Things CLI for image and video generation.
- Web access: Search and a controllable WebKit browser, including support for sites that need JavaScript or a sign-in.
Draw Things says the agent can create charts, slides and explainer videos; write or review Python and JavaScript; and work with Photos, Messages, Mail, Notes and Calendar where supported. Browser tasks can include signing into a website with the user’s credentials and making an appointment.
The useful distinction is the bundled workflow. A spreadsheet task could involve reading a file, calculating results in Python and producing a chart or revised document inside one agent session. Media generation uses the included Draw Things tooling, so the language model is coordinating other tools, not generating every output itself.
The repository also documents saved tasks and chat threads, resumable generation and steering messages sent while the agent works. Those features matter for longer jobs: closing the app or redirecting a task need not mean starting the entire conversation again.
Model Choices: Download Size Is Only One Requirement
The release announcement gives these model tiers:
| Model | Parameter Count | Announced Package Size | Suggested Mac Memory |
|---|---|---|---|
| Qwen 3.8 27B | 27 billion | 10 GiB | 16 GiB or more |
| DeepSeek 4 Flash 0731 | 304 billion | 89 GiB | 48 GiB or more |
| DeepSeek 4.1 Flash 1017 | 763 billion | 376 GiB | 64 GiB or more |
These are Draw Things’ recommendations, not independently measured minimums. The repository lists text-and-image input for Qwen and DeepSeek 4.1 Flash, while DeepSeek 4 Flash is text-only.
The packages use quantization, which stores model weights at reduced numerical precision to shrink their footprint. The README lists 2-bit S and 3-bit S options for DeepSeek 4.1 Flash, and 2-bit S, 4-bit S and 8-bit S options for Qwen. Those labels identify Draw Things’ quantization variants; they should not be read as a complete description of every byte in a download.
There is also a unit discrepancy worth keeping visible. The announcement labels package sizes in GiB, while the README uses GB, listing 9.6 GB for the smallest Qwen option, 89.4 GB for DeepSeek 4 Flash and 376 GB for the smaller DeepSeek 4.1 Flash package. A GiB is 1,073,741,824 bytes; a decimal GB is one billion bytes. The published figures should not silently be treated as identical measurements.
The README’s setup recommendations add another useful detail:
- Below 32 GB of memory: Qwen 3.8 27B, 2-bit S.
- From 32 GB: Qwen 3.8 27B, 4-bit S.
- From 48 GB: DeepSeek 4 Flash.
- From 64 GB: DeepSeek 4.1 Flash.
These broadly match the release’s model tiers, with an additional higher-precision Qwen step at 32 GB. They are setup defaults, and users can switch models later.
My practical reading is to start with the suggested tier, not the biggest package the disk can hold. More free memory also supports the agent’s context, document tools and other applications.
How a 376 GiB Package Can Run on a 64 GiB Mac
The repository documentation breaks the largest download into two major pieces. Using the README’s units, the 2-bit S DeepSeek 4.1 Flash checkpoint is about 173 GB, and the package includes a 203 GB engram file. That engram file is shared between the model’s two quantization options.
The README does not explain the engram file in detail. Its immediate relevance is storage accounting: the quoted package size includes more than the checkpoint alone.
Both DeepSeek options are mixture-of-experts models. Local Code keeps frequently used experts in memory and streams the remaining experts from disk. Consequently, the complete checkpoint does not have to remain resident in RAM.
The documentation specifies two limits on the experts held in memory. They cannot exceed either:
- The Mac’s total memory minus 32 GB.
- 72% of the memory free when the model loads.
In effect, the smaller allowance constrains the expert cache. Draw Things says this leaves room for other applications and lets the models run on Macs with less memory than their checkpoints.
That explains the mechanism behind the headline pairing. A large download describes what must be stored; resident memory describes what is loaded into RAM at a given time. They are different requirements.
The practical consequence is that 64 GiB is a memory recommendation, not permission to ignore the storage requirement. The model files still need disk space. More RAM allows Local Code to retain more experts, and the README explicitly says these models run faster with more memory.
Storage performance is therefore relevant to this design, although the opened documentation provides no drive-by-drive comparison. I would check available disk capacity before committing to the largest download, then treat extra RAM as a performance advantage rather than assuming every qualifying Mac will behave alike.
What the Published Speed Claims Tell Us
Draw Things reports that DeepSeek 4.1 Flash can operate with as little as 36 GiB of resident memory, at approximately:
- 350 tokens per second for prompt processing.
- 18 tokens per second for generation.
Prompt processing, often called prefill, handles the supplied input and context. Generation produces the response. A high prefill rate can reduce the wait before an answer begins, but it is not the speed at which the whole answer appears.
Frequently Asked Questions
4 questions
1Is Local Code Available in the Mac App Store?
Not yet, according to the October 28 announcement. The direct download is available through getlocalcode.app; the App Store release is described as coming soon.
