A 27-billion-parameter language model with a full 128k-token context window now runs entirely inside a 16GB graphics card that draws 70 watts. ByteShape's ShapeLearn quantization of Qwen3.8-27B, in its IQ3_XS variant at roughly 3.01 bits per weight, achieved that on a modest home server and then went through a battery of throughput, memory, reasoning, coding and agent tests. The short version: recall across long contexts was perfect, reasoning and Python results were solid, three browser-based apps and a Blender asset came out working, and a 3D Godot level was the one task that collapsed. Along the way, one operational quirk showed up repeatedly: the model tends to overrun its output token limit when it writes large code blocks unless the prompt tells it not to.

What ShapeLearn does differently

Quantization shrinks a model by storing its weights with fewer bits. Pushing that down to 2, 3 or 4 bits usually costs intelligence. ShapeLearn's approach is to learn the ideal data type for each tensor individually rather than applying one scheme across the whole model, which ByteShape says preserves quality even at very low bit widths. The model card notes that labels like IQ4_XS or IQ3_XS appear only so the files slot into Hugging Face's compatibility tables; the actual format is a custom hybrid, per-tensor mix.

The repository for byteshape/Qwen3.8-27B-GGUF showed 2,056,119 downloads in the preceding month, so a large part of the local-AI community has already picked it up.

The IQ3_XS build was chosen because it leaves room for a 128k context when paired with a Q8 KV cache. The KV cache is the memory a model keeps for every token it has already read; storing it at 8-bit precision shrinks that footprint, which is what lets the long context fit on a 16GB card.

The test machine

Component Spec
OS Ubuntu Server 24.04.4
Motherboard ASUS TUF Gaming X570-PLUS
CPU AMD Ryzen 5700X
RAM 32GB DDR4 3600MHz
Storage ADATA Pro 960 2TB Gen4 SSD
Inference GPU NVIDIA RTX 2000 Ada, 16GB, 70W
Inference server llama.cpp (llama-cpp-server)

An RTX 5090 with 32GB was also installed, but only to speed up batch benchmark runs. Every result below that concerns the model itself comes from the 16GB card. One limit of that card surfaced during setup: raising the prefill batch size failed for lack of memory headroom.

Throughput at 128k context

Prefill is the phase where the model reads the prompt; decode is the phase where it writes the answer. Cached prefill reuses KV-cache entries from an earlier turn, which is why it scales so dramatically.

Metric Result
Cold prefill, 512-token prompt 323.8 tokens/s
Cold prefill, peak at 8k prompt 446.5 tokens/s
Uncached prefill at 32k 391.6 tokens/s
Cached KV prefill, 512 tokens 2,205.9 tokens/s
Cached KV prefill, 32k tokens 87,677.4 tokens/s
Decode generation 31.0 to 31.7 tokens/s

Decode speed held steady across generation lengths at about 31 tokens per second, which for a dense 27B model on a 70W card seems like a usable interactive pace rather than a batch-only one.

Long-context memory and reasoning

The Needle-in-a-Haystack test hides a six-digit passkey inside a large block of text at depths of 0%, 25%, 50%, 75% and 100% of the context, then asks the model to retrieve it. Across 15 trials reaching up to 256,608 context tokens, the model found the key every time, a 15 out of 15 score. The full run took 55 minutes and 53 seconds. One caveat: when the needle sat in the middle of the context, at the 25% and 50% depths, the responses grew more verbose and included more visible internal reasoning than the ideal one-line answer.

Tall stack of paper with one bright card buried in the middle, a magnifying glass on top and a stopwatch beside it

▲ Needle-in-a-Haystack recall at deep context

The tiered reasoning benchmark consists of 48 questions split evenly across four difficulty levels, with an average latency of 6,324 ms per answer.

Tier Score
Easy 12/12 (100%)
Medium 12/12 (100%)
Hard 10/12 (83.3%)
Expert 6/12 (50.0%)
Overall 40/48 (83.3%)

By topic, Spatial, State Tracking and Temporal reasoning all scored 100%, Logic 94% and Probability 86%. The weak spots were Constraints at 50% and Information Theory at 0%. For a dense 27B model stored at about 3 bits per weight, the Hard and Expert results look solid rather than outstanding.

HumanEval Remix, a set of 100 Python programming challenges, produced a 77% overall pass rate. The model attempted 94 problems and passed 77 of them, an 81.9% rate among answered questions, while leaving 6 untouched. Average latency was 12,461 ms and the run lasted 20 minutes and 46 seconds. The unanswered problems are what pull the headline number down.

Three browser apps built by the agent

Each coding task ran as an agent session, with a Playwright harness driving headless Chrome to verify the result automatically.

SeatPlan, an event seating planner

The hardest of the three on paper: drag-and-drop table rearrangement, guest assignment, seat reordering, and search and filtering across multiple modal views. The final build passed all 9 verification criteria and all 45 test assertions, using 64.1% of the context with one compaction and three user prompts.

