How to Run Ornith 1.5 Uncensored Locally: A Complete Setup Guide

In this guide, you'll learn:

• What an uncensored Ornith 1.5 is, and what abliteration changed in it
• Which of the community builds to run at each size, and what hardware each one needs
• How to run Ornith 1.5 uncensored locally with Atomic Chat or llama.cpp

This article is about the uncensored builds. For the original weights from DeepReinforce, see our guides to running Ornith 1.5 9B locally and Ornith 1.5 35B locally. If you're choosing a local coding model more broadly, see our guide to the best local LLMs for coding.

What is Ornith 1.5 Uncensored?

Ornith 1.5 Uncensored is the community-edited version of DeepReinforce's Ornith 1.5: the same 9B and 35B coding models, with the refusal behavior taken out of the weights. The builds come from individual people on Hugging Face, not from DeepReinforce.

DeepReinforce published Ornith 1.5 9B and Ornith 1.5 35B-A3B under the MIT license on August 19, 2026, and within a day several people edited the part of those weights that makes the model decline requests and republished the result. The license allows it. Every build in this guide is one of those community edits, and each one was made by a different person with a different method.

The family has a third tag, the 397B MoE flagship, under the same license. Community derivatives of the 397B total 194 downloads, against 103,866 for the 35B-A3B and 53,572 for the 9B, so this guide covers the two sizes people actually edited and ran.

The underlying models are unchanged:

Abliteration edits weights, it does not retrain the model, so the parameter count, the layer count, the context window and the memory arithmetic all carry over from the original.

Two parts of the model sit outside the edit. The vision tower is one, and every build here leaves it alone: Thunder13240 reports its projector as bit-identical to the base, and PocketAiHub ships the pinned upstream tower unchanged. The multi-token prediction head is the one that moves around, and each publisher handles it differently. PocketAiHub drops it, dealignai keeps and ablates it, gbuzhf grafts one back in from the original checkpoint, and SC117 replaces it outright. The table in the build section says which is which.

What abliteration does to Ornith 1.5

Researchers found that refusal in many aligned models is governed by a single direction in the model's residual stream, the internal state it passes from layer to layer. Arditi et al. showed this across 13 open-weight chat models at NeurIPS 2024: erase that one direction and the model stops declining harmful instructions, add it back and the model starts declining harmless ones.

To find the direction, you run the model over matched sets of harmful and harmless prompts, record the activations, and take the difference in means between the two. Then you remove the model's ability to write to that direction, permanently, by orthogonalizing the weight matrices against it. No training data and no gradient descent are involved, which is why an abliterated Ornith 1.5 appeared within a day of the original rather than weeks.

For the method on its own, across models and toolchains, see our explainer on what abliterated models are; for the wider category of builds, our roundup of the best uncensored LLMs to run locally. The same edit on a different model is covered in our guide to running Qwen 3.8 27B uncensored locally. What follows is specific to Ornith 1.5, because two things about this model change how the edit behaves and how it gets measured.

Abliterated, uncensored, or something else?

Abliterated names the method, uncensored names the result. Uncensored also covers models like Dolphin and Hermes that got there by training on extra instruction data instead, so the two words are not synonyms in general. On Ornith 1.5 they happen to point at the same files, because every build in this guide was made by editing weights rather than by fine-tuning.

The publishers do not agree on vocabulary, which makes the repositories harder to search than they should be. mradermacher, junafinity and zaakirio label their builds uncensored. huihui-ai, PocketAiHub, alztrk and codecraftersllc label theirs abliterated. dealignai calls its method CRACK and uses neither word in the file names. Searching one term on Hugging Face misses most of the other camp.

You will also see the spelling ablated and the malapropism obliterated. Both refer to the same technique. The word abliteration is a community coinage for what Arditi et al. called directional ablation, and it does not appear in that paper.

Why a reasoning model breaks the usual refusal test

