DEV Community: David

DeepSeek V4.1 Flash Uncensored: what weight-level abliteration costs, and what we saw in testing

David — Sat, 24 Oct 2026 14:24:16 +0000

DeepSeek V4.1 Flash Uncensored is DeepSeek V4.1 Flash with the refusal behavior removed in the weights, published by dealignai as an FP8 checkpoint. No system prompt trick, no runtime hook: it loads like the base model.

I build Locally Uncensored, an open source desktop app (AGPL-3.0) for running models on your own machine, with an optional hosted side called LU Cloud. This model went into LU Cloud today. A 552B mixture of experts is not something most people run at home, so this one is hosted only for us. Here's what the numbers say and what we saw before we turned it on.

what the makers measured

From the model card:

                                  base V4.1 Flash   uncensored build
HarmBench-320, thinking off       42.8% answered    100%
HarmBench-320, thinking max        1.6% answered    100%
MMLU (14,042 questions)           87.0%             82.7%
MMLU without ethics/law subjects  -                 about 1.1 points below base

The interesting row is the second one. The stock model gets much more refusal-prone the longer it reasons: at max effort it answered 5 of 320. The abliterated build doesn't care about the effort setting.

The MMLU drop is mostly moral scenarios (76.9% to 37.0%) and professional law, which makes sense: those questions reward exactly the hesitation that was removed.

what we measured

Before it went into the catalog we ran it against the live endpoint:

reasoning     on by default, Think off stops it (43 -> 2 tokens)
effort        low / medium / high all answer
tools         native tool calls
context       1M in, 131,072 out
images        listed as vision, but a red and a blue square both came back "White"
refusals      answered our four probes without any host system prompt

So we ship it as a text model. The model card says the vision tower is untouched; whatever goes wrong happens somewhere between the checkpoint and the endpoint, and we'd rather not sell image input that names every color white.

The four probes are deliberately boring: a swearing rant, picking a lock you own, pirate insults, an explicit scene between adults. They tell you whether a model answers without being talked into it, not how far it goes.

using it

In the desktop app (3.0.7) you sign in to LU Cloud, flip the Cloud switch, and the model is in the Uncensored group, marked beta. It works in Chat, Agent mode and the Code tab, since tool calls are native. The model list comes from the server, so no app update was needed. The same account works in the browser and in the Android app.

It costs about 22,500 credits per million input tokens and 90,000 per million output, close to the stock V4.1 Flash. A 15 EUR pack is 450,000 credits.

Two limits worth knowing:

It runs on one route only. If that route is down, the request is refused with a plain message instead of quietly going to a different model.
Personal API keys don't reach it. It's for the apps and the browser.

A note for Agent mode: a model that doesn't refuse also doesn't hesitate. The agent's workspace is a folder jail, not a VM, so read the tool requests before you approve them.

Step by step: How to use DeepSeek V4.1 Flash Uncensored in LU. The longer write-up, including the second new model, Abliterated Large Flash: DeepSeek V4.1 Flash Uncensored in LU Cloud. The app is on GitHub.

AI-assisted: I wrote this with help from an AI model and checked the facts against the dealignai model card and our own measurements.

Kimi K3.1 Pro is out: what changed from K3, what it costs, and when you can run it yourself

David — Sat, 24 Oct 2026 11:57:25 +0000

Moonshot released Kimi K3.1 Pro on October 23. It's the same 2.8T parameter mixture of experts as Kimi K3 (about 104B active per token, 1M context, text and image input), trained further for coding and long agent runs. The weights aren't out yet; Moonshot promises them by November 4.

I build Locally Uncensored, an open source desktop app (AGPL-3.0) for running models on your own machine, with an optional hosted side called LU Cloud. K3.1 Pro went into LU Cloud yesterday. This post is about what the numbers say, what we measured, and why "run it locally" is still mostly a hardware question.

what changed from K3

The architecture didn't. The post-training did, and it shows in agent work. Artificial Analysis numbers:

                                   Kimi K3     Kimi K3.1 Pro
Intelligence Index                 44          55  (4th overall)
Terminal-Bench 4.0                 13%         67% (best measured so far)
GDPval-AA                          1,534 Elo   1,846 Elo
AutomationBench-AA                 58%         73%
Humanity's Last Exam               47%         52%
Hallucination rate (Omniscience)   53%         44%

Only Claude Opus 5.5 (58), Claude Sonnet 5.5 (56) and Muse Wonder Full (56) score higher on the index. Once the weights are published it's the top open weight model there, and the gap between open and closed on that index shrinks from 12 points to 3.

Moonshot also says it took cyberattack related material out of the training data before the open release. Their own exploit test went from 90.5% for the version without that cut to 81% for the one they shipped.

what we saw when we wired it up

Before it went into the catalog we ran it against the live endpoint:

reasoning     on by default; switching it off really stops it
effort        low / medium / high
tools         native tool calls, also in a stream
vision        works, images need to be at least 64x64
context       1M in, 131,072 out
cache reads   a tenth of the input price
speed         about 55 tokens/s

The thinking switch matters more than usual here. Reasoning tokens are output tokens, output costs five times input, and K3.1 Pro is the priciest model in our catalog: 0.3 credits per input token, 1.5 per output token, about 5% above K3. On a short question, thinking off is the biggest lever on the bill.

using it today

In the desktop app (3.0.7, Windows, Mac, Linux) you sign in to LU Cloud, flip the Cloud switch in the header, and pick Kimi K3.1 Pro. It runs in Chat, Agent mode and the Code tab. The app reads the hosted model list from the server, so no update was needed for it to show up. The same account works in the browser at lu-labs.ai and in the Android app, and there's an OpenAI compatible endpoint:

curl https://lu-labs.ai/api/inference/v1/chat/completions \
  -H "Authorization: Bearer $LU_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "moonshotai/Kimi-K3.1-Pro",
       "messages": [{"role": "user", "content": "Review this function for edge cases."}]}'

Step by step for all of it: How to use Kimi K3.1 Pro in LU.

running it yourself, honestly

Same architecture and size as K3, so the K3 GGUFs tell you what to expect once the weights land:

1-bit  UD-Q1_0       466 GB   more than a 512 GB Mac Studio leaves free with context
1-bit  UD-IQ1_S      594 GB   768 GB server, or two linked 512 GB machines
2-bit  UD-Q2_K_XL    861 GB   ~1 TB RAM server
4-bit  Q4            ~1.5 TB  multi GPU server

MoE saves compute, not memory: all 2.8T parameters have to be loaded. Speed then follows bandwidth. At 2 bits the 104B active parameters are roughly 30 GB read per token, so even with the whole model in 800 GB/s memory the ceiling is about 25 tokens/s, and real runs get a fraction of that.

On our side there's one more gate: the llama.cpp build bundled in LU doesn't read the Kimi K3 architecture yet. A coming version lists K3.1 Pro in the Model Manager once a loadable GGUF exists and the engine can open it. Until then it's hosted or nothing.

The longer write-up with sources is here: Kimi K3.1 Pro: what it can do, and how to use it in LU today. The app is on GitHub.

AI-assisted: I wrote this with help from an AI model and checked the facts against Moonshot's announcement, Artificial Analysis and our own catalog.

