An experiment as succulent as it is instructive comes from the forums: a Redditor put the Qwen 3.6 and Gemma 4 Large Language Models to the test with a rather original task — generating a single HTML file that draws a realistic döner kebab skewer rotating in front of a gas-powered heating element on a canvas. But instead of stopping at the first attempt, they ran the test at different quantization levels, from Q8 to IQ2, collecting nine iterations for each configuration and picking the best result (using a purely subjective criterion they called “yumminess”).

The outcome? A practical lesson on the hidden costs of model compression. With aggressive quantization, the LLMs progressively lose finesse: the fire becomes simpler, the rotation disappears, and elements end up in the wrong places. Gemma 4 seemed to weather lower precision better, with “surprisingly stable” results, while the low-quant Qwen models produced more unstable and less coherent code. The team behind the post noted that Gemma 4 appeared “more lobotomized” as precision decreased, but the other models suffered an even more pronounced loss of “finesse.”

Quantization is no free lunch

Behind the apparent quirkiness of the test lies a strategic issue for anyone evaluating on-premise LLM deployment. Quantization is the main path to running models with tens of billions of parameters on consumer hardware or enterprise servers without investing in GPUs costing tens of thousands of euros. Reduced formats (8-bit, 4-bit, down to 2-bit with techniques like IQ2) can cut VRAM usage by half or more. Yet, as the döner test shows, on complex, creative code-generation tasks those missing bits take their toll: logical structure falls apart, visual details vanish, and coherence is lost.

This doesn’t mean quantization is harmful in absolute terms. For many typical workloads — text analysis, summarization, question answering — quantized models remain surprisingly effective, as the literature now well documents. But when the output demands structured data, working code, or interactive interfaces, degradation can come on quickly. For companies embracing self-hosting for privacy, data sovereignty, or simply TCO, this variable becomes critical: they must find the right balance between hardware cost and output quality, without stumbling into performance drops that negate the investment.

An interesting detail is that the Redditor had to discard several attempts because the models got stuck in loops or threw errors like “invalid assignment to const.” This underlines how performance evaluation can’t rely on a single prompt but requires multiple iterations, especially with quantized models. It’s a warning for those building inference pipelines and automated metrics: the “best result” often only emerges after robust human cherry-picking.

Ultimately, the Döner Bench isn’t just a fun stylistic exercise — it’s a pragmatic reminder that democratizing LLMs through quantization comes at a price. And that price is paid in kebab slices that no longer spin.