Ornith 1.5 opens each answer with a thinking block, and its chat template ends the generation prompt inside that block rather than before it. Abliteration tooling samples activations at the start of the model's response, so on this model it samples at the start of the model's reasoning. The direction it recovers describes a model about to think about refusing rather than a model about to refuse, and those are different features.

Thunder13240 documented what that costs. Sampling inside the thinking block, a 200-trial search and a 13-recipe sweep could not get below roughly 22 refusals out of 100, and raising the ablation strength spent capability without moving the refusal count. Closing the block first, by setting the response prefix to \n</think>\n\n before computing directions, took the same recipe from 22 out of 100 to 0 out of 100 at a lower KL divergence.

The diagnostic is worth knowing if you ever run the tooling yourself. Ornith 1.5 9B scores 67 refusals out of 100 when the score is taken inside the reasoning block and 99 out of 100 when it is taken on the answers. A safety-tuned model that measures only two thirds censored is a sign that the wrong text is being scored.

This is also why the refusal numbers in the next section cannot be lined up against each other. Thinking mode is the largest single variable in every one of these measurements, and most publishers do not say which mode they used.

What the edit costs

The edit is small in weight-space terms. gbuzhf measured the abliterated 35B against the original BF16 weights over wikitext-2 and reports a mean KL divergence of 0.0151 with the same top token 95.04 percent of the time, which is a smaller perturbation than quantizing the model to Q6_K. Thunder13240 reports 0.0376 on the 9B, against a stated damage threshold around 0.5, and 43 modified tensors out of 760, all in the text decoder.

dealignai is the only publisher that scored MMLU against the un-abliterated base at the same quant, which isolates the edit from the quantization:

The deltas swing in both directions above 3-bit, which is what an edit that lands inside the noise floor looks like on a single benchmark. At Q2_K the model loses 8 points, and that is the row worth taking seriously. Nobody has published math, code, multilingual or vision numbers for any of these builds.

One number in these repositories reads worse than it is. Top-token agreement runs low on Ornith 1.5 whatever you do to the weights, so a build scoring 90 percent is not a damaged build. Thunder13240 ran the control: the untouched base quantized on the same harness scores 88.93 percent, the abliterated build scores 90.81, and DeepReinforce's own Q4_K_M scores 91.29. Judge these files by KL divergence.

What the edit removes is not in dispute. Over-refusal and safety-refusal are the same direction in the weights. Remove one and the other goes with it, which is why every card in this space ships a responsibility clause. You are now the only guardrail in the loop.

Which uncensored Ornith 1.5 build should you run?

At least a dozen people have published an uncensored Ornith 1.5, and others have repackaged those. Five are worth your download, for different reasons.

The 9B builds

Thunder13240 is the one to download if you want to know what you are getting. It is the only Ornith 1.5 build whose card publishes the method, the measurement, and a control experiment against the unmodified base. It reports 0 genuine refusals out of 100 where the original scores 99, uniform across 20 prompt groups, at a KL divergence of 0.0376. The card also documents the thinking-block problem described above, which is how it got there.

The catch is the ladder. Uploads are landing progressively over hours on a slow connection, and the highest quant live so far is Q4_K_M at 5.6 GB. Ten files are up, most of them 1-bit and 2-bit, and Q8_0, Q6_K, Q5_K_M, IQ4_XS and Q4_K_S are built and queued. Check the repository before you plan around a specific file.

The card also carries an improvement worth knowing if you quantize hybrid models yourself. llama.cpp's stock Q4_K_M recipe quantizes the projections that feed the recurrent state at the base 4-bit rate. Protecting those 72 tensors at Q8_0 lifts top-token agreement from 90.81 to 92.97 percent, above DeepReinforce's own build.

mradermacher gets you the full ladder. Twelve quants run from Q2_K at 3.8 GB to f16 at 17.9 GB, with two projector files, and the repository has the download count to match. What it does not have is any documentation of the edit: the card describes no method, and it quantizes junafinity's weights rather than editing anything itself. Take it when you need a specific file size that Thunder13240 has not uploaded yet, and test the behavior yourself.

The 35B-A3B builds

