Mac Local AI Hands-On: What Locally Uncensored 3.0.6 Can Actually Do

The open-source desktop app Locally Uncensored has released version 3.0.6, offering its first native Apple Silicon build. This AGPL-3.0 licensed tool lets users run chat, image generation, video, voice, and even computer control models on their own machines. Windows and Linux versions have surpassed 170,000 cumulative downloads, while the Mac version is still labeled beta—for a straightforward reason: the dev team only got it running on a single Mac.

System Requirements and Installation

The Mac version has two main gates: Apple Silicon is required, with Intel machines left off the support list, and the system needs macOS 14 or newer.

The only verified environment so far is an M5 Pro with 48 GB of RAM running macOS 26. The team explicitly states they haven't tested on macOS 14 or 15, nor on Macs with 16 GB or 24 GB of RAM—if you happen to be on one of those configurations, your feedback is more valuable than repeating tests on their dev machine.

Installation isn't complicated: download the Apple Silicon .dmg from the official site, drag it into Applications, and the setup wizard will automatically pick a first model for your machine. The installer is Developer ID signed and Apple notarized, and local use is free with no account required.

Local Chat and Model Backends

Chat runs local models through a built-in Metal-accelerated server, so you don't need to install a separate inference engine first. If you're already using Ollama or LM Studio, the app can also call them as backends.

Around the conversation itself, the app offers several practical capabilities: real-time display of the thinking process, chatting with your own documents via a local index, memory that persists across sessions, character persona switching, and side-by-side comparison of two models' outputs. Models that support image input will download together with their image processing components—this download path is new in 3.0.6 but hasn't been separately verified on Mac.

The app also exposes a local API: an OpenAI-compatible service running on port 8129, unifying local models under a single address. By default it listens on localhost unless you explicitly allow LAN access, and it always requires token authentication.

Metal acceleration is Apple's low-level graphics and compute API for its own chips (M series and A series), roughly equivalent to DirectX or Vulkan plus CUDA on macOS/iOS. The core of LLM inference is matrix multiplication, and Metal lets apps directly call the GPU's parallel compute units, efficiently running model weights on Apple Silicon's unified memory architecture. Unlike the NVIDIA ecosystem that depends on CUDA, there is no CUDA support on Apple platforms, so all local inference engines must use Metal (or higher-level MLX, or llama.cpp's Metal backend) to leverage the GPU. This also explains why the Mac version needs a separate build: Windows/Linux versions typically go the CUDA or Vulkan route, and the code can't be directly reused.

OpenAI-compatible API means the server's request and response formats follow OpenAI specs like /v1/chat/completions. This way, any client, script, or third-party tool originally written for OpenAI can call local models without modification—just change the base URL to http://localhost:8129 and fill in the token. This is a common interoperability strategy for local inference tools, avoiding the need to adapt each application individually.

Image Generation: No ComfyUI Required

This is where the Mac version differs most noticeably from Windows/Linux. On Windows and Linux, the app drives image generation through ComfyUI; the Mac version doesn't depend on ComfyUI at all—creation features run directly on-device using an engine the app installs itself.

The Mac catalog lists 23 image models, each card showing the required memory as a hard threshold rather than a suggestion: models needing 32 GB stay locked on a 16 GB Mac. The smallest models (SD Turbo, Realistic Vision V5.1) need 8 GB.

Measured data on an M5 Pro (48 GB):

• DreamShaper XL Turbo: 33 seconds per image
• Qwen-Image 2.1 Turbo: 38 seconds per image

Lower-spec Macs will be slower, but there's no measurement data on how much slower.

One notable Mac-specific detail: chat and image generation share the same memory pool. Before starting image or video generation, the creation module evicts the chat model from memory, showing "Freeing memory...", then loads it back when done.

