Public Beta of Local Code by Draw Things

Bringing the simplicity of Draw Things to running capable large language models locally.

There are many options for running LLMs locally: llama.cpp, mlx, Ollama, oMLX, LM Studio, and others. Similarly, there are many agent harnesses you can run locally, including Codex, Claude Code, Pi, and OpenCode.

Most of these harnesses run directly on your computer. They may provide their own sandboxing and permission systems, but the harness itself still runs on your computer with full permission, where it can see everything the computer has.

Draw Things is an App Sandboxed app with Hardened Runtime, delivered through Apple’s AppStore. To generate an image or a video, you simply download a model once, try our recommended settings, and start prompting. Behind the scenes, we do the hard work: quantizing the model, finding the best quality trade-off for the number of bits you download, and making it run as fast as possible on your Apple devices.

We want the same simplicity when putting capable local language models to work.

Local isn’t a checkbox. What matters is what you can actually run locally: how capable the model is, at what quality and speed, how much context it can use, and how much of the machine remains available for the rest of the work.

We are bringing three things out today:

1. A fast LLM inference engine. It performs particularly well on prefill, where we often see performance 1.2× to 1.6× faster than the next-fastest option available to us.

2. Harnesses specially designed for each supported model. Instead of forcing every model through the same generic interface, we tune the harness to how each model works best, so it can make the most of the model’s capabilities.

3. An in-process agent runtime. The runtime lives inside the application and is sandboxed by the operating system. Its security boundary is enforced by Apple’s App Sandbox as a requirement of App Store distribution, rather than by a sandbox implemented only by us, the developers.

These are not three separate apps.

They are one product.

We call it Local Code. And we are opening Local Code for public beta testing through TestFlight today.

Local Code is built with the same philosophy as Draw Things. We do the hard work to quantize the models, package the runtime, and make the inference engine fast enough for everyday use. You simply download a model and get ready to work.

The goal is not to win a tokens-per-second benchmark in isolation. The model has to share the machine with its context, its tools, Python, web servers, other running tasks, and potentially other models. What matters is whether the whole system can get the work done.

Models

At this time, Local Code recommends DeepSeek 4 Flash 0731, using our 2/3-bit quantized variant, on devices with 48 GiB or more of unified memory.

We also support Qwen 3.8 27B with our 2-bit and 4-bit quantized variants. In our internal evaluations, these variants score similarly to the full model.

For Qwen 3.8 27B, we also provide llama.cpp-compatible variants so you can try the same quantizations with your own preferred inference engine and harness: https://huggingface.co/drawthingsai/Qwen3.8-27B-GGUF.

A Runtime Packaged With the App

At around 500 MiB, Local Code packages much more than an inference engine.

It includes Python 3.14.7, Node.js 24.20, Lean 4.33.1, OSH as a Bash-compatible shell, ssh, curl, awk, ripgrep, and many of the Python libraries you already know and use, including NumPy 2.4.6, pandas 3.0.5, Pillow 12.3.0, Matplotlib 3.11.1, MLX 0.32.2, and more.

You can extend the environment further by installing pure-Python packages with pip and pure-JavaScript packages with npm.

We call this the in-process agentic runtime. By packaging it into Local Code, it works out of the box while fully respecting the boundaries enforced by Apple’s App Sandbox.

Join our Discord server to provide feedback. There will be more to come shortly!

Acknowledgement

Even with the power of GPT-6 Astra, software does not simply come into being without prior art. Local Code would not be possible without a tremendous amount of open-source software. Unlike the Draw Things app, Local Code itself will be fully open-sourced when it is ready for general release.

A-Shell demonstrated that a useful in-process shell environment is possible on iOS. Our in-process agentic runtime builds on ios_system from A-Shell.

Python’s subinterpreter support, strengthened in Python 3.12 with a per-interpreter GIL, gave us a much cleaner way to support recursive pip installs without additional hacks and binary duplication. A-Shell, for example, uses multiple copies of Python to work around some of the same constraints.

Node.js for Mobile Apps demonstrated that a full Node.js runtime can be embedded and remain functional on mobile platforms. OSH gives us a clean and easy-to-integrate Bash-compatible shell environment.

DwarfStar was taking shape around the same time as Local Code. We followed each other’s work closely and arrived at many of the same conclusions: local inference is not just about whether a model can run, but whether a sufficiently capable model can run fast and efficiently enough to get work done. Its work inspired us to develop our own approach, which we hope is interesting in its own ways.

Our quantization formats build heavily on ideas from llama.cpp, with additional optimizations for Apple Silicon. We thank the DeepSeek and Qwen teams for the open-weight models that make Local Code possible.

SwiftMarkdownEngine and SwiftMath are worth a special mention for keeping Markdown and math rendering native. Lean and Z3 bring formal reasoning into the packaged runtime.

Local Code also builds on many other open-source projects, including libgit2, ripgrep, jq, Info-ZIP, openssh, libcaca, and more. We are grateful to all of these projects and the people behind them.