PocketAiHub is the most carefully measured of the three: 100 harmful and 100 benign prompts from JailbreakBench, run against each quantized model with thinking disabled, flagged by a phrase detector and then confirmed by hand. Q4_K_M returns 3 refusals out of 100 and Q8_0 returns 1, with no refusals on either benign set. The card publishes KL divergence per quant against its own BF16, 0.0728 at Q4_K_M and 0.0136 at Q8_0. The limits are the ladder, three text files only, and the prediction head, which this build does not include.

dealignai covers the sizes PocketAiHub skips. Six quants run from Q2_K at 13.2 GB to Q8_0 at 37.8 GB, the sub-8-bit files carry both an importance matrix and an activation-aware pass, and the prediction head survives in all of them. It is the only 35B build with a capability table. Its refusal figure is the weakest part: 100 percent attack success across 240 HarmBench behaviors reads well until you notice the card never says what decided that a response counted.

gbuzhf is the pick if you want speculative decoding. It takes PocketAiHub's abliterated weights and grafts a prediction head back in from the original checkpoint. Nine tiers run between 14.4 and 30.2 GB, with KL divergence and top-token agreement measured on every one, and draft acceptance runs 96.77 percent on the 22.8 GB tier. The abliteration is PocketAiHub's rather than gbuzhf's, and the grafted draft head is not abliterated while the trunk is, which the card states plainly. The projector is not re-hosted here, so download it from PocketAiHub or the model is blind.

One more build deserves a mention without a table row. SC117 runs Heretic on the 35B and reports 9 refusals out of 100 in the search log, re-scored to 11 out of 100 after export, at a KL divergence of 0.0105. It also replaces the prediction head rather than grafting the original, on the grounds that the shipped head matches random initialization. Its four APEX tiers are worth reading the card for, because I-Balanced at 26.1 GB is larger than I-Quality at 23.5 GB: the tiers allocate bits per tensor rather than stepping down a size ladder, so a bigger file is not the better file here.

Heretic itself behaves differently on the two sizes, and neither card mentions it. On the dense 9B it reaches the attention and the MLP down-projections, which is its full coverage. On the 35B the experts are stored as one fused tensor rather than a list of modules, the loop that would edit them raises an error that gets swallowed, and the run continues on attention alone with no warning. Two attempts to fix that closed without merging, and the maintainer's position is that touching the MLP is usually the more damaging trade anyway. SC117's card claims the down-projections were edited anyway, and the repository publishes no run log to check that against.

Why the refusal numbers don't line up

Four of these publishers report a refusal figure. No two of them measured the same thing.

The rows differ in the prompt set, the number of prompts, what decides that an answer counts as a refusal, and whether the model was thinking. A response that opens with a warning and then delivers exactly what was asked scores as a refusal under one publisher's detector and as compliance under another's. One of the four states its thinking mode, which on a reasoning model is the setting that moves the number most. SC117's two figures are for one build and differ by two points on when it was scored.

mradermacher, huihui-ai and alztrk are missing from the table because they publish no refusal number at all, which is its own kind of answer.

A refusal rate describes one publisher's own test, on their prompts and their detector. Run your own prompts against a build before you rely on it, and turn thinking off when you do, so that you are scoring answers rather than reasoning.

Does quantization bring the refusals back?

It does not, and one publisher checked. gbuzhf measured every tier against both the abliterated BF16 and the original BF16, and reports that no tier un-abliterates: the distance to the original weights stays above abliteration's own distance of 0.0151 at every size, down to the 14.4 GB tier. The two kinds of damage also turn out to be strongly sub-additive, so quantizing an already-edited model costs less than adding the two effects together would suggest.

What low-bit quantization does affect is everything else. gbuzhf's own ladder shows mean KL divergence climbing from 0.0222 at the 30.2 GB tier to 0.2546 at 14.4 GB, with top-token agreement falling from 94.05 to 80.70 percent, and dealignai's MMLU column drops 8 points at Q2_K. The refusal boundary is the least stable property of an edited model, and the only repository that measures it below 4-bit is dealignai's, which reports the same near-total compliance at Q3_K_M and Q2_K as it does at Q8_0 without saying what decided that a response counted. Judge behavior on a 4-bit build or larger.