Getting there exposed the model's main operational flaw. On the first attempts, it repeatedly ran past the maximum output token limit while trying to write the whole application in one go, leaving the code cut off mid-file. The fix was a change to the system prompt: state the strict token limit explicitly and tell the model not to attempt massive single-step rewrites. After that, two short follow-ups were enough to fix a modal window that could not be closed and a broken drag-and-drop handler.

Falling sand sandbox

The second task asked for a cellular automata sandbox with sand, water, wall, acid and an eraser, plus adjustable brush sizes. The result showed sand piling into mounds, water spreading sideways, and acid eating through walls and sand. All 16 assertions passed across 5 runs with zero compactions, zero prompt revisions and no truncation problems, at 52.5% context use. One defect remained: sand particles occasionally teleport upward through standing water. That particular bug appears to show up in many language models given this prompt, so it reads more as a hard problem than a weakness specific to this quantization.

DUNGEON :: FORGE, a procedural 2D crawler

The third task was a top-down dungeon generator using binary space partitioning, a method that recursively splits the map into rooms, combined with raycast fog of war that reveals terrain only within the player's line of sight. The game tracked player movement, sight radius, room-by-room lighting and the percentage of the map scouted. Early on, sight lines leaked through walls; a follow-up prompt fixed the raycasting logic promptly, after which rooms stayed enclosed and unexplored terrain uncovered smoothly as the player moved. Small triangular shadow artifacts lingered along the outer perimeter walls. The session used 73.4% of context with no compactions and two user prompts, and the same initial truncation issue as SeatPlan appeared before being handled.

Blender and Godot through MCP

The final two tasks connected the model to real applications through Model Context Protocol (MCP), a standard that lets a model call tools inside other software.

Hexagonal caged lantern glowing on a workbench next to a half-finished floating game platform model with a pit

▲ Blender lantern pass and unfinished Godot level

In Blender, the task was to model and render a "Starfall lantern." The model produced a chunky hexagonal lantern with vertical cage bars and a mounting hook on top, a glowing yellow emissive core and a metallic gold frame. The viewport panned without any lag, which appears to come down to the low-polygon geometry the model generated. Four 1920x1080 renders came out at 2.0 to 2.1 MB each. Two shortcomings: the requested hanging ornaments around the lower rim were missing, and the glass casing showed an odd bloom or reflection halo. The session used just 21.2% of context with one compaction, though it initially sent renders only to the MCP buffer and did not save them to disk until asked where the screenshots were. For an optimized real-time game asset from a 3-bit model, the result seems acceptable.

Godot was the failure. The brief was a complete 3D platforming level with moving platforms, collectible keys, a pit hazard and an end-of-level trigger. The level itself rendered attractively, with pastel surfaces and floating platforms over a drop. Playing it told another story: vertical mouse look was inverted, the floating sphere keys could not be picked up, the central moving platform was out of reach, and falling into the pit sent the camera tumbling through the void with no respawn. The terminal showed why. The model had fallen into repetitive thought loops filled with strings like "hmm" and "wait", burning tokens without progress. Even a direct instruction to stop testing and fix only the mouse inversion and key collisions sent it back into the same loop. After seven compactions and 88.5% context use, the session was aborted. A fresh context, rather than a thread already degraded by that many compactions, might have given the task a better chance.

Agent scorecard

Task Result User prompts Compactions Context used
Seating Planner Pass 3 1 64.1%
Sand Physics Pass 0 0 52.5%
Dungeon Crawler Pass 2 0 73.4%
Blender Lantern Pass 1 1 21.2%
Godot Moving Platforms Fail 4 7 88.5%

How it stacks up against a base-model quant

The same task set had previously been run against the base Qwen model quantized by Unsloth at Q3_K_XL, a larger file. The ByteShape IQ3_XS build cleared the demanding Seating Planner while the base quant had struggled on a simpler Kanban board. In Godot, the base model failed outright, whereas the ByteShape build got close to a working level before looping. The one area where the base model came out ahead was Blender aesthetics, where its lantern had more visual detail and polish. On balance, the smaller ByteShape build appears to outperform the larger base quantization on most technical work, with 3D asset looks as the exception.

What to take away

For anyone with a 16GB card who wants a 27B-class model with a genuinely long context, this build does the job: perfect recall to 256k tokens, 83% on tiered reasoning, 77% on HumanEval Remix, and four of five agent tasks passed. If the main use is generating pretty 3D assets in Blender, the base Q3_K_XL quant may be the better pick; for code generation and multi-step agent work, the ByteShape build looks like the stronger choice.

A few practices matter when running it:

  • Put the output token limit in the system prompt and tell the model not to rewrite everything in a single turn; this removed the truncation problem in testing.
  • Do not set the maximum output excessively high, which invites context compaction.
  • Break big refactors into modular steps rather than multi-file rewrites.
  • Pair the 3-bit weights with a Q8 KV cache in llama.cpp to keep the 128k context inside 16GB.
  • When using MCP for automated tests, instruct the model to set strict execution timeouts so it does not hang on unresponsive processes.
  • For Blender renders via MCP, say up front that camera views must be saved as PNG files on disk.
  • If an agent session starts looping on "hmm" and "wait", reset the context instead of re-prompting inside a heavily compacted thread.