Reverse engineering without the cloud: REA, a local 27B model and an uncensored build

David — Thu, 22 Oct 2026 18:21:35 +0000

REA (Reverse Engineer Anything) is an MIT-licensed MCP server that gives an agent tools to look inside apps and files. Its own README is clear that the analysis runs locally. What it doesn't change is where the findings go next: to whatever model drives your agent. With Claude Code, Codex or Cursor, that's a cloud model, and the strings, endpoints and code fragments REA pulls out of a binary travel with every turn.

I build Locally Uncensored, an open source desktop app (AGPL-3.0) for running models on your own machine. Since 3.0.7 REA is a plugin there, and the agent can run on a local model. This post is about that setup: what stays where, which local models are big enough, and why I'd reach for an uncensored build.

the data path

                      cloud agent + REA        LU + local model + REA
analysis              your machine             your machine
tool results          -> cloud model           your machine
your questions        -> cloud model           your machine
setup                 rea-agents setup edits   one switch under Plugins
                      your agent's config

If the target is a client's app under audit, a closed tool from work or your own unreleased build, the right column is the whole point.

why an uncensored model

Reverse engineering vocabulary is exactly what safety training reacts to: decompile, bypass, patch, crack the file format. In a long agent run, one refusal at step seven ends the analysis. A model with its refusals removed just answers.

To be fair to the stock model: I haven't measured refusal rates on REA tasks, and on my test app stock Qwen 3.8 27B didn't refuse anything. The uncensored builds are the insurance for questions that sound rougher than "how does search work".

which local models are big enough

REA wants roughly a 27B model and 64K of context. Smaller models tend to stop before they answer: Qwen 3.5 9B at 32K ran out of context in my run. These are in LU's catalog, all flagged for agent use:

Qwen 3.8 27B                        stock, tools + thinking      16 GB  UD-Q4_K_M
Qwen 3.8 27B Abliterated (Ollama)   huihui, vision + tools       18 GB  one pull
Qwen 3.8 27B Abliterated            same build as GGUF           11-29 GB  Q2_K..Q8_0
Qwen 3.8 27B HauhauCS Aggressive    uncensored, tool calling     16 GB  IQ4_XS

Only the first one has run with REA so far. Add memory for a 64K context on top of the file size.

the run that worked

model      Qwen 3.8 27B Q4_K_P on Ollama, 64K context
REA        6.5.0
target     TinyNotes, a four-file Electron test app
steps      10
time       3 min 15 s
answer     version, both endpoints, both IPC channels
memory     never below 44 % free (Mac)

That run used LU's tool code outside the app. Getting there took three changes, because the model kept doing the right steps and never writing an answer:

fewer tools per turn. REA has 207 tools. A turn only gets the ones its words point at.
references, not copies. Trace and compare tools accept an earlier result whole (about 7,000 characters) or as {"kind": "retained-evidence", "evidence_id": "ev_..."}. The model kept trying to copy records it had never seen. LU now offers only the reference, which alone shrank the tools a turn carries from 108,651 to 74,459 characters. Ollama also doesn't enforce a schema const, so the model sent "kind": "evidence"; LU turns any object with an evidence id into the reference.
facts, not provenance. One analysis returned 343,583 characters, mostly hashes, with the interesting endpoint at character 230,308. The model now gets the facts, 32,792 characters with nothing lost, plus the evidence id.

on a leash

Every REA call goes through the same confirmation as any external tool in LU's Agent and Code: you see the call, you approve it. LU fetches one pinned package, checks it against the npm registry checksum before every start, and never runs REA's own setup, which writes into other apps' configs. REA needs Node.js 22.19+, 24.11+ or 26+.

limits

The complete answer came from one Mac with the stock model. On Windows the built app has started REA and handed its tools to a model, nothing more yet. Linux, cloud models and the uncensored builds are untried.
Use it on software you own or are allowed to examine.

Short version

REA analyzes locally, but a cloud agent still ships its findings to a cloud model. With a local model in LU, nothing leaves the machine.
Use a ~27B model at 64K context. Stock Qwen 3.8 27B finished a test app in 3 min 15 s; uncensored 27B builds are in the catalog but untested with REA.
The model only finished once it got fewer tools, references instead of copies, and facts instead of provenance.

The step by step guide is on locallyuncensored.com, and the app is on GitHub.

AI-assisted: I wrote this with help from an AI model and checked the facts against the code, the commit history and the changelog.

A live voice assistant on your own machine: Whisper, Pocket TTS and your local LLM

David — Tue, 20 Oct 2026 15:13:56 +0000

A live voice assistant works like this: you talk, it answers out loud, you cut in, it stops. Since 3.0.6, Locally Uncensored has a mode that works that way with a model on your own machine. Speech recognition, the voice and the turn taking all run locally, and the model that answers is whatever chat model you already use.

It is a beta and English only. This post covers how it is built, what it costs in memory and time, and where it falls short.

Locally Uncensored is an open source desktop app (AGPL-3.0) for running AI models locally, with 180,000+ downloads.

What runs where

Speech recognition   Whisper base.en       local
Voice                Pocket TTS            local, 15 voices
Turn taking          the voice engine      local
Answer               your chat model       local, or any provider you set up

The voice engine is one process. It holds the speech detection, the speech recognition and the voice, and it loads them when it starts, not when a session starts. Voice is hidden while the app's Cloud switch is on, because the hosted side has no voice service yet.

Setup

Open Voice in the main navigation. The first time, you get a setup screen that shows the download size, the space needed and your free space before anything is fetched, plus a list of what is downloaded and where it goes. One click on Install. On a Mac that came to about 0.7 GB in our measurement.

Pick one of fifteen voices there or later: Alba, Anna, Azelma, Charles, Eponine, Eve, Fantine, George, Jane, Javert, Marius, Mary, Michael, Paul or Vera. Changing the voice fetches one small file.

Talking to it

Click Start. A quiet chord says it is listening. Then you talk, it answers, and you can interrupt by speaking. The session is saved as a normal conversation.

Measured from the end of the question to the start of the answer, with a local model:

Windows, RTX 3060 12 GB, local 9B model    1.6 to 3.1 s
M5 Pro Mac                                  1.4 to 2.0 s

The first session after setup or a restart is the slow one. In our Windows tests it took 23 to 63 seconds to start cold, against about one second warm. What you say during that wait is kept for up to a minute and answered once the session is up, so you can start talking right away.

Memory

Voice engine in memory    about 1 GB on our Windows machine
                          1.2 to 1.3 GB on the M5 Pro Mac

A switch next to the title shows the number LU measured and unloads the engine with one click, together with the chat model if the voice session loaded it. Without the click, the engine shuts down five minutes after the last session.

Tools by voice

Four switches sit next to the title: Voice settings, Agent, Where it may work and Thinking.

With Agent on, the voice session gets the agent's tools with the same permissions. Local models get a shorter list (web, files, shell and the screen) so the first answer comes quickly. A tool that needs your approval waits for a click on Approve or Reject. A spoken yes does not approve a tool, because speech recognition can mishear and the microphone hears the whole room.

