Oct 26, 2026

How to Run Nanbeige4.3-33B Locally in LM Studio (No Code): Which Download, Settings, and Gotchas

Read time: ~8 minutes. The short version: install LM Studio, search for bartowski/Nanbeige_Nanbeige4.3-33B-GGUF, download Q4_K_M (20.79 GB) if your computer has about 32 GB of RAM or a 24 GB graphics card, then set temperature 0.6 and top-p 0.95 for normal chat. No code needed. Everything below explains which file to pick for your machine, what the settings mean, and what to do when it misbehaves.

Sourcing note: model facts, benchmark numbers and recommended settings come from the official Nanbeige/Nanbeige4.3-33B model card. File sizes come from the bartowski GGUF repo, a community conversion (Nanbeige has not published its own GGUF files as of October 26, 2026). App steps come from the LM Studio docs and the Hugging Face Ollama docs. Full links are at the bottom.

What Nanbeige4.3-33B is, in plain words

Nanbeige4.3-33B is an open-weight language model released on Hugging Face on October 24, 2026. “Open-weight” means you can download the whole model and run it on your own computer, offline, with no subscription and no data leaving your machine. It is released under the Apache-2.0 license, which allows commercial use.

A few facts from the official model card that matter for normal users:

Size: 33 billion parameters, in a single “dense” model (every word it writes uses the whole model). That makes it heavier to run than a mixture-of-experts model of similar headline size, so expect it to be slower than you might guess from the “30B class” label.
Input: text only. You can’t drop images into it.
Languages: the card lists English and Chinese.
Context: the model supports up to 524,288 tokens (512K). You will not be able to use anywhere near that much on a normal computer; more on that below.
Thinking mode: it “thinks” before answering by default, like other reasoning models. This can be switched off.
What it’s for: the team describes it as the flagship “teacher” model of the Nanbeige4.3 series, aimed at agentic coding and “professional cowork” tasks (multi-step office and tool-use work). A smaller Nanbeige4.3-3B is announced but not yet released.

If you have already tried a local model like Muse-Glimmer-30B or Qwen3.8-27B, this is the same kind of thing, and it runs in the same apps.

Is it actually better? What the benchmarks say (and don’t)

The model card compares Nanbeige4.3-33B with Qwen3.8-27B, Muse-Glimmer-30B and Gemma4-31B, all at their highest thinking effort, using the same settings and test harness. Some of the headline numbers:

Benchmark	Nanbeige4.3-33B	Qwen3.8-27B	Muse-Glimmer-30B	Gemma4-31B
Terminal-Bench 2.1	80.9	73.0	61.8	47.2
SWE-Bench Pro	60.3	61.7	36.9	51.2
Automation Bench	54.2	38.3	15.2	9.7
GDPval	84.8	86.4	75.8	71.4
Toolathlon-Verified	70.4	68.5	47.2	27.8
GPQA Diamond	89.5	89.2	83.5	91.3
AIME 2026	95.2	94.5	94.7	89.2

Three honest caveats before you get excited:

These are the vendor’s own numbers. Independent results usually take a few days to appear. Treat the table as a reason to try the model, not proof it beats the others for your work.
Qwen3.8-27B is close or ahead on several tests, including SWE-Bench Pro and GDPval. Nanbeige’s biggest leads are on long, multi-step agent tests (Terminal-Bench, Automation Bench, DeepPlanning).
The tests were run on the full-precision model. The files most people will download are compressed (“quantized”) versions, which lose some quality, especially the smallest ones.

The practical takeaway: if you mainly chat, write and summarize, a 30B-class model you already have may feel similar. If you want a local model to drive multi-step tasks, Nanbeige4.3-33B is worth a test run.

Step 1: Check whether your computer can run it

Local models live in your computer’s memory while they run. On a Mac with Apple Silicon, that’s your unified memory (RAM). On a Windows or Linux PC, it’s ideally your graphics card’s memory (VRAM), with regular RAM as a slower fallback.

LM Studio’s own minimum requirements are an Apple Silicon Mac (M1 or newer) on macOS 14+, or a Windows/Linux PC with an AVX2-capable CPU, and it recommends 16 GB of RAM or more. For a 33B model, you need more than that. Here are the real file sizes of the most useful downloads from the bartowski repo:

