A 35B AI model on your own Mac and iPhone, with Edge0
The official Edge0 repo, copyable Mac + iPhone setup steps, and your first useful offline workflow: every command, check and fix, checked against the Edge0 repo at the guide’s pinned commit, a build of the engine, Apple’s docs and the model’s own licence
Edge0 runs a 35-billion-parameter model on an Apple silicon Mac and on an iPhone by keeping most of it on storage and reading in only the parts each token needs, so it uses about 3 GB of memory. This guide gets it answering on the Mac, then puts the chat app on a compatible iPhone, with no cloud bill and no connection once it’s installed. The checks built the engine from the guide’s pinned commit and confirmed the commands. They also found the guide’s licence advice points at the wrong licence: the 35B it installs is Apache-2.0. The model is a 4-bit preview whose only tested Apple devices are a 12 GB iPhone 17 Pro Max and a 16 GB M5 Mac, and the iPhone build needs Xcode, a cable and re-signing every 7 days on a free Apple account.
A step-by-step guide to running Edge0’s 35B model on your own devices: build the engine on an Apple silicon Mac, download and convert the model, chat with it in Terminal, optionally serve it to other apps, then build the iPhone chat app and copy the model over a cable. Every step, command, check and troubleshooting tip from the guide is here, with its pictures; the newsletter’s branding and promotion are removed. The checks follow the Edge0 repo at the commit the guide pins, which is still the latest. The engine was built from it on Linux (CPU), and its info output matched; the model itself, the Mac’s Metal build and the iPhone app were not run here. Where the guide got something wrong or left something out, the note at that spot says so.
What held up, on 13 November 2026
Checked against the Edge0 repo at commit da9cc526 (the guide’s pin, and still the latest), a build of the engine from it, the model’s Hugging Face card, and Apple’s and Homebrew’s docs.
The official Edge0 repo, copyable Mac + iPhone setup steps, and your first useful offline workflow
Your next AI draft could run on the hardware you already own. No cloud token charge for those local answers. No connection needed once the model is installed. Your notes can stay on your device. (Not in the guide: “hardware you already own” means an Apple silicon Mac, and for the phone part a recent high-memory iPhone; those are the only Apple devices the project has tested. On iPhone, see the backup note in step 7. On a free Apple account the iPhone app stops opening after 7 days until you rebuild it from the Mac, which needs an internet connection.)
Get Edge0’s 35B model answering on an Apple silicon Mac, then put the chat app on a compatible iPhone. Start with the Mac. Confirm it works before moving 22GB to your phone.
Not in the guide: Edge0 is an open-source engine for mixture-of-experts models, which split each layer into many small “experts” and use only a few for each token. Its 35B (a preview) is Qwen3.6-35B-A3B, 4-bit, with Edge0’s tuning added: 35 billion parameters in total, about 3 billion used for each token (roughly, each word). The repo’s front page now leads with Edge0’s newer 145B and 120B models; those need an NVIDIA GPU, so the 35B, its previous release, is the one for a Mac or iPhone.
A local Mac chat
you can use for drafts, summaries and brainstorming. (Not in the guide: it’s a chat in Terminal, text only, and each conversation holds about 16,000 tokens.)
An optional local API
for tools that let you change the server URL.
An optional iPhone chat app
that runs the model on the phone. (Not in the guide: a developer example you build and sign yourself, not an App Store app.)
Read: about 8 minutes. (Not in the guide: that’s for the guide alone; with the notes added here, this page takes about 20 minutes.) Setup: a separate download, conversion and build session; allow longer for the iPhone. This guide follows the official docs, checked November 13, 2026. The guide’s authors say they hadn’t run the full model on their own hardware, and neither has this check: every speed below is the Edge0 project’s own measurement.
Not in the guide, from the docs: the download is about 19.7 GB, conversion takes 3 to 4 minutes on an Apple M-series Mac, and the iPhone copy is about 21.9 GB and about 11 minutes over a cable.
Check your hardware before downloading
Edge0 keeps model weights on storage and loads the pieces needed for inference into memory. That makes a large model more practical on smaller devices. It does not remove the storage requirement, and long conversations still add memory use. (Not in the guide, from the docs: more exactly, only the experts are read from storage, a few per token, and the rest of the model stays in memory, about 3 GB in the project’s tests. Memory for a conversation is mostly reserved up front, so a long chat adds only a little (on the test iPhone a multi-turn chat peaked at about 3.16 GiB against 3.05 GiB for one prompt): it runs into the roughly 16,000-token limit, and then you start a new one. Keep the model on the Mac’s internal drive; it reads from it as it answers.)
Mac:
Apple silicon, around 42GB free for the original weights plus converted assets, and enough spare space for Xcode if you want the phone build. Developer benchmarks include an M5 Mac with 16GiB RAM; that is a tested example, not a minimum for every workload. (Not in the guide: on that M5 the project measured about 25 tokens a second and about 6 seconds to the first word on a long prompt. Intel Macs aren’t supported. Once the model passes its check you can delete the original weights, about 20 GB.)
iPhone:
around 22GB free for model assets, plus the app and working space. The published 35B phone test used an iPhone 17 Pro Max. An iOS 17 deployment target does not mean every iPhone can run this model. (Not in the guide: that phone has 12 GB of memory and managed about 13 to 16 tokens a second. iOS caps each app’s memory, and on it the engine peaked at about 3.2 of a roughly 3.3 GiB cap, so phones with less memory may close it.)
Tools:
Git, Ninja, uv and CMake. Use CMake 3.22+ for the iPhone example. Mac command line tools are enough for the Mac build; the phone needs full Xcode and its iOS SDK. (Not in the guide: the Mac engine itself needs CMake 3.21 or newer, as the screenshot below says; Homebrew’s current CMake covers both. Git and the C++ compiler come with Apple’s command line tools.)
Phone development:
the official example specifies Xcode 26.6, Swift 5.9+, a signing team and an unlocked, wired device with Developer Mode enabled. (Not in the guide: Xcode 26.6 runs only on macOS Tahoe 26.2 to 26.x. The App Store now ships Xcode 27, which needs macOS Tahoe 26.6 or later and which the project hasn’t tested. Swift comes with Xcode.)
Cost: the route below uses your own hardware and downloads. Local generation avoids a cloud provider’s per-token bill; storage, electricity, development tools and your setup time still count. This is a developer setup, with Xcode signing on iPhone. (Not in the guide: the software and the model are free, and a free Apple account is enough to sign the app; as the guide’s “Signing fails” tip says, it then has to be reinstalled every 7 days. Homebrew needs macOS 15 or newer.)
Build the Mac engine
Install Homebrew first if you don’t have it. Open Terminal, install Apple’s command line tools if needed, and let that installation finish before continuing. (The guide gives this line and the next as one block. This one opens an installer and returns at once, so run it on its own and wait for the installer to finish, or for the message that the tools are already installed. Not in the guide: when Homebrew’s installer ends, run the “Next steps” commands it prints, or brew won’t be found.)
Clone the official repo. The checkout pins the revision used for this guide so later repo changes don’t silently change these instructions. (Confirmed: apart from the guide’s own checkout pin, this matches the docs. Not in the guide: the checkout’s “detached HEAD” message is normal, and so are compiler warnings during the build.)
Check: the info output should include model.0: edge0_35b. Keep this Terminal open. Every remaining command runs from edge0/edge0-infer/. (Confirmed by building the engine here: it printed model.0: edge0_35b. Not in the guide, from the source and not run here: on a Mac the same output should also show backend.metal: compiled=yes.)
Download and prepare the 35B model
Create the parent folder only. The two output folders below must not already exist when starting fresh. Keep the names consistent: the phone transfer later uses the converted assets from this same location. (Not in the guide: the download is about 19.7 GB from the public Hugging Face repo Edge0/Edge0-35B-A3B-preview, pinned to a fixed revision, with no account or token needed. The tools refuse an output folder that already exists, so don’t create source-35b or assets-35b yourself.)
Check: the probe can reach the model source, the download and conversion finish without errors, and the asset check passes before you continue. Internet is needed for the initial tools and model download. The function’s --offline flag reuses uv’s prepared Python environment; it doesn’t make the model download offline. (Two corrections: it’s --no-sync that reuses the environment uv sync prepared, and --offline only stops uv itself going online; the download still uses the internet. Not in the guide: if you see “No module named numpy”, run uv sync --project tools/assets again. A passing probe and a passing check both print JSON with "status": "passed". The converter’s log is at ~/Models/edge0/assets-35b.log. If Hugging Face is blocked, put --endpoint and a mirror’s address before probe and before download.)
Get your first local answer
Check: the first command returns a model response; the second opens an interactive conversation. The first Metal run can take extra time while shaders compile. Use /new for a fresh conversation, /think off for shorter direct replies, and /quit to leave. (Corrected: thinking is already off by default for the 35B: /think on turns on step-by-step reasoning, longer and slower, and /think off switches it back. Not in the guide: the JSON block printed after an answer is a speed and memory summary, not an error.)
Try something useful immediately
Not in the guide: the chat sends each line you type as its own message, so pasting this as is sends five messages (the blank line is skipped). Type a line with only """ first, paste the prompt and your notes, then type """ again. For longer notes, save the whole prompt in a file and send /file followed by its path.
Review the answer before using it. A local model can still get facts wrong. Once installed, disconnect the network and repeat a short prompt to check that your chat works offline. (Not in the guide: it’s a 4-bit preview, about 4 points below its full-precision base on the project’s tests, and its lowest score is for following instructions (57.9 against the base’s 61.7 on IFBench), so check the word limit and every fact yourself.)
Optional: connect a tool to your Mac
If your app accepts a custom API base URL, leave this server running in Terminal (official endpoint details are linked at the top). (Not in the guide: wait for the line that starts “Listening:” before connecting. The server keeps this Terminal busy, so use a second one for the iPhone steps: go back to edge0/edge0-infer/ there and repeat the two exports from step 3.)
Base URL:
http://127.0.0.1:8000/v1
Model name:
edge0_35b. (Not in the guide: if an app insists on its own model name, restart the server with --alias and that name.)
API key field:
loopback SDK clients can use any nonempty value, such as local.
A successful connection returns a response from that model while the server is running. This address is local to the Mac; it does not connect your phone. API compatibility covers specific endpoints and fields, so check the server guide if your app rejects a request. (Not in the guide: it speaks OpenAI’s Chat Completions and Responses formats and Anthropic’s Messages, with streaming and function tools, but text only. It answers one request at a time, the others get “busy”, and it sends no CORS headers, so tools that run in a web page can’t call it.)
Build the iPhone chat app
Keep the Mac working first. Install full Xcode, open it once to finish components, and sign in under Xcode → Settings → Accounts. Pair and trust the wired phone, enable Developer Mode, and keep it unlocked. (Not in the guide: current Xcode calls the pane Apple Accounts. Check under Xcode → Settings → Components that iOS is installed. Developer Mode is in the phone’s Settings → Privacy & Security, and only appears once the phone has been paired with the Mac; turning it on restarts the phone. Use a data cable: Wi-Fi is refused.)
Not in the guide: step 2 set your command line tools to Apple’s standalone package, and the commands below need full Xcode. Point them at it, then check that the second line prints a path inside Xcode.app.
Find your Team ID in your Apple developer account and the phone’s UDID in Xcode’s Devices and Simulators window, or with the first command below. Replace both placeholder values. They are development identifiers; don’t paste them into a public repo. (The guide gives this command, the exports and the build as one block; here they’re split so you don’t run the build with the placeholders. Not in the guide: a free account’s developer page has no Membership details, and Edge0’s Xcode project can’t be made until this ID is set. Neither Apple nor the repo says where else a free account shows it. One route, not tested here: add an Apple Development certificate under Xcode → Settings → Accounts → Manage Certificates; in Keychain Access, that certificate’s Organizational Unit is your 10-character Team ID. For the phone, use the last pair of brackets on its line (the first pair is its iOS version), not a simulator’s. In Xcode 27 the Devices and Simulators window is called Device Hub.)
(Not in the guide: if you change any of the four values later, paste all four exports again (the two bundle IDs are built from your Team ID), then run the first line again: it reads the Team ID and bundle ID when it sets up the project.)
Check: the build produces examples/ios/build/Release-iphoneos/edge0-chat.app. The build and transfer must use the same bundle ID. This chat app has a different data container from Edge0’s reference command-line app. (Not in the guide: if signing says the phone isn’t registered, the build above never registered it. This command, adapted from Edge0’s instructions for its command-line app and not tested here, builds once for your phone so Xcode can add it. A free account allows three registered devices.)
Transfer the model and open the app
Keep MOE_ASSETS_35B set to the validated assets from step 3. The first transfer is about 21.9GB. Keep the cable connected and leave room for it on the phone. (Not in the guide: run this in the same Terminal as step 6, since it needs the four exports from there too. It takes about 11 minutes on the project’s cable. The first command also installs the app. If the first transfer is interrupted, all 21.9 GB is sent again. The check command should print assets/35b: consistent. A message starting with SKIP means nothing was sent. If the launch is refused, trust the developer in the phone’s Settings, then try again or tap Edge0 Chat.)
In the app, open Models → Refresh models, select the valid 35B assets, load the model and return to Chat. Send a short prompt. Then enable Airplane Mode with Wi-Fi off and send a new prompt: a response confirms on-device generation without a live connection. Keep the app in the foreground while it generates; backgrounding cancels active generation. (Not in the guide: in the app, Refresh models is the ↻ button next to the Models heading, the model shows as “edge0_35b · 35b” with a Load button, and once it loads the app goes back to Chat by itself. Not in the guide: a screen lock also stops a reply, so set Auto-Lock longer while testing. The app’s storage, chat history included, is part of iCloud Backup, so turn off backup for Edge0 Chat if you don’t want 22 GB going there, and don’t delete the 35b folder the Files app shows.)
Command or preset missing:
return to edge0/edge0-infer/. A new Terminal also needs the two model path exports and the assets_py function from step 3. (Not in the guide: for the iPhone steps it also needs the four exports from step 6.)
Download interrupted:
the fetch tool supports resuming. Run the same download command with the same output path. (Not in the guide: unfinished files wait in ~/Models/edge0/source-35b.partial; don’t delete or rename it.)
Conversion stopped:
it may leave an assets-35b.partial directory. Check the error and disk space; remove only that incomplete conversion folder before retrying. Keep the original weights. (Not in the guide: the details are in ~/Models/edge0/assets-35b.log.)
Xcode can’t find the iOS SDK:
select the full Xcode installation in Xcode → Settings → Locations → Command Line Tools. (Not in the guide: or run the xcode-select command from step 6, and check that iOS is installed under Components.)
Signing fails:
check the Team ID, account and selected physical device in the generated Xcode project. With a free Personal Team, provisioning expires after seven days; rebuild and reinstall without uninstalling the app. (Not in the guide: fix MOE_IOS_TEAM, paste all four step 6 exports again and re-run the first cmake line rather than editing the generated project, and register the phone if it’s new to your team. To renew after seven days, run the step 6 build and the step 7 transfer again: it reinstalls over the app and skips the model files it already has. Deleting the app deletes them.)
Model unavailable or chat crashes:
read the reason under Unavailable models, recheck assets and the matching bundle ID, close other apps and start a short new conversation. Don’t assume a benchmark from a different device guarantees yours. (Not in the guide: if the 35B doesn’t appear at all, run the transfer’s --check command and confirm MOE_IOS_BUNDLE_ID: without it the files go to Edge0’s command-line app instead.)
“SKIP: requested device unavailable” or “model.json: cannot read”:
Not in the guide. The first means the binary wasn’t built with the mac-metal preset; the second means MOE_ASSETS_35B points to the wrong folder; if it’s unset in this Terminal, run prints its usage text and chat says “Expected --model <directory> …” instead.
For a freelance consultant or small agency account manager, start with one repeatable deliverable: turning rough meeting notes into a reviewed client follow-up. The buyer is the client who needs a clear recap; the deliverable is one accurate email, with the next action spelled out. Keep sending manual.
If this becomes a client offer, bound it to a weekly recap and action list inside your existing service. Price your editing and delivery work, not a promise of autonomous AI or unlimited accuracy. Track a handful of drafts against your usual process before claiming time savings.
Keep licence scope clear: the inference framework and model terms are separate. Check the current model licence and the specific downloaded model’s upstream terms before packaging a paid assistant, distributing weights or hosting inference for others. The repo’s model licence requires separate permission for certain commercial services. (Corrected: the model licence in the repo, the Edge0 Community Model License, covers only the 145B and 120B. The 35B this guide downloads is Apache-2.0, and so is its base, Qwen3.6-35B-A3B, and the Edge0 framework itself. Apache-2.0 allows all three uses, commercially too, as long as you pass on the licence text and notices and don’t use the Edge0 or Qwen names as your brand. Neither the download nor the model’s Hugging Face repo includes a licence file (the card just says Apache 2.0 and links to the Apache-2.0 LICENSE file at the root of the Edge0 GitHub repo, not the model licence linked at the top), so keep a copy of that file. Drafting client emails with it is fine under either licence.)
The useful part is ownership: a local place to draft, experiment and work through notes without paying a cloud token charge for every attempt. Start with the Mac, prove one useful workflow, then decide whether the phone setup earns its place. (Not in the guide: no Mac? The same model also runs on Linux, Windows and Android, with their own build commands; the getting-started page linked at the top covers them.)