Where it may work defaults to Workspace only: files stay in the session's folder, commands ask first, no screen. Whole computer opens the rest of your user account and the screen, after one extra question. System folders and the folders that hold keys and passwords stay closed at both levels.

Thinking is off by default. Switched on, the thought shows in the transcript and is never read aloud. A thought is capped between 128 and 4096 tokens, 512 by default, and if it runs longer LU ends it and asks the model for a direct answer.

Asking for something on the screen

With Whole computer on, you can ask for a task on the screen and hear the result. That is computer control, a separate beta with its own rules. Every new chat asks "Allow computer control in this chat?" and waits for a click. LU says aloud that it waits. A spoken yes does not allow it, a spoken no or stop declines.

During a task, yes or no answers an ordinary action, and saying "stop" or "wait" on its own pauses it. "Wait, what is two plus two?" is a question for the model, not a pause. In our Windows test, typing a note in Notepad by voice took 11 to 22 seconds from the end of the command to the spoken result, with a local 9B model.

On a Mac, computer control is in the app but not fully tested yet.

Where it falls short

English only, and the voices are fixed.
Interrupting relies on your system's echo cancellation. With loud speakers and no headset, the first words of an interruption can be quiet or missing. A headset helps.
For six seconds after Start, a voice that reaches the microphone only faintly is turned down.
Checked point by point on Windows. Tried by hand on a Mac. Not run in the app on Linux, although the Linux packages carry the voice engine.

Short version

A live voice mode where everything except the answer is a fixed local pipeline (Whisper base.en, Pocket TTS, a turn taking engine), and the answer is your own chat model. About 1 to 1.3 GB of memory, an answer that starts 1.4 to 3.1 seconds after you stop talking, interruptions that work best with a headset, and tools and screen control behind clicks rather than spoken yeses. English only, and in beta.

The code is at github.com/PurpleDoubleD/locally-uncensored. The setup, the measurements and the limits are written up in VOICE.md in the repository.

AI-assisted: I wrote this with help from an AI model and checked the facts against the code and VOICE.md.

one character, every tab: training a local LoRA that changes clothes, on 8 GB cards and on a Mac

David — Tue, 20 Oct 2026 15:13:15 +0000

Locally Uncensored is an open source desktop app (AGPL-3.0) that runs AI models on your own machine: chat, an agent, image and video generation. It has 180,000+ downloads. For 3.0.7 I wanted a character you train once to work everywhere in the app, and I wanted more machines to be able to train one.

This post follows one character from training to image, edit, video and chat. It also says where my testing stopped, which for this feature is further back than I would like.

Training: what changed

Local characters use the Z Image family. You drop photos of one person or character into Character Studio, pick a trigger word and train on your own machine. Three things are new in 3.0.7.

A character that changes clothes

The Train tab has a short text field under each photo, on Windows, Linux and Mac. You write there what changes from photo to photo: clothes, hair, place. That text goes into the photo's caption after the trigger word. The trained character then keeps its face and body without being tied to the one outfit it wore in most photos. An empty field keeps the caption as it was.

Describe photos fills the empty fields for you with the local chat model picked in Chat, if that model can see images. It never sends the photos to a cloud model. The per photo text has run in automated tests only.

Low VRAM, for cards under 12 GB

On Windows and Linux, training now has a second setting next to the training length:

Normal     the 12 GB recipe as before
Low VRAM   512 px instead of 768 px
           28 of the model's 30 blocks in system memory
           saved activations in system memory
           LoRA rank 16 instead of 32

Each step takes clearly longer, and fine detail comes out softer. A card with less than 11 GB is pointed at Low VRAM, both in the tab and in the trainer's own check.

Low VRAM lets cards from about 8 GB train. That number is worked out from the trainer's own figures. I have not measured it on an 8 GB card. Low VRAM as a whole has run in automated tests only so far.

A Mac trains now

On a Mac, Character Studio's Train tab now trains a Z Image character from 4 to 100 photos with the Mac's image engine. The first run downloads a training adapter of 340 MB, and the result goes into the Mac's LoRA folder.

It is slow:

M5 Pro, one step        about 7 seconds
Standard (1200 steps)   a little over two hours

My own run was 10 photos and 100 steps on one Mac with 48 GB. The Standard and Thorough settings, Macs with less memory and stopping a training in the middle have not run yet. This is on macOS only.

A character from the frames of a video

The lightbox and the large view of a video offer Use frames for a character. LU takes frames spread evenly over the clip:

default    8 frames
slider     4 to 20 frames

You untick the frames that do not show the figure, then train with the rest or save them as a character. On a Mac this feeds the same Mac training. This has run in automated tests only.

Image and Edit

When Create runs on ComfyUI, Image and Edit have a character chip next to the model chip. Pick a character there and its LoRA and trigger word go into the run.

The pick also sets the model. Before, picking a character left the image model as it was, and on a model of another family the run left the character out. Now the pick sets an installed Z Image model. Where none fits, the line under the character says so with a button to switch, and Create does not start a run that would ignore the character. The same line tells you to describe the key features in the prompt too, because the trigger word alone often does not hold the look (issue 161).

Two limits in Edit:

Edit with a mask     does not take a character
Trained characters   up to 3 of the training photos as references, at most 1024 px each

The Trained characters row sits in the reference strip of Edit. A character trained before 3.0.7 has no photos there, and I have not tried the row with a real training set yet.

Video: Step 1 of 2, Step 2 of 2

A character video is two runs. LU first makes a picture of the character, then starts the clip from that picture:

Step 1 of 2    picture of the character
Step 2 of 2    clip from that picture

This works on Video, Animate, Extend, Multishot, MiniMax H3, Motion Control and Talking Character. A start image of your own wins over the character picture. A video model that only takes text, or a tab with no video model installed, says so before anything runs, so you do not wait through step 1 for nothing.

I checked this in the app on Windows with a stand-in character, not a real trained one. How well a real character keeps its face has not been checked, and step 2 has not run with a real video model yet.

Chat

The image and video tools in the chat take a character by name or by trigger word.

On a Mac

Character Studio's Use tab on a Mac lists the characters in the Mac's LoRA folder, including the ones the Mac trained itself. A pick brings the Z Image model the character was trained for, and Image, the video tabs and the chat tools take the character as they do on Windows. A video starts from a picture of the character made on the Mac.

The Mac parts of 3.0.7 have run in automated tests and with the real engine on one Mac with 48 GB, but have not been clicked through in a built app yet.

Characters from LU Cloud, and cleaning up

If you trained a character on LU Cloud, the cloud character shelf has Use locally. It saves a Z Image character into the LoRA folder of this machine, so the local Use character shelf lists it next to your own.

file of that name already there    LU stops and says so, nothing is replaced
other model families               refused, with the reason

This has run in automated tests only, not yet against the real service.

A character trained on this machine can be deleted from the Use character shelf. LU asks first, and the file goes to the Recycle Bin or Trash.

What I did not test

real trained character in the app       not checked, stand-in LoRA only
step 2 of a character video             not run with a real video model
per photo text (changing clothes)       automated tests only
Low VRAM                                automated tests only, not measured on 8 GB
training on a Mac                       10 photos, 100 steps, one Mac with 48 GB
Standard and Thorough on a Mac          not run
Use frames for a character              automated tests only
Trained characters row in Edit          not with a real training set
Use locally from LU Cloud               automated tests only

