Gemma 4 12B Coder Fable5: What's in the Viral Finetune

If you've seen "gemma 4 12b coder fable5" spiking in Google Trends and wondered what it actually is: it's a community fine-tune of Google's Gemma 4 12B, specialized for Python coding, released on Hugging Face and Ollama by an independent hobbyist developer. It is not an official Google release.

The full name is gemma-4-12B-coder-fable5-composer2.5-v1, and the "fable5" and "composer2.5" pieces in the name aren't marketing flourishes — they're the two teacher models used to generate its training data. Here's what's verified, what the model actually is, and how to run it if you want to try it.

Who Made It, and Where to Find It

This model comes from a Hugging Face user going by yuxinlu1, described on the model card as a "personal/hobby project," shared as-is with no warranty. It is not produced, reviewed, or endorsed by Google.

Three places to find it:

• Hugging Face (full weights): yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1 — the bf16 safetensors master, meant for further fine-tuning or building your own quantizations
• Hugging Face (GGUF): yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1-GGUF — pre-quantized files for llama.cpp, LM Studio, Jan
• Ollama: xentriom/gemma-4-12B-coder-fable5-composer2.5-v1 — a third-party port of the GGUF files (1,500+ downloads as of this writing), published by a different user, xentriom, than the original creator

It's licensed Apache 2.0, inheriting Gemma 4's own Apache 2.0 terms, and it's fine-tuned from Google's official google/gemma-4-12B-it base model — so the underlying architecture and license are Google's, but the fine-tuning, the data pipeline, and the distribution are entirely community work.

What "Fable 5" and "Composer 2.5" Actually Mean

According to the model card, the training data is a distillation of chain-of-thought reasoning from two teacher models, over verifiable Python coding problems (algorithmic, function-level tasks with deterministic tests):

• Composer 2.5 (main teacher): generated the primary reasoning traces. Each candidate solution was actually executed against the problem's test suite, and only traces whose code passed were kept.
• Fable 5 (secondary teacher): handled the subset of problems Composer 2.5 got wrong. Those were handed to Fable 5 to re-derive a fresh chain of thought and a correct solution — again gated on passing the tests, and tagged separately as synthetic ("second-attempt") data.

That confirms the premise: Fable 5 and Composer 2.5 are teacher models used purely for the distillation pipeline, not architectural components of the finetune itself. What the model card does not do is state which organizations built Composer 2.5 or Fable 5 — the author names them and describes their role in the pipeline, but doesn't document their provenance beyond that. Treat the two names as labels for "teacher model A" and "teacher model B" in this author's process rather than as models you can independently verify claims about.

What's Actually Different vs. Stock Gemma 4 12B

The base model is Google's Gemma 4 12B, a dense, encoder-free multimodal model with a 256K context window. The fine-tune changes the model's behavior, not its architecture:

• Narrower, deeper skill: every training example is a Python/algorithmic problem with a test-verified solution. The model reasons through edge cases and complexity out loud (in Gemma's native "thinking" channel) before writing code, and that habit is now baked in by training rather than prompted.
• Reduced refusals: because the training set is entirely task-focused coding data with no safety hedging, the model refuses less often than the base instruction-tuned model. The author is explicit that this comes at the cost of safety alignment — more on that below.
• A context-length fix: Gemma 4's family shipped with a well-known upstream metadata bug where config.json reported 131K tokens instead of the real 262K. This fine-tune's master weights already carry the corrected max_position_embeddings: 262144, so anything quantized from it — including the GGUF builds — gets the full 256K context Gemma 4 was designed for.
• No published benchmark numbers for v1. The model card doesn't claim a HumanEval or LiveCodeBench score for this specific release. (The author's newer v2, an agentic-focused follow-up, does publish one comparison — a tau2-bench "telecom" tool-use score, ~55% vs. the base model's ~15% — but that's a different checkpoint, not this one, and it's the author's own reported number, not an independent benchmark.)

In short: same base model and context window as stock Gemma 4 12B, retrained to be a sharper, more talkative Python problem-solver, with fewer guardrails.

How to Run It

Ollama (easiest)

ollama run xentriom/gemma-4-12B-coder-fable5-composer2.5-v1

This pulls the default tag (~7.4 GB, roughly Q4_K_M-equivalent quantization). If you've already got Ollama running Gemma 4, the workflow is identical — just point at this model name instead of gemma4.