Ornith 1.5 uncensored hardware requirements

The system requirement to check is memory. On Apple Silicon, compare the numbers below against 75 percent of unified memory, which is all macOS gives the model by default.

For the 9B, sizes are from mradermacher's ladder, the only complete one at this size:

For the 35B, the tiers come from different publishers, so the build is named with each:

Note: if you are choosing between two neighbouring files and both still fit in memory, take the larger one. It costs a gigabyte or two more and picks the wrong token noticeably less often, especially at the bottom of the ladder, where quality falls fastest.

With a smaller card, the 35B has an option the 9B does not. Keep the experts in system RAM instead of dropping to a smaller file: they are most of the weights, but only 3B of them run per token, so the arithmetic stays cheap while the bandwidth cost moves to RAM. The same trade is what makes DeepSeek V4 Flash practical on desktop hardware. In llama.cpp, --cpu-moe puts every expert on the CPU and --n-cpu-moe N offloads the experts of the first N layers. Count the full file size against RAM plus VRAM when you plan the download.

How much memory does the context window add?

The figures above only cover the model weights. On top of that, the engine allocates a KV cache: the longer you chat, the more context the model holds in memory, and the more gigabytes that takes. The same goes for pasting big documents or codebases into the conversation.

In a conventional dense transformer, all 32 layers of the 9B would store attention data for every token. Here, 24 of the 32 use linear attention with a fixed-size state, and the 8 full-attention layers use just 4 KV heads. Measured on our builds of the original weights, the model keeps 32 KB of attention cache per token:

Abliteration does not touch the attention layout, so these figures carry over to the edited builds unchanged. The full 262K window fits on a 24 GB card alongside a Q8_0 file, which together come to about 18 GB.

What hardware can run Ornith 1.5 uncensored?

• 8 GB GPUs (RTX 3060 Ti, RTX 4060): can run a 4-bit 9B entirely in VRAM with room for about 32K of context.
• 12 GB GPUs (RTX 3060 12 GB, RTX 4070): can run a 5-bit 9B with room for 128K, or serve a 4-bit 35B with the experts in system RAM.
• 16 GB GPUs (RTX 4060 Ti 16 GB, RTX 5060 Ti): can run the 9B at Q6_K, or the smallest 35B tier entirely in VRAM.
• 24 GB GPUs (RTX 3090, RTX 4090): can run PocketAiHub's 21.2 GB Q4_K_M entirely in VRAM, or the 9B at Q8_0 with the full context window.
• RTX 5090 (32 GB VRAM): can run gbuzhf's 24.9 GB tier with context headroom, which is where the 35B behaves closest to the original.
• MacBook Pro (16 GB unified memory): can run a 4-bit 9B. macOS caps GPU-addressable memory at roughly 75 percent of unified memory by default, so a 16 GB Mac gives the model about 12 GB.
• Mac Studio, MacBook Pro M4/M5 Max (32-64 GB): can run the 35B tiers, and this is where the MLX builds are worth trying instead of GGUF. PocketAiHub ships MLX at 4-bit, 8-bit and BF16; see our GGUF vs MLX guide if you're choosing between formats.
• Phones: no. For a model that runs on a phone, see the smaller entries in our uncensored roundup.

How to run Ornith 1.5 uncensored locally with Atomic Chat

Atomic Chat is a free, open-source local AI app we built. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

Here's how to run Ornith 1.5 uncensored with Atomic Chat:

Step 1: Install Atomic Chat

Download Atomic Chat from atomic.chat and install the build for your platform:

• macOS: a universal .dmg (Intel and Apple Silicon), macOS 13.6 or later
• Windows: an .exe installer for x64
• Linux: a self-contained .AppImage for x86_64, which needs no root
• iOS: through the App Store
• Android: through Google Play