The real app check ran on one Windows machine with an NVIDIA card. If you try any of these on your own hardware, a report on the issue tracker helps more than another run on mine. A Low VRAM run on an 8 GB card is the one I would most like to see.

Short version

In 3.0.7 a local character can change clothes between photos, train on cards from about 8 GB with Low VRAM (worked out, not measured), and train on a Mac, slowly. Once trained, it works in Image and Edit through a chip next to the model, in every video tab as Step 1 of 2 and Step 2 of 2, and in the chat by name or trigger word. The video step has not run with a real video model yet, and the face check with a real character is still open.

The code is at github.com/PurpleDoubleD/locally-uncensored, and the Character Studio chapter of the handbook covers photos and training. Downloads are on locallyuncensored.com.

AI-assisted: I wrote this with help from an AI model and checked the facts against the code and the changelog.

Reverse engineering with a local model: what it took to make a 27B model finish the job

David — Mon, 19 Oct 2026 17:12:32 +0000

Locally Uncensored is an open source desktop app (AGPL-3.0) that runs AI models on your own machine. Version 3.0.7 came out today, and one of the new things is a plugin called REA, short for Reverse Engineer Anything. It's an MIT-licensed MCP server by morluto, and in LU it gives the Agent and Code modes tools to look inside apps and files.

Getting it to work with a local model was harder than wiring up the server. Here's what I ran into.

how it starts

There's one switch under Plugins in the composer, off by default, desktop app only. When you flip it, LU fetches one pinned version of the package and checks it:

package:   rea-agents 6.5.0 (npm tarball)
check:     against the checksum the npm registry publishes
again:     before every start
never run: REA's own setup (it writes other apps' settings)
node:      22.19+ within 22, 24.11+ within 24, or 26+

npx gets the checked file, never a package name. If Node.js is missing or too old, the row says which version it found.

The first start has a catch: npx installs REA's dependencies before the server answers the MCP initialize. Every MCP request in LU waited 30 seconds, and on a slow line on a Windows test machine that ended every first start with "Request initialize timed out". The same start by hand answered after 111 seconds. REA now gets ten minutes for that handshake, every other server keeps 30 seconds. The second start, from npm's cache, came up in 22 seconds with 207 tools.

207 tools is too many for a local model

Hand 207 tool schemas to a local model and its context is gone before the first question. So a turn only gets the REA tools its words point at. Ask about an Electron app and the model sees the JavaScript and Electron tools, not the .NET ones.

Each REA tool sits behind the same confirmation as any external tool in LU. The model proposes a call, you approve it, then it runs.

the run that found every step and never answered

My first real run was Qwen 3.8 27B on Ollama, 64K context, on a Mac, against a small test app. It picked the right tools in the right order. It never wrote an answer. Two reasons:

The schema invited the model to copy huge records. Tools that work on an earlier result take that evidence record either complete or as a reference:

{"kind": "retained-evidence", "evidence_id": "ev_..."}

The schema listed the complete record first, about 7,000 characters of it. The model kept trying to reproduce records it had never seen in full, and REA refused each one. LU's version of the schema now offers only the reference, which is also what REA's own guide recommends, and LU holds the model's call to that form.

The results were mostly provenance. One analyze_javascript_application call on a four-file app returned 343,583 characters. The interesting part, the sync endpoint, sat at character 230,308. LU's general cap keeps the first 40,000 and the last 20,000 characters, so the model never saw it. Now the model gets the facts from each record instead, about a tenth of the size, plus the evidence_id, so a later tool can still ask REA for the full record.

After both fixes, the same model took the test app apart and wrote a complete answer in 3 minutes 15 seconds. Qwen 3.5 9B at 32K still ran out of context before it got there.

what REA reads

By itself: JavaScript and Electron apps, .NET, Go and Rust programs, Flutter, SQLite and WebAssembly. It uses Ghidra, Hopper, JADX and Frida if you have them installed. LU installs none of them.

limits

The complete answer came from LU's tool code outside the app, on one Mac. A full run from the built app hasn't been tried yet, and neither have analysis runs on Windows and Linux or cloud models.
Pick a model of about 27B with 64K context or more. Smaller ones tend to stop before an answer.
Use it on software you own or are allowed to examine.

Short version

REA is a plugin in LU 3.0.7 that gives Agent and Code 207 reverse engineering tools, with only the relevant ones shown per turn.
The pinned package is checked against its npm checksum before every start, and the first start gets ten minutes to install.
A local 27B model only finished once it got references instead of 7,000-character records and facts instead of 340K-character results.

The app is on GitHub, and the user guide for the plugin is on locallyuncensored.com.

AI-assisted: I wrote this with help from an AI model and checked the facts against the code and the changelog.

DeepSeek V4.1 Flash 1017: what DeepSeek says changed, and swapping it in without breaking anyone's saved model

David — Mon, 19 Oct 2026 17:07:32 +0000

Locally Uncensored is an open source desktop app (AGPL-3.0) that runs AI models on your own machine. It also has an optional cloud mode, LU Cloud, for models too big for a desk. DeepSeek V4.1 Flash is one of those: the checkpoint is 510.3 GB.

On 17 October 2026 DeepSeek published V4.1 Flash 1017. Since 18 October, 21:54 UTC, it is the model behind our V4.1 Flash entry. This post covers what DeepSeek claims for it and how we moved people over.

What DeepSeek says is better

DeepSeek calls 1017 a minor update to V4.1 Flash. The release note says it scores higher on benchmarks, finishes tasks faster and writes shorter outputs. The model card has a table comparing it with V4.1 Flash. These are DeepSeek's numbers, run by DeepSeek:

Benchmark	V4.1 Flash	V4.1 Flash 1017
HLE without tools	36.8	42.6
Terminal-Bench 4.0	31.2	42.3
DeepSWE v1.1	74.2	77.0
ProgramBench	20.3	29.1
AutomationBench	54.8	60.5
Agents' Last Exam	31.8	35.4
Apex Bench v1.1	64.6	72.1
Chartography, with tools	78.9	83.0
BabyVision, with tools	89.6	92.5
ZeroBench, with tools	49.0	51.0

The biggest jumps are on the long agent tests, Terminal-Bench 4.0 and ProgramBench. The image tests move by two to four points. I have not measured output length myself yet.

The checkpoint is the same size as before, under the same MIT licence. If you call it yourself, the card now recommends temperature 1.0 and top_p 1.0.

Sources: the release note and the model card.

Swapping a model id without breaking saved picks

People had V4.1 Flash saved as a default, in old chats and in API scripts that send deepseek-ai/DeepSeek-V4.1-Flash. Renaming the entry would have broken all of them.

So the catalog entry now carries the new id, deepseek-ai/DeepSeek-V4.1-Flash-1017, and the old id sits in a small table of retired ids that points to its replacement. Every request goes through that lookup before it reaches the model, and the meter prices the replacement. Old chats keep working, API scripts keep working, and nobody has to touch a setting.

Before the switch I ran both versions side by side: a native tool call, an image to describe, and the same reasoning prompts at different effort levels. They behaved the same way, so the flags in the catalog (image input, tools, reasoning always on) carried over unchanged.