Recommended sampling settings, per the model card: temperature 1.0, top_p 0.95, top_k 64 for general use, or temperature 0 (greedy) for more deterministic code output.

GGUF in LM Studio

If you'd rather use a GUI, grab the GGUF files directly:

1. Open LM Studio and search Hugging Face for yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1-GGUF, or use the "Use this model" → LM Studio button on the Hugging Face page
2. Pick a quantization (see table below) — Q4_K_M is the one the author calls "the sweet spot"
3. Load it and make sure "thinking mode" stays enabled in the chat template, since that's how the model was trained to reason

One catch: this uses Gemma 4's gemma4_unified architecture, so you need a recent build of llama.cpp (or an app bundling one). Older builds won't load the GGUF files at all.

Hardware: Same Ballpark as Stock Gemma 4 12B

Because this is a fine-tune, not a bigger model, the memory math doesn't change from Gemma 4 12B's own requirements: around 7–8 GB of VRAM or unified memory at Q4 is enough in practice, once you account for the KV cache. That means the same machines that run stock Gemma 4 12B comfortably — a 16 GB MacBook Air, a 16 GB MacBook Pro, or a 12 GB RTX 3060 — run this fine-tune too. If you're on a MacBook Pro, you have plenty of headroom; on a 16 GB machine, stick to Q4_K_M or smaller.

One extra option: the author notes that Gemma 4's stock MTP (multi-token prediction) draft model — the small speculative-decoding helper Google ships with the base 12B — also works with this fine-tune for free speed-ups, since it's lossless (byte-for-byte identical output, just faster generation). The acceptance rate is a bit lower than on vanilla Gemma 4 since the drafter was trained on the base model, but there's no real downside to trying it in llama.cpp with the --model-draft flag.

Honest Caveats

This is a hobbyist fine-tune, not a Google product, and it's worth being clear-eyed about what that means:

• No official support. There's no Google backing, no SLA, no guarantee the repos stay maintained. The author describes it as shared "as-is, no warranty."
• Reduced safety alignment. The author states directly that the model refuses less than the base instruction-tuned model because the training data has no safety hedging built in. Don't deploy it in front of untrusted users without your own guardrails.
• Narrow specialization. It's tuned specifically for Python and algorithmic coding. General knowledge, facts, and non-Python tasks should be verified against a general-purpose model — the fine-tuning process can degrade broad capabilities even as it sharpens the target skill.
• Verify outputs like any code-generation model. "Trained on tests that passed" describes the training data, not a guarantee about code you generate with it. Run and test anything it writes before trusting it.
• It's already superseded. As of this writing, the same author has a v2 release focused on agentic coding — this article covers v1, the version behind the trending searches, but if you're evaluating this model fresh, it's worth checking whether v2 fits your use case better.

FAQ

Is Gemma 4 12B Coder Fable5 an official Google model? No. It's a community fine-tune built on top of Google's official google/gemma-4-12B-it, created and distributed independently by a Hugging Face user (yuxinlu1) and ported to Ollama by a separate user (xentriom). Google did not produce or review it.

What are "Fable 5" and "Composer 2.5"? They're the two teacher models the author used to generate the training data via distillation — Composer 2.5 produced the main reasoning traces, and Fable 5 was used to redo the cases Composer 2.5 got wrong. The model card names them but doesn't document which organizations built them.

What is this model good at? Python and algorithmic coding problems — the kind with deterministic, testable solutions. It reasons through the problem in Gemma's thinking channel before writing code. It's not a general-purpose upgrade over stock Gemma 4 12B for non-coding tasks.

Does it need more hardware than stock Gemma 4 12B? No. Same base model, same size class — expect roughly 7–8 GB of VRAM or unified memory at Q4 quantization, matching Gemma 4 12B's official hardware requirements.

Is it safe to use in production? Not without your own safety layer. The author explicitly says the model has reduced refusals and no safety alignment work beyond the base model — treat it as an unsupervised coding assistant, not a public-facing chatbot.

How do I run it? Easiest path is Ollama: ollama run xentriom/gemma-4-12B-coder-fable5-composer2.5-v1. For a GUI, grab the GGUF from yuxinlu1/gemma-4-12B-coder-fable5-composer2.5-v1-GGUF and load it in LM Studio.