On Linux, mark the AppImage executable with chmod +x and run it directly. If the app asks about FUSE on first launch, install it with sudo apt install fuse libfuse2 on Debian or Ubuntu, or sudo dnf install fuse fuse-libs on Fedora.

Step 2: Find an uncensored Ornith 1.5 GGUF

Open the Models tab and search for the repository you picked in the build section, for example:

Thunder13240/Ornith-1.5-9B-heretic-GGUF

The catalog is backed by Hugging Face, so community repositories appear alongside official ones. Check the publisher name on the result before you download, then expand the Download Options picker to list the available quantizations.

Note: several repositories carry near-identical names, and at least one card describes files that are no longer in its repository. See the Troubleshooting section for what to check before you download.

Step 3: Pick a quant for your memory

Use the hardware tables above. For the most common configurations:

• 8 GB GPU: download the 9B at Q4_K_M, at 5.6 GB.
• 24 GB GPU: download PocketAiHub's 35B Q4_K_M, at 21.2 GB.
• 32 GB and up: download gbuzhf's 25G-ICE tier, at 24.9 GB.

The picker lists every quantization in the repository under its short tag, smallest first, and leaves the vision projector out of that list. Its figures run a little above the file sizes in our tables, so match a build by its quant name rather than by the number next to it. Select the largest quant that fits with context headroom. If you're not sure what the quant names mean, see our guide to what GGUF is and how quantization works.

Step 4: Set the context, thinking, and sampling

The model declares a 262K context window, but configuring the maximum allocates the KV cache up front. Start with 8,192 tokens for chat or 32,768 for code and document work, and increase it only when the workload requires it.

Context size lives in the model's own settings. Open Settings → Model Providers → Llama.cpp, find the build in the model list, and click the gear icon on its row. Set three things there:

• Context Size: set it to 8192 or 32768. A value of 0 reads the maximum from the GGUF, which for this model means the full 262K window.
• Auto Increase Context Size: on by default. It grows the context when a conversation runs out of room, which can push a build that only just fit past your memory limit. Turn it off when you're working close to that limit.
• GPU Layers: -1 offloads every layer, which is what you want when the file fits in VRAM.

Changing Context Size or GPU Layers restarts the model, so set them before a long conversation.

Thinking is on by default. The lightbulb icon in the chat switches it off. With it off you are scoring answers rather than reasoning, which is how PocketAiHub took the one refusal figure here whose mode is stated.

Sampling is a separate panel: click the sliders icon next to the model name at the top of the chat. DeepReinforce's recommended values carry over from the original weights: temperature 1.0, top_p 0.95 and top_k 20 with a presence penalty of 1.5 for general work, or temperature 0.6 for coding. These settings are saved on the assistant, your chat profile, not on the model, so they stay the same when you switch models.

Step 5: Chat locally

After the download completes, Atomic Chat loads the model and opens it in the built-in chat. Send it a prompt the original declines, to check that the build you downloaded is the edited one.

Both sizes are native vision-language models and the vision tower survives abliteration, so you can attach an image to the chat and ask about it, once the separate projector file from the same repository sits next to the quant. The image, the weights, and your prompts stay on your machine.

Atomic Chat also exposes an OpenAI-compatible API server at http://localhost:1337/v1. Any tool that speaks the OpenAI API, including coding agents like Claude Code and Cline, can use the local model as a drop-in replacement for a cloud one.

How to run Ornith 1.5 uncensored with llama.cpp

You might prefer to run the model directly through llama.cpp if you need:

• A server you can start headless, with the host and port set by flag
• Precise control over GPU offload, which the 35B needs when the experts go to system RAM
• A reproducible server configuration

These builds use the same hybrid architecture as the original, which Ornith 1.5 inherits from Qwen 3.5, and which upstream llama.cpp has supported since PR #19468 shipped in February 2026, covering both the dense 9B and the 35B mixture-of-experts along with the vision path. They run on a current build with no patches.

Step 1: Build current llama.cpp