What it costs in LU Cloud

The catalog price went down with the switch. 1017 draws 20,000 credits per million input tokens and 60,000 per million output tokens. Before the switch the catalog listed V4.1 Flash at 30,000 and 120,000. Every plan and every credit pack carries the whole chat catalog.

Using it

In the desktop app, flip the Cloud switch and pick DeepSeek V4.1 Flash 1017 in Chat. The app pulls the catalog from the server, so no update is needed. From code, any OpenAI-compatible client works against https://lu-labs.ai/api/inference/v1 with the model id deepseek-ai/DeepSeek-V4.1-Flash-1017 and a personal API key from account settings.

Short version

1017 replaced V4.1 Flash in LU Cloud on 18 October; DeepSeek calls it a minor update with higher benchmark scores and shorter outputs.
The old model id still works and is routed to 1017, so saved picks, old chats and API scripts keep running.
It got cheaper: 20,000 credits per million input tokens and 60,000 per million output tokens.

The app itself is on GitHub. The full post with the local hardware math links is on locallyuncensored.com.

AI-assisted: I wrote this with help from an AI model and checked the facts against the release note, the model card and our catalog.

Local AI computer use: a model that clicks for you, and the questions it asks first

David — Sun, 18 Oct 2026 22:49:52 +0000

Locally Uncensored 3.0.6 added computer control: a model uses the mouse and keyboard in apps you approve. It works with local models, so the screenshots and the clicks stay on your machine. It is a beta, and most of the work in it went into the questions it asks before it does anything, so most of this post is about those.

Locally Uncensored is an open source desktop app (AGPL-3.0) for running AI models locally, with 170,000+ downloads. Computer control is one part of its agent.

Off until you switch it on

It stays off until you switch it on under Settings, Agent, Agent Permissions, Computer control. Switching it on is not a blanket yes. After that, LU still asks at these points:

Every new chat        "Allow computer control in this chat?" Allow / Deny
First touch of an app asks before it uses that app
Every action          asked by default (supervised mode)
Sensitive actions     always asked, also in autonomous mode

Until you click Allow on that first card, LU takes no screenshot and does nothing. The yes holds for that one chat. A new chat asks again, and so does every chat after a restart of the app. No setting skips the card.

Sensitive means anything that sends, buys, deletes or changes permissions. Those are asked with the reason in red. So is a click on a button, link or menu item that has no name, because LU cannot tell what it would do.

What it never touches

Some places are off limits at every level:

terminals
password managers
system sign-in and permission dialogs
security settings
the Run dialog
windows with administrator rights

LU never types into a password field, and pasting there is refused too. A double click on a program, an installer, a script or a shortcut asks first.

How you stop it

Ctrl+Alt+Space    pause
Ctrl+Alt+Esc      stop

On a Mac it is Control+Option instead of Ctrl+Alt. In an autonomous session LU also pauses when you move the mouse. The paused view shows what it did so far and asks whether you take over or let it continue, and you can add an instruction for the rest of the task. A screen task ends after at most 25 steps or 8 minutes either way, and the time you take to answer a question counts.

While it works on Windows, the LU window shrinks to a small window in the top right corner and the edge of the screen glows softly in purple. The small window shows what LU is doing and names the two shortcuts. Questions appear there with a Stop button and take mouse clicks only, so the app LU works in keeps the keyboard focus.

Which model looks at the screen

By default the chat model you already picked. LU does not ask how it should run.

On Windows, LU reads the list of buttons and fields of the window it works in. A model that can see images gets the screenshot plus that list. A model that cannot see images works from the list alone, without a picture. That second case is what makes small local text models usable here at all.

We compared the two on two tasks, three runs each. Both finished all six runs. The runs with the picture took 497 seconds in total, the runs with the list alone 381.

For a dedicated screen model, the catalog has Holo 3.1 9B, marked Beta and recommended from 16 GB of video memory. In our test on Windows it finished a simple typing task in 1 of 3 runs, and it does not fit next to a 9B chat model on a 12 GB card. That is not a strong result, and I would rather say so than leave it out.

A real number

Typing a note in Notepad, asked by voice, with a local 9B model working from the list of buttons and fields: 11 to 22 seconds from the end of the spoken command to the spoken result. That was measured before the question in every new chat existed, so in a new chat your click on Allow comes on top.

Platforms

Windows   checked point by point in the real app, on one Windows 10 machine
Linux     not run in the app yet, needs an X11 session
macOS     in the app, not fully tested yet

The list of buttons and fields and the autonomous mode exist on Windows only. On Linux and macOS, LU cannot name what a click would press, so every click there is asked as a sensitive action. On a Mac it also needs two system permissions first, Accessibility and Screen Recording, and the model needs image input because it only has screenshots.

There is no background mode on any platform. It works in the foreground with your real pointer.

The limits I would want to know

Small local models misjudge when a task is finished. A task can end as stopped although the work is done.
Text on the screen can try to give the model instructions. LU marks what it reads from the screen as untrusted and asks before sensitive actions. For anything that matters, stay in the supervised mode.
The words LU reads on a button to tell a sensitive action from an ordinary one come from a list. A wording the list does not know is not recognised.
Eight corrections and ten security fixes made after the Windows check have run in automated tests only.

Short version

Computer control in Locally Uncensored 3.0.6 lets a local model click and type in apps you approve. It is off by default, asks in every new chat, asks before sensitive actions in every mode, never touches terminals or password fields, and stops on Ctrl+Alt+Esc. It is checked on Windows, not fully tested on a Mac, and not run on Linux yet. Treat it as a beta that wants you watching.

The code is at github.com/PurpleDoubleD/locally-uncensored, COMPUTER-CONTROL.md describes every question and every limit, and the changelog has the full list of what is and is not tested.

Qwen-Image 2.1 uncensored: text encoder, finetune or GGUF, and what each one changes

David — Wed, 14 Oct 2026 17:35:23 +0000

"Qwen-Image 2.1 uncensored" gets searched as if it were one thing. It is at least three, and they change different parts of the pipeline. This post sorts them out, says which of them Locally Uncensored ships, and what the license still says no matter which one you pick.

Background, if you missed it: Alibaba Qwen published Qwen-Image 2.1 on 20 September 2026. One 7B set of weights does text to image and image editing. I wrote about running it locally when it came out. A few releases later, the uncensored side has filled in.

Two different meanings of uncensored

Where it runs. On your own machine nothing sits between your prompt and the model. No moderation layer reads the prompt or the picture. That part you get with the stock model already, as long as it runs locally.

What the weights do. The original model draws what it was trained to draw. The builds labelled uncensored change that, and they change it in different places:

Text encoder   the part that reads your prompt; can be processed to stop refusing
Image model    the part that draws; can be finetuned on other material
Both           community GGUF builds that change the weights

What the app ships

Locally Uncensored (open source, AGPL-3.0, 170,000+ downloads) has these in the Model Manager under Models, Image, Get new:

Qwen-Image 2.1 (Generate and Edit)   the original files, three of them, 16.1 GB
Qwen-Image 2.1 (No Filter)           same image model and VAE, a text encoder
                                     with its refusal direction removed (Heretic)