ComfyUI is a node-graph-based Stable Diffusion frontend where users build generation pipelines by connecting sampler, CLIP encoder, VAE, and other nodes. It's powerful with a massive community ecosystem, but depends on a Python environment and many custom nodes, making deployment and troubleshooting costly. Locally Uncensored treats ComfyUI as a backend on Windows/Linux, essentially borrowing that mature pipeline; the Mac version's choice of a built-in proprietary engine means the team must implement model loading, sampling scheduling, and memory management themselves. The upside is shedding ComfyUI's dependency baggage; the cost is temporarily lagging in model coverage and feature richness.

Quantization (4-bit / 8-bit) refers to compressing model weights from 16-bit floats to lower bit depths, greatly reducing memory footprint and bandwidth needs. 4-bit quantization typically shrinks model size to about a quarter, at the cost of some precision loss. The article's mention that "the 4-bit quantized package needs 16 GB of RAM" reflects this principle: quantization determines whether a model fits on a machine with given memory, making it both a performance parameter and a hard admission threshold.

Image Editing and LoRA

The Mac version's editing feature runs on Qwen-Image 2.1, and the editing tab only appears after that model is installed. The 4-bit quantized package needs 16 GB of RAM.

The interaction differs from the usual brush-mask approach—there's no masking concept. You provide an image, describe the changes in text, and can also add reference images. Worth noting: although the editing feature exists in both code and app, it wasn't included in this release's timed test list, so its reliability is lower than pure generation.

As for LoRA, all quantized image models in the Mac catalog whose names end in 4-bit or 8-bit support LoRA, including Qwen-Image 2.1, Qwen-Image 2512, Z-Image Turbo, and FLUX.2 klein 4B. The app provides a separate LoRA list and folder, stack management with strength sliders, and deletion moves files to the trash.

One technical detail: Qwen-Image 2.1 LoRAs with built-in alpha now compute weights the ComfyUI way (alpha divided by rank). Before 3.0.6, they ran at full configured strength, producing overly strong effects.

LoRA (Low-Rank Adaptation) is a lightweight fine-tuning technique: instead of modifying the base model's hundreds of millions of parameters, it trains a pair of small matrices (low-rank decomposition) that are added to the original weights at inference time. A LoRA file is usually only tens to hundreds of MB yet can significantly change art style, character appearance, or a specific concept. Think of it as a "plugin" for the model—the base model stays general-purpose while LoRA handles personalization.

The article's mention of alpha divided by rank refers to the LoRA weight scaling factor. LoRA's mathematical form is W + (alpha / rank) * B * A, where alpha and rank are hyperparameters set during training. If the implementation omits the division by rank, the effective strength will be far higher than the trainer intended, causing overexposed, distorted output. The 3.0.6 fix to compute the ComfyUI way is meant to keep the same LoRA consistent across different tools.

Character LoRA Training: Not on Mac

This needs to be stated clearly, since many people will search for this feature. Training character LoRAs on your own hardware works on Windows and Linux—Character Studio uses your GPU for training and drops results into the local LoRA folder. But on Mac, this feature doesn't run locally. Character training on Mac goes through a hosted service, and the trained character can be downloaded as a .safetensors file.

Video Generation

The Mac catalog lists 31 video models. The smallest requirements need 16 GB of RAM: LTX-2.3 Distilled 4-bit and Wan 2.1 T2V 1.3B (the latter recommends 32 GB for safety).

Reference data on M5 Pro (48 GB): LTX-2.3 Distilled 4-bit takes 64 seconds to generate a 2-second 768x512 clip with sound.

Two things to know before launching long generations. For models that have actually been timed, if the estimate exceeds ten minutes, the creation page will tell you the expected duration before starting and show current step and remaining time during the run. Also, most video models in the Mac catalog are labeled "Experimental: not yet tested in LU"—a label to take seriously.

The Animate feature for generating video from images becomes available once a video model supporting an initial image is installed.

Local Features Not Supported on Mac

The Windows/Linux creation module also has several local channels: background removal, talking characters, music generation, clip extension, and motion control. None of these run locally in the Mac build. Upscale and erase go through hosted services on all platforms.