For NVIDIA CUDA:

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON
cmake --build build -j --target llama-cli llama-server llama-mtmd-cli

For Apple Silicon, Metal is enabled by default:

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j --target llama-cli llama-server llama-mtmd-cli

Step 2: Run the model

The following command downloads the 9B at Q4_K_M from Hugging Face, offloads all layers to the GPU, applies DeepReinforce's recommended sampling, and limits the context to 8K:

./build/bin/llama-cli \
  -hf Thunder13240/Ornith-1.5-9B-heretic-GGUF:Q4_K_M \
  --jinja \
  --temp 1.0 --top-p 0.95 --top-k 20 --presence-penalty 1.5 \
  -ngl 99 \
  -c 8192

For the 35B on a 24 GB card, point it at PocketAiHub instead:

./build/bin/llama-cli \
  -hf PocketAiHub/Ornith-1.5-35B-A3B-Abliterated-GGUF:Q4_K_M \
  --jinja \
  --temp 1.0 --top-p 0.95 --top-k 20 \
  -ngl 99 \
  -c 8192

Add --cpu-moe to that second command to keep the experts in system RAM on a smaller card, or --n-cpu-moe 20 to offload only the first 20 layers' experts.

Step 3: Expose a local OpenAI-compatible API

Replace llama-cli with llama-server:

./build/bin/llama-server \
  -hf PocketAiHub/Ornith-1.5-35B-A3B-Abliterated-GGUF:Q4_K_M \
  --alias ornith-1.5-uncensored \
  --jinja --reasoning-format deepseek \
  --temp 1.0 --top-p 0.95 --top-k 20 \
  -ngl 99 \
  -c 8192 \
  --host 127.0.0.1 --port 8080

Test it with:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{ "model": "ornith-1.5-uncensored", "messages": [ { "role": "user", "content": "Summarize what linear attention changes about memory use." } ] }'

Bind the server to 127.0.0.1 unless other machines on your network need access. The --reasoning-format deepseek flag separates the thinking block from the answer in the response, which keeps the reasoning out of your application's output.

Running vision through llama.cpp

Image input needs one extra file, the vision projector, which is shared by all quants in a repository and runs about 0.9 GB. Download it once and pass it alongside whichever quant you picked:

./build/bin/llama-mtmd-cli \
  -m Ornith-1.5-9B-heretic-Q4_K_M.gguf \
  --mmproj mmproj-Ornith-1.5-9B-heretic-f16.gguf \
  --image your-photo.jpg --image-min-tokens 1024 \
  -ngl 99 -c 8192 \
  -p "What is in this image?"

Keep --image-min-tokens 1024, because charts and screenshots get too few visual tokens without it. The projector file is named differently in each repository, so check the file list in yours before you copy the filename above. gbuzhf's repository does not host one at all: take PocketAiHub's, since that is the trunk those tiers were built from.

Speculative decoding with the MTP head

The original checkpoint ships a multi-token prediction head, the mechanism behind speculative decoding, and the builds that kept it can draft the next token ahead of the main model. Add the flags:

./build/bin/llama-server \
  -m Ornith-1.5-35B-A3B-Abliterated-MTPv2-23G-ICE.gguf \
  --spec-type draft-mtp --spec-draft-n-max 1 \
  -ngl 99 -c 8192

Only some builds carry the head. gbuzhf grafts one in from the original checkpoint and measures 96.77 percent draft acceptance on the 22.8 GB tier; dealignai keeps and ablates the original; PocketAiHub drops it, so these flags do nothing there. Older llama.cpp builds load these files and silently ignore the prediction tensors, so update first if you see no speedup. On gbuzhf's builds the drafted tokens come from a head that was not abliterated while the trunk was, which the card states; every drafted token is still verified by the model itself, so output quality is unaffected.

Running it with Ollama or LM Studio

Two uncensored 35B builds have Ollama tags:

ollama run codecraftersllc/ornith-1.5-35b-a3b-abliterated

ollama run aratan/Ornith-1.5-35B-A3B-Uncensored-GGUF:Q4_K_M