Download (quant)	File size	Who it’s for
Q8_0	35.20 GB	48 GB+ Macs or big GPUs; near-original quality
Q6_K	29.02 GB	48 GB Macs; “very high quality”
Q5_K_M	25.07 GB	32–36 GB Macs if you keep context small
Q4_K_M	20.79 GB	The default pick: 32 GB Macs, 24 GB GPUs
IQ4_XS	18.64 GB	Tight fit on 24 GB cards
Q3_K_M	15.92 GB	24 GB Macs, 16 GB GPUs with some RAM help
IQ2_M	12.19 GB	Last resort for 16 GB machines; noticeable quality loss

Rule of thumb (our estimate, not an official figure): you want free memory of at least the file size plus a few gigabytes for the conversation itself and your other apps. On a Mac, macOS keeps part of memory for the system, so a 32 GB Mac comfortably fits Q4_K_M but not Q6_K. If your machine has 16 GB total, this model will be painful; a smaller model like Gemma 4 12B will be a much better experience.

bartowski’s own advice in the repo is simple: “Don’t know which to choose? Grab Q4_K_M.” LM Studio’s docs give the same general guidance: choose a 4-bit option or higher if your machine can handle it.

Step 2: Install LM Studio and download the model

LM Studio is a free desktop app with a ChatGPT-style window for local models. It’s the easiest no-code route.

Download and install LM Studio from lmstudio.ai. If you already have it, update to the latest version first, because new models often need a newer built-in engine.
Open the Discover tab (the magnifying-glass icon; the shortcut is ⌘+2 on Mac or Ctrl+2 on Windows/Linux).
In the search box, paste: bartowski/Nanbeige_Nanbeige4.3-33B-GGUF. LM Studio’s docs say you can search by keyword, by user/model name, or by pasting a full Hugging Face URL, so https://huggingface.co/bartowski/Nanbeige_Nanbeige4.3-33B-GGUF works too.
Pick the file that matches your machine from the table above (most people: Q4_K_M) and click Download. It’s a 20 GB download, so give it time.
Watch out for look-alike repos. Search results for “Nanbeige4.3” also show many small community uploads and the Base model (Nanbeige4.3-33B-Base). The Base model is not tuned for chat and will ramble. Make sure the name doesn’t end in “Base”.

Step 3: Load it with sensible settings

Go to the Chat tab, click the model picker at the top, and choose Nanbeige4.3-33B.
Before it loads, LM Studio shows load settings. Two matter most:
- Context length: start with 8,192 to 16,384 tokens. The model supports 512K, but every extra token of context needs memory. A huge context is the most common reason a model that “should fit” crashes or crawls.
- GPU offload: on a Mac, leave it at the maximum. On a PC, push it as high as your graphics card allows; any layers that don’t fit run on the much slower CPU.
Open the settings sidebar in the chat and set sampling to the values from the official model card:

What you’re doing	Temperature	Top-p
Normal chat, questions, reasoning	0.6	0.95
Agent and tool-use tasks	1.0	0.95

The card also lists very large “max new tokens” values (65,536 for agent work, 262,144 for reasoning). That’s because thinking can be long. In LM Studio, just make sure you haven’t set a small response-length limit, or answers will get cut off mid-thought.

To avoid redoing this every time, LM Studio lets you save defaults per model: go to My Models (⌘+3 / Ctrl+3), click the gear icon next to the model, and set your context length and GPU offload there.

Step 4: Use it (and control thinking mode)

Type a question and you’ll see the model think first, then answer. According to the model card, the chat template has two switches:

enable_thinking turns reasoning on or off for a reply. It’s on by default. Turning it off gives faster, shorter answers for simple tasks.
preserve_thinking decides whether earlier reasoning stays in the conversation. The team recommends off for normal chat and Q&A, and on for multi-turn tool use, office tasks and coding agents. Their benchmark scores were measured with it on.

Whether you can flip these switches with a button depends on your app and version. If LM Studio doesn’t show a thinking toggle for this model, leave thinking on; it’s the default the model was tuned for. The quick test: ask “Which number is bigger, 9.11 or 9.8?” (the example in the official quickstart). A working setup thinks briefly and answers 9.8.

Good first tasks to judge it: a multi-step plan (for example “plan a three-day product launch with a checklist for each day”), a long document summary within your context limit, or a step-by-step troubleshooting conversation. These are the kinds of jobs the vendor says it’s strongest at.

Other no-code ways to run it

Ollama (one line in Terminal). If you already use Ollama, Hugging Face’s docs say you can run any GGUF repo on the Hub directly, without extra setup. Open Terminal (Mac) or PowerShell (Windows) and paste:

ollama run hf.co/bartowski/Nanbeige_Nanbeige4.3-33B-GGUF:Q4_K_M

Swap Q4_K_M for another quant name from the table. Per the Hugging Face docs, Ollama picks Q4_K_M by default when you leave the tag off, and reads the chat format from the file. Apps that sit on top of Ollama (like Open WebUI) will then list the model.

Jan, koboldcpp, Atomic Chat and others. The bartowski repo says these files also work in Jan, koboldcpp, ramalama, Text Generation Web UI, LoLLMs and Atomic Chat. In most of them you search for or paste the same repo name.

Tell your AI agent to set it up. If you use Claude Code, Codex or Cursor’s agent, you can hand it the job in plain words, for example: “Install llama.cpp and start a local server for bartowski/Nanbeige_Nanbeige4.3-33B-GGUF at Q4_K_M, then tell me the address of its chat page.” The repo’s own instructions use llama.cpp’s llama-server, which includes a built-in chat web page at http://localhost:8080 by default, and they note the files need llama.cpp release b11845 or newer.

Using it as the brain of a coding agent. You can point agent tools that accept a local, OpenAI-compatible server at LM Studio or llama-server. Keep expectations realistic: the official benchmarks for agent work were run on the full model with long contexts and large output budgets, which a laptop running a 4-bit file with a 16K context won’t match.

What it costs

The model itself is free under Apache-2.0, and running it locally costs nothing beyond electricity. As of October 26, 2026 we found no listing for it on OpenRouter, so there’s no simple pay-per-use cloud option yet. If your computer can’t run it, the realistic alternatives are a smaller local model or a hosted model you already pay for.

Troubleshooting

“Failed to load model” or an unknown-architecture error. Update LM Studio (or Ollama, or llama.cpp) to the latest version. The bartowski files were made with llama.cpp release b11845, and older engines may not read them.

It loads, then crashes or freezes the computer. You’ve run out of memory. Lower the context length first (try 8,192), then try a smaller file (Q4_K_M → IQ4_XS → Q3_K_M). Close browsers and other heavy apps.

It’s extremely slow (a word every few seconds). Part of the model is running on your CPU. On a PC, raise GPU offload or pick a smaller file that fits fully in your graphics card. On a Mac, check that nothing else is using a lot of memory. Remember that a dense 33B model is simply slower than smaller or mixture-of-experts models.

Answers stop halfway through. Check the response-length (max tokens) limit in the chat settings. Thinking uses a lot of tokens before the visible answer starts.

It rambles or continues your text instead of answering. You probably downloaded the Base model. Delete it and download the regular Nanbeige4.3-33B GGUF.

You see raw <think> or <tool_call> tags in replies. Your app isn’t recognizing this model’s output format. Update the app. The prompt format published in the bartowski repo shows that tool calls use an XML style (<tool_call><function=...>), which some apps may not parse yet. Plain chat still works fine in that case.

Quality seems worse than the benchmarks. That’s expected with small quants. Step up a size if you have the memory (Q4_K_M → Q5_K_M → Q6_K), and use temperature 0.6 for chat.

FAQ

Is Nanbeige4.3-33B free for commercial use? The official model card lists the Apache-2.0 license, which permits commercial use. Read the license yourself if it matters for your business.

Can it see images? No. The GGUF repo lists text as the only input.

Is the GGUF official? No. As of October 26, 2026, the Nanbeige organization on Hugging Face has published the full-precision model and the Base model, and the GGUF files come from bartowski, a well-known community quantizer. That’s normal for new models, but it’s why we name the exact repo.

Will there be a smaller version? The model card says a Nanbeige4.3-3B is planned. It isn’t out yet.

What’s the minimum hardware? Realistically a 32 GB Apple Silicon Mac or a PC with a 24 GB graphics card for the recommended Q4_K_M file. Smaller files exist down to about 10 GB, but quality drops a lot.

The takeaway

Nanbeige4.3-33B is a free, Apache-2.0 model that you can run privately in LM Studio in about ten minutes if you have roughly 32 GB of memory. Download Q4_K_M from the bartowski repo, keep the context around 8K to 16K, use temperature 0.6 for chat and 1.0 for agent work, and judge it on multi-step tasks, where its claimed lead is biggest. For more local-model guides, see our Muse-Glimmer-30B walkthrough, our Qwen 3.6 local coding guide, or browse the latest tutorials on the 7minai homepage.