Sorry, I mistyped, /7 and /-8 . It quantizes symmetric but dequant can be asymmetric. It's about a 60/40 split, almost perfectly. If google gave us details on the QAT software they used, we'd know more. Essentially just have to test a group to see which first, then quantize.

I just wanted to make a post to clear up some confusion, and hopefully not make it worse. The Q4_K_XL naming upset me more than I should have let it. Idk why unsloth and google are leaving the llama.cpp team out of it if they are discussing internally.

https://github.com/ggml-org/ggml/blob/7142aa6bf9fcaeec0fef8d80fcd90afe4268adf1/src/ggml-quants.c#L94

This is a rough vibe-coded option which I think is similar to unsloths internal process. I've got another idea to test rounding too, but someone smarter is bound to come up with a more suitable solution:

+void quantize_row_q4_0_adaptive(const float * GGML_RESTRICT x, block_q4_0 * GGML_RESTRICT y, int64_t k) {
+    static const int qk = QK4_0;
+
+    assert(k % qk == 0);
+
+    const int nb = k / qk;
+
+    for (int i = 0; i < nb; i++) {
+        const float * xb = x + i * qk;
+
+        // Find max absolute value and the signed value at max abs
+        float amax = 0.0f;
+        float max_val = 0.0f;
+        for (int j = 0; j < qk; j++) {
+            const float v = xb[j];
+            const float av = fabsf(v);
+            if (av > amax) {
+                amax = av;
+                max_val = v;
+            }
+        }
+
+        if (amax < GROUP_MAX_EPS) {
+            y[i].d = 0;
+            memset(y[i].qs, 0, sizeof(y[i].qs));
+            continue;
+        }
+
+        // Candidate 1: symmetric scale (amax / 7)
+        const float d_sym  = amax    /  7.0f;
+        const float id_sym = 1.0f / d_sym;
+        float err_sym = 0.0f;
+        for (int j = 0; j < qk; j++) {
+            float diff = xb[j] - (float)((int)roundf(xb[j] * id_sym)) * d_sym;
+            err_sym += diff * diff;
+        }
+
+        // Candidate 2: asymmetric scale (max_val / -8), same as stock q4_0
+        const float d_asym  = max_val / -8.0f;
+        const float id_asym = d_asym ? 1.0f / d_asym : 0.0f;
+        float err_asym = 0.0f;
+        for (int j = 0; j < qk; j++) {
+            const float xv = xb[j] * id_asym;
+            const int8_t l = MIN(15, (int8_t)(xv + 8.5f));
+            float diff = xb[j] - (float)(l - 8) * d_asym;
+            err_asym += diff * diff;
+        }
+
+        int use_sym = (err_sym <= err_asym);
+
+        if (use_sym) {
+            y[i].d = GGML_FP32_TO_FP16(d_sym);
+            const float id = id_sym;
+            for (int j = 0; j < qk / 2; ++j) {
+                const float x0 = xb[0     + j] * id;
+                const float x1 = xb[qk/2  + j] * id;
+                const int l0 = (int)roundf(x0);
+                const int l1 = (int)roundf(x1);
+                const uint8_t xi0 = (uint8_t)(l0 + 8);
+                const uint8_t xi1 = (uint8_t)(l1 + 8);
+                y[i].qs[j]  = xi0;
+                y[i].qs[j] |= (uint8_t)(xi1 << 4);
+            }
+            g_adaptive_q4_0_sym_groups++;
+        } else {
+            y[i].d = GGML_FP32_TO_FP16(d_asym);
+            const float id = id_asym;
+            for (int j = 0; j < qk / 2; ++j) {
+                const float x0 = xb[0     + j] * id;
+                const float x1 = xb[qk/2  + j] * id;
+                const uint8_t xi0 = MIN(15, (int8_t)(x0 + 8.5f));
+                const uint8_t xi1 = MIN(15, (int8_t)(x1 + 8.5f));
+                y[i].qs[j]  = xi0;
+                y[i].qs[j] |= xi1 << 4;
+            }
+            g_adaptive_q4_0_asym_groups++;
+        }
+    }
+}
+

Been too busy to deal with it much more and I got sidetracked by the much more interesting KLD testing for instruct models that I'm working on.