Noct Q (Qwen-Image 2.1, Unfiltered)  a community finetune; the image model
                                     itself is changed

The No Filter build only swaps the text encoder. If you already have Qwen-Image 2.1, only that encoder is downloaded, about 9 GB. With both encoders installed, the Expert settings in Create get a "Text encoder" row so you pick which one reads your prompt, for new pictures, for edits and for pictures made in chat. The official one stays the default.

Noct Q goes further: its notice says the transformer weights were modified. It uses the official text encoder and VAE, so on top of an existing install it is about 7 GB. The app treats it as Qwen-Image 2.1, so edits, the transparent background, the encoder choice and the prompt enhancer all work with it. I have not run Noct Q on my own hardware yet.

There is a matching pair for the prompt enhancer too, Official and No Filter. Both run on a 12 GB card and need ComfyUI 0.37.2 or newer.

Community files you add by hand

Outside the bundles there are GGUF builds on Hugging Face. As read off the repositories on 10 October 2026:

unsloth/Qwen-Image-2.1-GGUF                         original weights
  Q2_K 2.47 GB, Q4_K_M 4.2 GB, Q5_K_M 5.39 GB, F16 14.23 GB
abenzerps/Qwen-Image-2.1-Uncensored-GGUF            uncensored build
  Q4_K_M 4.6 GB, Q5_K_M 5.22 GB, Q6_K 5.88 GB, BF16 14.23 GB
pottokao/Qwen-Image-2.1-Text-Encoder-Heretic-GGUF   text encoder only
  Q4_K_M 5.03 GB, Q6_K 6.88 GB, Q8_0 8.71 GB

These go into ComfyUI by hand, and ComfyUI reads GGUF through a loader node you install first. I list them as their authors describe them. I have not tested them.

LoRAs exist now

When 2.1 came out there was no LoRA for it, and the older Qwen-Image speed LoRAs do not fit the new architecture. That changed within weeks: speed LoRAs for four to six steps (Viggle's turbo LoRAs, Alibaba PAI's acceleration LoRAs) and content LoRAs are on Hugging Face. On Windows and Linux they go into ComfyUI's models/loras folder and show up in the LoRA stack. I have not tested them with the bundle either.

Editing got better since launch

At launch the app's Edit lane took one reference image. Now, with Qwen-Image 2.1 on your own machine, small tiles under the source image take up to three more images. You name them in the prompt as image 2, image 3, for example "put the jacket from image 2 on the person". There is still no mask with this model. You describe the change in words.

There is also a "Transparent background" switch for new pictures. The result is saved as a PNG with an alpha channel.

On a Mac

The Mac build (Apple Silicon, beta) runs Qwen-Image 2.1 without ComfyUI, as quantized packs:

Qwen-Image 2.1 4-bit          needs 16 GB
Qwen-Image 2.1 8-bit, Turbo   need 24 GB

Qwen-Image 2.1 Turbo made an image in 38 seconds on an M5 Pro with 48 GB, the only Mac the build has run on. A LoRA that carries its own alpha is weighted alpha divided by rank there, the way ComfyUI does it.

The license does not change with the weights

Qwen-Image 2.1 is under the Qwen Research License. Research and evaluation are covered, commercial use needs a separate license from Alibaba Qwen. The community builds above name the same license. An uncensored text encoder does not turn a research license into a commercial one. If you need Apache 2.0 terms, Qwen-Image 2512 and Qwen-Image-Edit 2511 are still under Apache 2.0.

Short version

Running Qwen-Image 2.1 locally already removes any moderation layer. The No Filter build swaps only the text encoder (about 9 GB on top), Noct Q changes the image model itself (about 7 GB on top), and community GGUF builds go in by hand. Edits take up to three extra images and no mask, the Mac runs it from 16 GB, and every variant is still research and evaluation only.

The code is at github.com/PurpleDoubleD/locally-uncensored, and the longer page with the files and the FAQ is Qwen-Image 2.1, uncensored on your own card.

Uncensored AI on a Mac: which local models fit which memory size

David — Tue, 13 Oct 2026 21:31:20 +0000

"Uncensored AI on a Mac" is two questions in one. Which models answer without refusing, and which of them fit into the memory your Mac has. The second question decides more than the first, so this post takes them in that order of usefulness: what the word means, what fits where, and how to get one running with the Mac build of Locally Uncensored (open source, AGPL-3.0, free for local use).

One caveat before anything else. The Mac build is a beta. It has run on one Mac so far, an M5 Pro with 48 GB. Sizes below come from the model files. Where I have not run something on a Mac myself, I say so.

What "uncensored" means for a local model

A local model has no moderation layer in front of it. Nothing reads your prompt before the model does, and nothing reads the answer afterwards. What is left is the model's own training, and a stock model from a big lab is trained to refuse a range of requests.

The models people call uncensored change that part. Two labels come up most:

Abliterated   the direction in the weights that produces refusals is removed
Heretic       an abliteration made with the Heretic tool, same idea, automated

Neither is magic. An abliterated model can still decline now and then, and removing the refusal behaviour can cost a little quality elsewhere. If one model keeps hedging on the kind of thing you ask, try another one from the list before you blame your prompt.

The app adds nothing on top. The default persona states a role and no content rule in either direction, so what you get is the model.

The number that matters is unified memory

On Apple Silicon there is no separate video memory. The model shares one pool with macOS, your browser and everything else. So the chip name tells you how fast the answer comes, and the memory size tells you which model you can load at all. An M4 with 16 GB loads the same models as an M2 with 16 GB.

A working rule: the model file plus 1 to 2 GB for context has to fit into what is left after macOS and your open apps have taken their 4 to 6 GB.

Chat models, by download size

These are the uncensored chat models the app's catalog recommends to start with:

Llama 3.1 8B Abliterated        5 GB     the usual first download
Qwen3-VL 8B Abliterated         5 GB     reads images
Gemma 4 12B Heretic             7.4 GB   reads images
GLM 4.7 Flash Heretic           10 GB    30B class in a small build
Qwen 3.8 27B Uncensored         18 GB    images, tools, switchable thinking
Qwen 3.6 35B MoE Abliterated    24 GB    35B total, 3B active

Read against the rule above, that gives roughly this:

16 GB Mac    the 5 GB models comfortably, Gemma 4 12B Heretic with less open
24 GB Mac    adds GLM 4.7 Flash Heretic
32 GB Mac    adds Qwen 3.8 27B Uncensored, the first tier I would recommend
48 GB and up adds Qwen 3.6 35B MoE Abliterated with room for long context

That mapping is arithmetic on file sizes. I have run chat on the 48 GB machine only, so on a 16 or 24 GB Mac treat it as a starting point and tell me where it is wrong.

The setup wizard picks a first model for your machine, and the model manager marks what fits. You do not have to do this arithmetic yourself. It helps to understand why the app offers what it offers.

Images and video

Create on the Mac makes images and video on the Mac itself, without ComfyUI. The Mac catalog has a separate group called Unfiltered next to Mainstream:

Image models    23 in the catalog, 10 of them in the Unfiltered group
Video models    31 in the catalog, 14 of them in the Unfiltered group