The first pulls 18 GB, a Q3_K_M file plus the vision projector, and sets the Qwen 3.5 renderer, a 32K context and DeepReinforce's coding sampling. The second pulls 22 GB at Q4_K_M and sets no renderer, so tool calling behaves differently. Note that :latest and :q3_k_m on the first one resolve to the same file rather than to two rungs of a ladder.

No uncensored 9B has an Ollama tag. huihui-ai publishes abliterated Ornith 1.5 weights at both sizes on Hugging Face but has not pushed either to Ollama, so its usual one-command route does not exist here.

LM Studio loads the GGUF files from all five builds directly; search the repository name. dealignai's card names it explicitly. On Apple Silicon, LM Studio also loads PocketAiHub's MLX builds.

Troubleshooting

The model still refuses

Abliteration reduces refusals, it does not eliminate them. The best-measured 35B build here still declines 3 prompts out of 100 on its own test set. Check three things:

• Turn thinking off with the lightbulb icon. PocketAiHub's numbers were measured that way, and the other cards never say which mode they used, so thinking is the variable they leave open.
• Move up one quant. The refusal boundary is the least stable part of an edited model, and the one publisher that measured it below 4-bit never says what decided that a response counted.
• Confirm you loaded the build you meant to load. The original weights and the edited ones sit under very similar names in the app catalog.

The model thinks forever and never answers

The reply comes back empty, or the token budget runs out before any text appears. Ornith 1.5 opens every answer inside a thinking block, and with thinking on a low token limit gets spent there before the answer starts. Turn thinking off for the prompt, or raise the token limit well above the default. This is not a corrupt download, and it is worth checking for on any build whose card reports a refusal figure: an empty completion reads as compliance to a keyword screen.

The build you downloaded is not what the card describes

Community re-uploads carry no publisher guarantee, and cards go stale. Before downloading from an unfamiliar repository, check that the model card describes an actual method, that the file list contains GGUF files of a plausible size, and that the files the card's own commands reference actually exist. A 9B model at 4-bit cannot weigh 400 MB. alztrk's card is the live example: it publishes a table of four GGUF files and a Modelfile pointing at a gguf/ directory, and a cleanup commit removed all of them from that repository twenty minutes after upload.

Image input does nothing

The vision projector is a separate file, not part of the quant you downloaded. Fetch the projector from the same repository and pass it with --mmproj, as in the vision section above. If your repository has no projector, take the one from the build it was derived from.

You run out of memory at long context

The weights fit, then a long conversation crashes the model. That's the KV cache growing past your headroom. Set an explicit Context Size instead of 0, turn off Auto Increase Context Size when you're near the limit, and if you need more room, step one quant down: on the 9B, at 32 KB of cache per token, every gigabyte you free adds about 32K of context.

Frequently asked questions

The questions that come up most often about running an uncensored Ornith 1.5 on your own hardware.

What is the difference between abliterated and uncensored models?

Abliterated describes how the model was changed: one direction in the weights, the one that governs refusal, was removed. Uncensored describes the result, and it also covers models that got there through fine-tuning rather than weight editing. Every Ornith 1.5 build in this guide is abliterated, so in this case both words point at the same files. You will also see ablated and obliterated used for the same thing.

Is Ornith 1.5 Uncensored an official DeepReinforce release?

No. DeepReinforce published Ornith 1.5 under the MIT license and the uncensored versions are community edits of those weights, made by individual publishers. DeepReinforce neither produced nor endorsed them.

How much VRAM does Ornith 1.5 uncensored need?

About 5.6 GB for the 9B at 4-bit, so an 8 GB GPU is comfortable with context headroom. For that hardware class, see our best local LLM for 8GB roundup. The 35B needs about 21 GB at 4-bit, which means a 24 GB card, or 13.2 GB at 2-bit. On Apple Silicon, macOS caps GPU memory at about 75 percent of unified memory, so a 16 GB Mac runs the 9B and 32 GB and up runs the 35B.