Voice Mode

Voice mode's interaction logic is: you speak, the selected chat model answers, and you hear the spoken reply. Speech recognition, speech synthesis, and turn-taking all run on-device. Fifteen voices are provided, and you can interrupt an answer by speaking during it.

Reference data on M5 Pro:

• Initial setup downloads about 0.7 GB
• Replies begin 1.4 to 2.0 seconds after the question ends
• The voice engine uses 1.2 to 1.3 GB of RAM

Voice is in beta and English-only. It was only manually tried on Mac, without the item-by-item checks the Windows version received.

Computer Control: Limited Functionality

Computer control lets the model use mouse and keyboard to operate apps you approve. Off by default. In each new conversation, the model asks once before viewing the screen, and it never types into password fields.

Computer control on Mac is more limited than the Windows version and not fully tested. The app states this directly at the toggle. Specific differences include:

• macOS requires granting two permissions first: Accessibility and Screen Recording
• On Windows, the model can get a list of buttons and fields in a window; on macOS that list isn't available, so the model needs image input and works from screenshots
• For the same reason, the app can't predict what a click will trigger, so every click requires asking and waiting for your confirmation
• Autonomous mode exists only on Windows

Control+Option+Space pauses, Control+Option+Esc stops. The official advice is to treat it on Mac as a taste-test feature rather than a dependable tool.

Accessibility and Screen Recording are two macOS privacy permissions that must be granted manually in System Settings → Privacy & Security; apps can't obtain them on their own. Accessibility permission allows a program to read and simulate UI elements, sending simulated clicks and keyboard events; Screen Recording permission allows capturing screen content. Without these two grants, computer-control features can barely function on macOS.

Window element lists refer to the interface element tree exposed by the OS's accessibility interface (UI Automation on Windows, AX API on macOS), containing names, positions, and types of buttons, input fields, menus, etc. The Windows version can get this structured list, letting the model directly "see" what a button is called and click it by name; on macOS this capability is limited, so the model must rely on screenshots for visual recognition, cannot predict click outcomes, and must ask for user confirmation each time.

Coding Agents

The Agent and Code tabs are included in the Mac build. The agent's shell inherits the login shell's PATH, so tools installed via Homebrew can be found. The agent can also call the local image and video engines as tools. However, there are no separate Mac test records for these two tabs.

Unconfirmed Features

Remote access (using the app from your phone) and auto-update (no older Mac version available to upgrade from) haven't been confirmed on macOS.

TL;DR

Local chat, image generation, prompt-driven image editing, LoRA, video, and voice can run on-device on Mac—no ComfyUI, no account needed. Character LoRA training, music, talking characters, and similar features aren't supported locally on Mac for now. Computer control exists but isn't fully tested. All verification was done on a single M5 Pro 48 GB, which is exactly why this build is labeled beta.

Report issues via the GitHub issue tracker. If your Mac is Intel or lacks memory, similar models can also run hosted in the browser through LU Cloud, a paid service, while all the local features above are free.

One-line Summary

Locally Uncensored 3.0.6 offers its first native Apple Silicon Mac build, but it was only verified on a single M5 Pro and is labeled beta.

Paragraph Summary

Locally Uncensored 3.0.6 provides the first native Apple Silicon Mac build, requiring macOS 14+ and not supporting Intel machines. The biggest Mac change: image generation no longer depends on ComfyUI, using the app's own engine instead, with 23 image models and 31 video models gated hard by memory requirements. Local chat, image generation, image editing, LoRA, video, and voice all run on-device on Mac, free and account-free; but character LoRA training, music generation, talking characters, and other local features aren't yet supported on Mac, and computer control is limited by macOS permission mechanisms, lacking window element lists, relying on screenshots, and requiring confirmation on every click. Since all verification was based on a single M5 Pro 48GB, the team labeled it beta and encourages feedback from users on other configurations.