Every tile says how much memory the model needs, and the app holds you to it. Image models start at 8 GB, video models at 16 GB. Most video models in the Mac catalog are marked "Experimental: not yet tested in LU", and that label is meant literally.

For a sense of speed, on the M5 Pro with 48 GB one image took 33 seconds with DreamShaper XL Turbo and 38 seconds with Qwen-Image 2.1 Turbo.

Getting it running

Apple Silicon, macOS 14 or newer. Intel Macs are not supported.

Download the .dmg from locallyuncensored.com/mac. It is signed with a Developer ID and notarized by Apple.
Drag the app into Applications and start it.
Let the setup wizard pick a first model, or open Models and choose one from the list above.
Send a message.

There is no account and no sign-in for local use.

What the app sends, since that is the point of running locally

Your prompts and answers stay on the machine when you use a local model. The app has no analytics kit and sends no crash reports. Two things do go out on their own: it asks GitHub Releases for a new version a few seconds after start and at most every six hours after that, and it counts each press of the Cloud switch (which way, the platform and the app version, without an identifier). If you never touch the Cloud switch, the second one never fires.

What is not there yet on a Mac

Training your own character LoRA does not run locally on a Mac. Computer control is in the app but not fully tested on macOS. Voice works locally but is a beta and English only. Remote Access and the automatic update are not confirmed on macOS. I wrote these up in more detail in the post about what the Mac build runs.

Short version

Uncensored on a Mac comes down to picking an abliterated model that fits your unified memory. 16 GB runs the 8B class, 32 GB is where Qwen 3.8 27B Uncensored fits, and the app's Unfiltered groups cover images and video on the same machine. It all runs locally, with no account, in a build that is still a beta and has seen one Mac.

The code is at github.com/PurpleDoubleD/locally-uncensored. The longer tier list by memory size is in What a Mac can actually run locally in 2026, and the background on abliteration is in the abliterated models guide.

If your Mac is too small for the model you want, the bigger ones also run hosted in a browser as LU Cloud. That part is paid. Everything above is free.

Local AI on a Mac: what one open source app runs on Apple Silicon, and what it does not

David — Tue, 13 Oct 2026 19:43:50 +0000

Locally Uncensored 3.0.6 is the first release with a Mac build. It is an open source desktop app (AGPL-3.0) that runs AI models on your own machine: chat, a coding agent, image and video generation, voice, and a model that can use your mouse and keyboard. On Windows and Linux it has 170,000+ downloads. On the Mac it is a beta, and the honest reason is short: the app has run on exactly one Mac so far.

This post goes through each part of the app and says what runs locally on a Mac today, what only runs on Windows and Linux, and what I have not tested.

What you need

Apple Silicon (Intel Macs are not supported)
macOS 14 or newer

The one Mac it has run on is an M5 Pro with 48 GB on macOS 26. It has not run on macOS 14 or 15, and not on a Mac with 16 or 24 GB. If you have one of those, your report is worth more to me than another run on my own machine.

Install

Download the .dmg for Apple Silicon from locallyuncensored.com/mac.
Open it and drag the app into Applications.
Start it. The setup wizard picks a first model for your machine.

The .dmg is signed with a Developer ID and notarized by Apple. Local use is free and needs no account.

Local chat with an LLM

Local models run through a bundled server with Metal. There is no separate runner to install first. If you already use Ollama or LM Studio, the app can talk to those as backends too.

Around the chat itself: thinking is shown as it happens, you can chat with your own documents through a local index, keep a memory across conversations, switch personas, and compare two models side by side. Models with image input download together with their image part, the second file a local model needs to see pictures. That download path is new in 3.0.6 and I have not checked it on the Mac specifically.

There is also a Local API: an OpenAI compatible server on port 8129 that lists your local models under one address. It listens on localhost unless you allow the LAN, and it always asks for a token.

Local image generation without ComfyUI

On Windows and Linux the app drives ComfyUI. On a Mac it does not use ComfyUI at all. Create makes images on the Mac itself, on engines the app installs for itself.

The Mac catalog lists 23 image models. Each tile says how much memory the model needs, and that number is a hard limit, not a hint: a model that needs 32 GB stays locked on a 16 GB Mac. The smallest ones (SD Turbo, Realistic Vision V5.1) need 8 GB.

Measured on the M5 Pro with 48 GB:

DreamShaper XL Turbo    one image    33 s
Qwen-Image 2.1 Turbo    one image    38 s

A smaller Mac will be slower. I have not measured by how much.

One Mac detail the app handles for you: chat and Create share one pool of memory. Before a picture or video run, Create takes the chat model out of memory, shows "Freeing memory..." while it does, and brings the model back afterwards.

Local image editing

Edit on the Mac runs on Qwen-Image 2.1, and the Edit tab appears once that model is installed. The 4-bit pack needs 16 GB.

It works differently from the brush you may be used to. There is no mask. You give it a picture and describe the change in words, and you can add reference images.

Edit on the Mac is in the code and in the app. It is not in the list of things I timed for the release, so treat it as less proven than plain generation.

LoRAs on the Mac

You can use LoRAs with the quantized image models in the Mac catalog, the ones whose names end in 4-bit or 8-bit: Qwen-Image 2.1, Qwen-Image 2512, Z-Image Turbo and FLUX.2 klein 4B. There is a LoRA list with its own folder, a stack with strength sliders, and delete moves the file to the Trash.

A Qwen-Image 2.1 LoRA that carries its own alpha is weighted the way ComfyUI does it, alpha divided by rank. Before 3.0.6 it ran at the full strength that was set, which was too strong.

Character LoRA training: not locally on a Mac

This one I want to state flat, because people search for it. Training a character LoRA on your own hardware works in the app on Windows and Linux, where Character Studio trains on your own card and drops the result into your local LoRA folder. It does not run locally on a Mac. On a Mac, character training goes through the hosted side, and a character trained there can be downloaded as a .safetensors file.

Local video generation

The Mac catalog lists 31 video models. The smallest need 16 GB: LTX-2.3 Distilled 4-bit, and Wan 2.1 T2V 1.3B, which is better off with 32.

LTX-2.3 Distilled 4-bit    2 s clip, 768x512, with sound    64 s    (M5 Pro, 48 GB)

Two things to know before you start a long run. Where a model was timed on a real run, Create tells you before the start how long a clip will take once that is ten minutes or more, and during the run it shows the step and the time left. And most video models in the Mac catalog are marked "Experimental: not yet tested in LU". Take that label at its word.

Animate, which starts a clip from a picture, is there once you have installed a video model that takes a start image.

What Create does not do locally on a Mac

On Windows and Linux, Create also has local lanes for background removal, talking character, music, extending a clip and motion control. None of those run locally on the Mac build. Upscale and erase are hosted on every platform.

Voice mode

You talk, the chat model you picked answers, and you hear the answer. Speech recognition, the voice and the turn taking run on your machine. There are fifteen voices, and you can interrupt an answer by speaking.

Numbers from the M5 Pro:

Setup download          about 0.7 GB
Answer starts           1.4 to 2.0 s after the end of the question
Voice engine in memory  1.2 to 1.3 GB

Voice is in beta and English only. On the Mac it has been tried by hand in the app. It did not get the point by point check the Windows app got.