Can I run Ornith 1.5 uncensored on a 16GB Mac?

Yes, at 9B. macOS will hand the model about 12 GB of a 16 GB machine, which fits the 9B up to Q8_0 at 9.5 GB. The 35B does not fit at any usable quant. For what else runs well in that class, see our best local LLM for a 16GB Mac roundup.

Which uncensored Ornith 1.5 build is best?

Thunder13240's at 9B and PocketAiHub's at 35B, unless you need something the others have. Those two are the only ones that published a refusal measurement you can inspect. Take mradermacher when you need a 9B file size Thunder13240 has not uploaded, dealignai for the widest 35B ladder, and gbuzhf when you want speculative decoding.

Do abliterated models get dumber?

Barely, above 3-bit. dealignai scored its 35B against the un-abliterated base at matched quants on MMLU and the differences swing both directions between -0.6 and +2.4 points, which is what a change inside the noise floor looks like. At Q2_K the same comparison loses 8.1 points. In weight terms the edit is small: gbuzhf measures it at a KL divergence of 0.0151 from the original, less than quantizing to Q6_K costs. Nobody has published math, code, multilingual or vision numbers for any of these builds, so test one on your own work before you trust it.

Is Ornith 1.5 uncensored free for commercial use?

Yes. Ornith 1.5 ships under the MIT license and the uncensored builds inherit it: commercial use, modification, and redistribution are all allowed. Two publishers label their repositories Apache 2.0 while naming MIT as the base license, which does not change your obligations to DeepReinforce. What you generate with the model is your responsibility, and local law still applies.

Is it safe to download an uncensored Ornith 1.5 build?

The risk here is the wrong file rather than a malicious one. The weights are data rather than a program, but stick to repositories whose card describes an actual method and whose file list matches what the card claims. At least one card here documents files its repository no longer contains.

Does Ornith 1.5 uncensored support vision locally?

Yes. The vision tower sits outside the part of the model that abliteration edits, and every build in this guide leaves it alone. In Atomic Chat you attach the image to the chat; through llama.cpp you pass the separate projector file with --mmproj.

Does Ornith 1.5 uncensored work with Ollama or LM Studio?

At 35B, yes: ollama run codecraftersllc/ornith-1.5-35b-a3b-abliterated pulls 18 GB including the projector. No uncensored 9B has an Ollama tag. LM Studio loads the GGUF files from all five builds in this guide, and PocketAiHub's MLX builds on Apple Silicon.

Can I abliterate Ornith 1.5 myself?

Yes, with a caveat specific to this model. Heretic automates the search, but on a reasoning model it samples activations inside the thinking block by default, which caps how far the refusal count will fall no matter how hard you push. Set the response prefix to close that block first. On the 35B there is a second limit: the experts are stored as one fused tensor that the tool cannot reach, so the run edits attention only.

Bottom line

If you want an uncensored Ornith 1.5 and you have an 8 GB card, download Thunder13240's 9B at Q4_K_M and start at 8K of context: it is the only build at this size whose publisher documented the edit, measured it against the original, and published the control. On a 24 GB card, take PocketAiHub's 35B Q4_K_M at 21.2 GB, the most carefully measured of the 35B builds. From 32 GB, gbuzhf's 25G-ICE tier gets you the same edit with a working prediction head. Turn thinking off when you test any of them, so you are scoring answers rather than reasoning.

Key takeaways:

• Uncensored Ornith 1.5 builds are community edits of DeepReinforce's MIT weights. DeepReinforce did not publish them.
• Abliteration removes the refusal direction from the weights without retraining, so the size and memory arithmetic are unchanged.
• Ornith 1.5 is a reasoning model, and tooling that samples inside its thinking block recovers the wrong direction. One publisher went from 22 refusals out of 100 to zero by fixing only that.
• Refusal rates from different publishers were measured on different prompt sets, in different thinking modes. They cannot be ranked against each other.
• Quantization does not bring the refusals back, but it damages everything else, and the only refusal measurement below 4-bit comes from a card that never says what scored it.