Local computer control

A model uses the mouse and keyboard in apps you approve. It is off by default. In every new chat it asks once before it looks at the screen, and it never types into a password field.

On a Mac it is more limited than on Windows, and it is not fully tested yet. The app says so at its switch. What is different:

macOS has to grant two permissions first, Accessibility and Screen Recording.
On Windows the model gets a list of the buttons and fields in a window. On macOS that list is not available, so the model needs image input and works from screenshots.
For the same reason the app cannot name what a click would press, so every click is asked and needs your click.
The autonomous mode exists on Windows only.

Control+Option+Space pauses and Control+Option+Esc stops. I would use this on a Mac to try it out, not to rely on it.

Coding agent

The Agent and Code tabs are in the Mac build. The agent's shell gets the PATH of your login shell, so tools installed through Homebrew are found. The agent can also call the local image and video engines as tools. I have no separate Mac test run for these two tabs to point at.

Not confirmed on macOS

Remote Access (using the app from your phone)
Automatic update (there is no older Mac version to update from)

Short version

Local chat, image generation, image editing by prompt, LoRAs, video and voice run on the Mac itself, with no ComfyUI and no account. Character LoRA training, music, talking character and the other extra lanes do not run locally on a Mac yet. Computer control is there but not fully tested. All of it has run on one M5 Pro with 48 GB, which is why the build says beta.

If something breaks on your machine, the issue tracker is the place. The code is at github.com/PurpleDoubleD/locally-uncensored, and the Mac page keeps the current state of each part.

If your Mac is an Intel model or short on memory, the same kind of models also run hosted in a browser as LU Cloud. That part is paid. Everything above is free.

How to Run Qwen-Image 2.1 Locally: One Model That Draws and Edits

David — Tue, 22 Sep 2026 10:13:53 +0000

Alibaba Qwen published Qwen-Image 2.1 on 20 September 2026. The interesting part for anyone running models on their own hardware is not the benchmark table, it is the file count: one set of weights now does text to image and image editing. There is no separate edit model in this generation.

The less interesting part, which you should read before you spend 16 GB of bandwidth, is the license. More on that at the end, and it is not a footnote.

What is actually in the box

The architecture moved, and it moved downwards:

Image model: 7B parameters, single stream DiT, 32 layers
Text encoder: Qwen3-VL-8B
VAE: new, 64 channels, RGBA
Objective: flow matching

For comparison, the original Qwen-Image from August 2025 (the one usually written as 2508) had a 20B image model and a Qwen2.5-VL encoder. So 2.1 is not a bigger sibling of the old model, it is a different and smaller one. Anything you tuned against the 20B shape has nothing to attach to.

New in 2.1 against everything before it: a native alpha channel, up to ten reference images in one pass, local editing driven by a drawn marking rather than only a painted mask, a prefix KV cache to speed up repeated edits, and better typography. Native 2K carried over from 2.0 in February 2026.

Memory

I have not benchmarked this model, so these are quoted numbers, not mine. ai.rs puts the int8 pipeline at roughly 16 GiB in total: about 6.8 GiB for the image model, 8.7 GiB for the text encoder and 0.6 GiB for the VAE. A 24 GB card keeps all three parts resident. On a 16 GB card the usual approach is to push the text encoder into system RAM and let the card carry the rest. The full bf16 weights are a different machine entirely at 33 to 40 GB.

ai.rs also reports 5.93 seconds on an RTX 5090. Their hardware, their measurement, quoted as such.

The three files

The int8 repack from Comfy-Org is three files that go into three different ComfyUI folders:

ComfyUI/models/diffusion_models/qwen_image_2.1_int8_convrot.safetensors
ComfyUI/models/text_encoders/qwen3vl_8b_int8_convrot.safetensors
ComfyUI/models/vae/qwen_image_2.1_vae_bf16.safetensors

Sizes, as Hugging Face lists them and as they measure on disk: 7.26 GB (6.76 GiB), 9.35 GB (8.71 GiB), 676 MB (0.63 GiB). Full bf16 versions of the first two exist at 14.2 GB and 17.5 GB, and there is a w4a8 encoder variant at 6.31 GB if you want to trade quality for memory.

The version gate you will hit first

ComfyUI added support in 0.37.0, merged on 19 September 2026, and it brought a new encode node:

TextEncodeQwenImage21

The older Qwen-Image edit nodes do not fit this model. If you are assembling a graph by hand and it fails at the encode step, check your ComfyUI version before you check anything else.

If you would rather not assemble the graph at all, Locally Uncensored 3.0.1 (AGPL-3.0, Windows and Linux) ships it as a Model Manager bundle called "Qwen-Image 2.1 (Generate and Edit)": 16.1 GB, three files, one click, into the folders above. It refuses politely on an older backend with exactly this line:

Qwen-Image 2.1 needs ComfyUI 0.37.0 or newer. Update ComfyUI in Settings.

Which is a small thing, but a better small thing than a graph that dies two nodes in.

Values that work

Straight from the official template:

Steps: 25
CFG: 1
Sampler: euler
Scheduler: simple
Resolution: 1024x1024

CFG below 1 is not usable with this model. If you are used to dialling CFG down on other models to soften things, that instinct will only produce noise here.

Generating and editing

Generation is what you expect: prompt in, negative prompt optional, picture out.

Editing is the part worth adjusting to. You give it one reference image and a prompt, and there is no mask. You describe the change in words instead of painting where it should happen. In Locally Uncensored the mask path is closed for this model on purpose, and the output follows the reference image while the resolution follows the canvas you picked. Whether you find that liberating or annoying probably depends on how much of your workflow currently involves a brush.

What is not wired up yet

In Locally Uncensored 3.0.1, several of the model's own abilities are not exposed. Stated flat, with nothing said about plans:

Several reference images at once. The model takes ten, the app takes one.
RGBA output. The VAE has the channel, the app does not write it out.
Masks with this model.
A prompt enhancer and the KV cache node.

And across the board, not app specific: there is no Lightning or Turbo LoRA for 2.1 as of 21 September 2026. The old Qwen-Image speed LoRAs were built for the 20B architecture and do not fit. If your habit is to reach for a 4 step LoRA, there is nothing to reach for yet.

The license

Qwen-Image 2.1 is published under the Qwen Research License. Research and evaluation are covered. Commercial use is not, and needs a separate license from Alibaba Qwen.

This is a real break with the rest of the series. Qwen-Image 2512 and Qwen-Image-Edit 2511 are Apache 2.0 and they stay Apache 2.0. So if you are generating assets for paid work, or building something you intend to sell, the newest model in the family is not the one to build on as published, and the older pair is.

Worth saying plainly because the naming does not warn you. It reads like the next version of an Apache 2.0 model, and the terms underneath are not the same terms.

Short version

A 7B model that draws and edits with one set of weights, about 16 GiB of int8 pipeline, ComfyUI 0.37.0 or newer, 25 steps at CFG 1, one reference image and no mask when editing, and a license that stops at research and evaluation. If that last clause does not block what you are doing, it is a cheap thing to try. If it does, the Apache 2.0 entries in the same series are still there.

The longer walkthrough with screenshots of each step lives on the Locally Uncensored blog.