Commit 55d323507 for llama.cpp

commit 55d323507de290f5baacf56082b087a6bccfc7d9
Author: nicholas-mainardi-domyn <nicholas.mainardi@domyn.com>
Date:   Fri Nov 20 08:51:41 2026 +0100

    model: add Domyn Edge 4B Model (#32559)

    * feat: add domyn-edge model

    * Generate tokenizer hash for conversion + fix tests

    * Address changes according to code-review skill

    * catch ValueError in convert_hf_to_gguf_update.py

    * renegerate fusion test baseline + fix model naming style

diff --git a/conversion/__init__.py b/conversion/__init__.py
index 1182c06be..253a18fd4 100644
--- a/conversion/__init__.py
+++ b/conversion/__init__.py
@@ -78,6 +78,7 @@ TEXT_MODEL_MAP: dict[str, str] = {
     "DistilBertForMaskedLM": "bert",
     "DistilBertForSequenceClassification": "bert",
     "DistilBertModel": "bert",
+    "DomynEdgeForCausalLM": "domynedge",
     "Dots1ForCausalLM": "dots1",
     "Dots3NoteForCausalLM": "dots3",
     "Dots3NoteForConditionalGeneration": "dots3",
diff --git a/conversion/base.py b/conversion/base.py
index 7cfbff321..540a66ba5 100644
--- a/conversion/base.py
+++ b/conversion/base.py
@@ -2470,6 +2470,9 @@ class TextModel(ModelBase):
         if chkhsh == "5635e1c8d621dff7b4825f41f2f97b6ceb39bcf2d5c541db28577080d6efd5e5":
             # ref: https://huggingface.co/thinkingmachines/Inkling-2-Small
             res = "inkling2"
+        if chkhsh == "32d85c31273f8019248f2559fed492d929ea28b17e51d81d3bb36fff23ca72b3":
+            # ref: https://huggingface.co/domyn/Domyn-Edge-Teacher-IF
+            res = "domyn-edge"

         if res is None:
             logger.warning("\n")
diff --git a/conversion/domynedge.py b/conversion/domynedge.py
new file mode 100644
index 000000000..df07add83
--- /dev/null
+++ b/conversion/domynedge.py
@@ -0,0 +1,53 @@
+from .base import TextModel, ModelBase
+import gguf
+
+
+@ModelBase.register("DomynEdgeForCausalLM")
+@ModelBase.example("domyn/Domyn-Edge-Teacher-IF")
+class DomynEdgeModel(TextModel):
+    model_arch = gguf.MODEL_ARCH.DOMYN_EDGE
+
+    def set_gguf_parameters(self):
+        super().set_gguf_parameters()
+        hparams = self.hparams
+        self.gguf_writer.add_vocab_size(hparams["vocab_size"])
+
+        position_layers = hparams["position_layers"]  # list of "rope"/"nope" strings per layer
+        head_sizes      = hparams["head_sizes"]        # list of int head dims per layer
+
+        # Per-layer rope/SWA pattern: True="rope", False="nope"
+        rope_pattern = [v == "rope" for v in position_layers]
+        self.gguf_writer.add_rope_pattern(rope_pattern)
+        self.gguf_writer.add_sliding_window_pattern(rope_pattern)  # SWA <-> RoPE in domyn-edge
+
+        # window_sizes entries are flash-attn style [left, right] (current token excluded; -1 = full attention),
+        # while llama.cpp's n_swa counts the current token, hence the +1 (matches HF's sliding_window=1025)
+        swa_window = hparams.get("sliding_window")
+        if swa_window is None:
+            window_sizes = hparams.get("window_sizes")      # list of [size, offset] pairs per layer
+            if window_sizes is None:
+                raise KeyError("Neither `sliding_window` nor `window_sizes` found among domyn edge hyperparameters")
+            left = next((ws[0] for v, ws in zip(position_layers, window_sizes) if v == "rope"), None)
+            swa_window = left + 1 if left is not None and left > 0 else None
+        if swa_window is None:
+            raise ValueError("No sliding window size found among domyn edge hyperparameters")
+        self.gguf_writer.add_sliding_window(swa_window)
+
+        # Head dims differ between full-attention ("nope") and SWA ("rope") layers
+        full_head_dims = {h for v, h in zip(position_layers, head_sizes) if v == "nope"}
+        swa_head_dims  = {h for v, h in zip(position_layers, head_sizes) if v == "rope"}
+
+        if len(full_head_dims) != 1:
+            raise ValueError(f"Expected one head dimension for full attention layers, found {len(full_head_dims)}")
+        full_head_dim = full_head_dims.pop()
+
+        self.gguf_writer.add_key_length(full_head_dim)
+        self.gguf_writer.add_value_length(full_head_dim)
+
+        if len(swa_head_dims) != 1:
+            raise ValueError(f"Expected one head dimension for SWA attention layers, found {len(swa_head_dims)}")
+        swa_head_dim = swa_head_dims.pop()
+
+        self.gguf_writer.add_key_length_swa(swa_head_dim)
+        self.gguf_writer.add_value_length_swa(swa_head_dim)
+        self.gguf_writer.add_rope_dimension_count_swa(swa_head_dim)
diff --git a/convert_hf_to_gguf_update.py b/convert_hf_to_gguf_update.py
index ff5fca4ff..91fb418a5 100755
--- a/convert_hf_to_gguf_update.py
+++ b/convert_hf_to_gguf_update.py
@@ -168,6 +168,7 @@ models = [
     {"name": "mmbert",           "tokt": TOKENIZER_TYPE.BPE, "repo": "https://huggingface.co/jhu-clsp/mmBERT-base", },
     {"name": "k2-horizon",       "tokt": TOKENIZER_TYPE.BPE, "repo": "https://huggingface.co/IFM/K2-Horizon-36B", },
     {"name": "inkling2",         "tokt": TOKENIZER_TYPE.BPE, "repo": "https://huggingface.co/thinkingmachines/Inkling-2-Small", },
+    {"name": "domyn-edge",       "tokt": TOKENIZER_TYPE.BPE, "repo": "https://huggingface.co/domyn/Domyn-Edge-Teacher-IF", },
 ]

 # some models are known to be broken upstream, so we will skip them as exceptions
@@ -227,8 +228,6 @@ def download_model(model):
     repo = model["repo"]
     tokt = model["tokt"]

-    os.makedirs(f"models/tokenizers/{name}", exist_ok=True)
-
     files = ["config.json", "tokenizer.json", "tokenizer_config.json"]

     if name == "gpt-4o":
@@ -243,6 +242,7 @@ def download_model(model):

     if os.path.isdir(repo):
         # If repo is a path on the file system, copy the directory
+        os.makedirs(f"models/tokenizers/{name}", exist_ok=True)
         for file in files:
             src_path = os.path.join(repo, file)
             dst_path = f"models/tokenizers/{name}/{file}"
@@ -484,7 +484,7 @@ for model in models:
             tokenizer = AutoTokenizer.from_pretrained(f"models/tokenizers/{name}", use_fast=False)
         else:
             tokenizer = AutoTokenizer.from_pretrained(f"models/tokenizers/{name}")
-    except (OSError, TypeError) as e:
+    except (OSError, TypeError, ValueError) as e:
         logger.error(f"Failed to load tokenizer for model {name}. Error: {e}")
         continue  # Skip this model and continue with the next one in the loop

diff --git a/gguf-py/gguf/constants.py b/gguf-py/gguf/constants.py
index e07ea2f4b..f36566a81 100644
--- a/gguf-py/gguf/constants.py
+++ b/gguf-py/gguf/constants.py
@@ -778,6 +778,7 @@ class MODEL_ARCH(IntEnum):
     KOLIBRI1         = auto()
     LIMITE           = auto()
     INKLING2         = auto()
+    DOMYN_EDGE       = auto()


 class VISION_PROJECTOR_TYPE(IntEnum):
@@ -1778,6 +1779,7 @@ MODEL_ARCH_NAMES: dict[MODEL_ARCH, str] = {
     MODEL_ARCH.KOLIBRI1:         "kolibri1",
     MODEL_ARCH.LIMITE:           "limite",
     MODEL_ARCH.INKLING2:         "inkling2",
+    MODEL_ARCH.DOMYN_EDGE:       "domynedge",
 }

 VISION_PROJECTOR_TYPE_NAMES: dict[VISION_PROJECTOR_TYPE, str] = {
@@ -7085,6 +7087,22 @@ MODEL_TENSORS: dict[MODEL_ARCH, list[MODEL_TENSOR]] = {
         MODEL_TENSOR.FFN_POST_CONV,
         MODEL_TENSOR.FFN_RES_QUERY,
     ],
+    MODEL_ARCH.DOMYN_EDGE: [
+        MODEL_TENSOR.TOKEN_EMBD,
+        MODEL_TENSOR.ATTN_Q,
+        MODEL_TENSOR.ATTN_K,
+        MODEL_TENSOR.ATTN_V,
+        MODEL_TENSOR.ATTN_OUT,
+        MODEL_TENSOR.ATTN_K_NORM,
+        MODEL_TENSOR.ATTN_NORM,
+        MODEL_TENSOR.ATTN_POST_NORM,
+        MODEL_TENSOR.FFN_PRE_NORM,
+        MODEL_TENSOR.FFN_POST_NORM,
+        MODEL_TENSOR.FFN_DOWN,
+        MODEL_TENSOR.FFN_UP,
+        MODEL_TENSOR.FFN_GATE,
+        MODEL_TENSOR.OUTPUT_NORM,
+    ],
 }

 # tensors that will not be serialized
diff --git a/gguf-py/gguf/tensor_mapping.py b/gguf-py/gguf/tensor_mapping.py
index c844a9322..d48d46b9a 100644
--- a/gguf-py/gguf/tensor_mapping.py
+++ b/gguf-py/gguf/tensor_mapping.py
@@ -272,6 +272,7 @@ class TensorNameMap:
             "model.layers.{bid}.pre_attention_layernorm",           # kormo
             "head.layers.{bid}.norm1",  # laya
             "model.layers.{bid}.attn_norm",                         # inkling2
+            "model.layers.{bid}.pre_attention_norm",                # domynedge
         ),

         # Attention norm 2
@@ -440,6 +441,7 @@ class TensorNameMap:
             "model.layers.{bid}.post_attn_norm",                 # kolibri1
             "model.layers.layers.{bid}.post_mixer_norm.weight",  # plamo2
             "model.layers.{bid}.post_operator_norm",             # lfm3
+            "model.layers.{bid}.post_attention_norm",            # domynedge
         ),

         # Rotary embeddings
@@ -579,6 +581,7 @@ class TensorNameMap:
             "layers.{bid}.pre_feedforward_layernorm",       # embeddinggemma
             "model.layers.{bid}.pre_ff_layernorm.weight",
             "model.layers.{bid}.pre_mlp_layernorm",        # afmoe
+            "model.layers.{bid}.pre_feedforward_norm",     # domynedge
         ),

         MODEL_TENSOR.FFN_PRE_NORM_2: (
@@ -603,6 +606,7 @@ class TensorNameMap:
             "model.layers.{bid}.feed_forward.up_proj",
             "model.layers.{bid}.post_moe_norm",               # grok-2
             "model.layers.{bid}.post_ffn_norm",               # lfm3
+            "model.layers.{bid}.post_feedforward_norm",       # domynedge
         ),

         MODEL_TENSOR.FFN_POST_NORM_1: (
@@ -692,6 +696,7 @@ class TensorNameMap:
             "encoder.layers.{bid}.mlp.dense_h_to_4h",                 # chatglm
             "transformer.h.{bid}.mlp.c_fc_1",                         # exaone
             "model.layers.{bid}.feed_forward.up_proj",                # llama4 jamba granite-hybrid
+            "model.layers.{bid}.feedforward.up_proj",                 # domynedge
             "transformer_encoder.{bid}.ffn.w12",                      # neobert
             "model.layers.{bid}.block_sparse_moe.up",                 # smallthinker
             "model.transformer.blocks.{bid}.up_proj",                 # llada
@@ -755,6 +760,7 @@ class TensorNameMap:
             "layers.{bid}.mlp.gate_proj",                     # qwen3-embedding
             "model.layers.{bid}.mlp.language_mlp.gate_proj",  # cogvlm
             "model.blocks.{bid}.mlp.mlp_gate",                # talkie
+            "model.layers.{bid}.feedforward.gate_proj",       # domynedge
         ),

         MODEL_TENSOR.FFN_GATE_EXP: (
@@ -923,6 +929,7 @@ class TensorNameMap:
             "encoder.layers.{bid}.mlp.dense_4h_to_h",                 # chatglm
             "model.layers.h.{bid}.mlp.c_proj",                        # exaone
             "model.layers.{bid}.feed_forward.down_proj",              # llama4 jamba granite-hybrid
+            "model.layers.{bid}.feedforward.down_proj",               # domynedge
             "transformer_encoder.{bid}.ffn.w3",                       # neobert
             "model.layers.{bid}.block_sparse_moe.down",               # smallthinker
             "model.transformer.blocks.{bid}.ff_out",                  # llada
@@ -997,6 +1004,7 @@ class TensorNameMap:
             "layers.{bid}.self_attn.k_norm",                                  # qwen3-embedding
             "model.layers.{bid}.self_attn.k_rope_only_layernorm",             # dots3note
             "model.layers.{bid}.attention.key_layernorm",                     # apertus
+            "model.layers.{bid}.attention.k_norm",                            # domynedge
         ),

         MODEL_TENSOR.ROPE_FREQS: (
diff --git a/src/llama-arch.cpp b/src/llama-arch.cpp
index c50e9f98a..1c90b2180 100644
--- a/src/llama-arch.cpp
+++ b/src/llama-arch.cpp
@@ -184,6 +184,7 @@ static const std::map<llm_arch, const char *> LLM_ARCH_NAMES = {
     { LLM_ARCH_KOLIBRI1,         "kolibri1"         },
     { LLM_ARCH_RICURSIVE,        "ricursive"        },
     { LLM_ARCH_INKLING2,         "inkling2"         },
+    { LLM_ARCH_DOMYN_EDGE,       "domynedge"        },
     { LLM_ARCH_UNKNOWN,          "(unknown)"        },
 };

diff --git a/src/llama-arch.h b/src/llama-arch.h
index 9c517a9fe..a8c0fdf09 100644
--- a/src/llama-arch.h
+++ b/src/llama-arch.h
@@ -188,6 +188,7 @@ enum llm_arch {
     LLM_ARCH_LIMITE,
     LLM_ARCH_RICURSIVE,
     LLM_ARCH_INKLING2,
+    LLM_ARCH_DOMYN_EDGE,
     LLM_ARCH_UNKNOWN,
 };

diff --git a/src/llama-model.cpp b/src/llama-model.cpp
index ac5266a42..629b3a7a6 100644
--- a/src/llama-model.cpp
+++ b/src/llama-model.cpp
@@ -394,6 +394,8 @@ static llama_model * llama_model_mapping(llm_arch arch, const llama_model_params
             return new llama_model_k2_horizon(params);
         case LLM_ARCH_KOLIBRI1:
             return new llama_model_kolibri1(params);
+        case LLM_ARCH_DOMYN_EDGE:
+            return new llama_model_domyn_edge(params);
         default:
             throw std::runtime_error(std::string("unsupported model architecture: '") + llm_arch_name(arch) + "'");
     }
@@ -3873,6 +3875,7 @@ llama_rope_type llama_model_rope_type(const llama_model * model) {
         case LLM_ARCH_HRM_TEXT:
         case LLM_ARCH_BEAM:
         case LLM_ARCH_KOLIBRI1:
+        case LLM_ARCH_DOMYN_EDGE:
             return LLAMA_ROPE_TYPE_NEOX;

         case LLM_ARCH_DFLASH:
diff --git a/src/llama-vocab.cpp b/src/llama-vocab.cpp
index 3aecacb51..f3e1d0192 100644
--- a/src/llama-vocab.cpp
+++ b/src/llama-vocab.cpp
@@ -2566,7 +2566,8 @@ void llama_vocab::impl::load(llama_model_loader & ml, const LLM_KV & kv) {
                     tokenizer_pre == "qwen2" ||
                     tokenizer_pre == "deepseek-r1-qwen" ||
                     tokenizer_pre == "kormo" ||
-                    tokenizer_pre == "f2llmv2") {
+                    tokenizer_pre == "f2llmv2" ||
+                    tokenizer_pre == "domyn-edge") {
                 pre_type = LLAMA_VOCAB_PRE_TYPE_QWEN2;
                 clean_spaces = false;
             } else if (
diff --git a/src/models/domyn-edge.cpp b/src/models/domyn-edge.cpp
new file mode 100644
index 000000000..6452894d3
--- /dev/null
+++ b/src/models/domyn-edge.cpp
@@ -0,0 +1,164 @@
+#include "models.h"
+
+void llama_model_domyn_edge::load_arch_hparams(llama_model_loader & ml) {
+    ml.get_key(LLM_KV_ATTENTION_LAYERNORM_RMS_EPS, hparams.f_norm_rms_eps);
+    ml.get_key(LLM_KV_ATTENTION_SLIDING_WINDOW,    hparams.n_swa);
+    // required: the base loader defaults it to n_rot_full if the key is not found
+    ml.get_key(LLM_KV_ROPE_DIMENSION_COUNT_SWA, hparams.n_rot_swa);
+    // RoPE cannot rotate more dims than the SWA head has: CPU aborts, GPU backends read past the row
+    if (hparams.n_rot_swa > hparams.n_embd_head_k_swa) {
+        throw std::runtime_error(format("invalid n_rot_swa: %u, max %u", hparams.n_rot_swa, hparams.n_embd_head_k_swa));
+    }
+
+    hparams.swa_type = LLAMA_SWA_TYPE_STANDARD;
+
+    ml.get_arr(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, hparams.is_swa_impl);
+    ml.get_arr(LLM_KV_ATTENTION_ROPE_PATTERN,           hparams.rope_pattern);
+
+    // only for print_info / saver; get_rope_params uses cparams
+    hparams.rope_freq_base_train_swa  = hparams.rope_freq_base_train;
+    hparams.rope_freq_scale_train_swa = hparams.rope_freq_scale_train;
+
+    switch (hparams.n_layer()) {
+        case 36: type = LLM_TYPE_4B; break;
+        default: type = LLM_TYPE_UNKNOWN;
+    }
+}
+
+void llama_model_domyn_edge::load_arch_tensors(llama_model_loader &) {
+    LLAMA_LOAD_LOCALS;
+
+    tok_embd    = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD,  "weight"), {n_embd, n_vocab}, 0);
+    output_norm = create_tensor(tn(LLM_TENSOR_OUTPUT_NORM, "weight"), {n_embd}, 0);
+    output = create_tensor(tn(LLM_TENSOR_OUTPUT, "weight"), {n_embd, n_vocab}, TENSOR_NOT_REQUIRED);
+
+    // if output is NULL, init from the input tok embed
+    if (output == NULL) {
+        output = create_tensor(tn(LLM_TENSOR_TOKEN_EMBD, "weight"), {n_embd, n_vocab}, TENSOR_DUPLICATED);
+    }
+
+    for (int i = 0; i < n_layer; ++i) {
+        auto & layer = layers[i];
+        const int64_t n_embd_head_i = hparams.n_embd_head_k(i);
+        const int64_t n_embd_k_i    = hparams.n_embd_k_gqa(i);
+        const int64_t n_embd_v_i    = hparams.n_embd_v_gqa(i);
+
+        layer.attn_norm      = create_tensor(tn(LLM_TENSOR_ATTN_NORM,      "weight", i), {n_embd}, 0);
+        layer.attn_post_norm = create_tensor(tn(LLM_TENSOR_ATTN_POST_NORM, "weight", i), {n_embd}, 0);
+
+        const int64_t n_embd_q_i = n_embd_head_i * n_head;
+        create_tensor_qkv(layer, i, n_embd, n_embd_q_i, n_embd_k_i, n_embd_v_i, 0);
+        layer.wo = create_tensor(tn(LLM_TENSOR_ATTN_OUT, "weight", i), {n_embd_head_i * n_head, n_embd}, 0);
+
+        // K-norm has a learnable weight; Q-norm does not
+        layer.attn_k_norm = create_tensor(tn(LLM_TENSOR_ATTN_K_NORM, "weight", i), {n_embd_head_i}, 0);
+
+        layer.ffn_norm      = create_tensor(tn(LLM_TENSOR_FFN_NORM,      "weight", i), {n_embd}, 0);
+        layer.ffn_post_norm = create_tensor(tn(LLM_TENSOR_FFN_POST_NORM, "weight", i), {n_embd}, 0);
+
+        layer.ffn_gate = create_tensor(tn(LLM_TENSOR_FFN_GATE, "weight", i), {n_embd, n_ff}, 0);
+        layer.ffn_up   = create_tensor(tn(LLM_TENSOR_FFN_UP,   "weight", i), {n_embd, n_ff}, 0);
+        layer.ffn_down = create_tensor(tn(LLM_TENSOR_FFN_DOWN, "weight", i), {n_ff, n_embd}, 0);
+    }
+}
+
+llama_rope_params llama_model_domyn_edge::get_rope_params(const llama_cparams & cparams, int il) const {
+    auto res = llama_model::get_rope_params(cparams, il);
+
+    // the SWA layers use the global base and scale
+    res.freq_base  = cparams.rope_freq_base;
+    res.freq_scale = cparams.rope_freq_scale;
+
+    return res;
+}
+
+llama_model_domyn_edge::graph::graph(const llm_graph_params & params)
+    : llm_graph_context(params) {
+    ggml_tensor * cur;
+    ggml_tensor * inpL    = build_inp_embd(model.tok_embd);
+    ggml_tensor * inp_pos = build_inp_pos();
+
+    auto * inp_attn = build_attn_inp_kv_iswa();
+
+    ggml_tensor * inp_out_ids = build_inp_out_ids();
+
+    for (int il = 0; il < n_layer; ++il) {
+        const auto &  layer        = model.layers[il];
+        const int64_t n_embd_head  = hparams.n_embd_head_k(il);
+        const int64_t n_head_il    = hparams.n_head(il);
+        const int64_t n_head_kv_il = hparams.n_head_kv(il);
+        const float   kq_scale     = 1.0f / sqrtf((float)n_embd_head);
+
+        ggml_tensor * residual = inpL;
+
+        // pre-attention norm
+        cur = build_norm(inpL, layer.attn_norm, NULL, LLM_NORM_RMS, il);
+        cb(cur, "attn_norm", il);
+
+        auto [Qcur, Kcur, Vcur] = build_qkv(layer, cur, n_embd_head, n_head_il, n_head_kv_il, il);
+
+        // Q-norm: RMSNorm without learnable weight (elementwise_affine=False)
+        Qcur = build_norm(Qcur, NULL, NULL, LLM_NORM_RMS, il);
+        cb(Qcur, "Qcur_normed", il);
+
+        // K-norm: RMSNorm with learnable weight
+        Kcur = build_norm(Kcur, layer.attn_k_norm, NULL, LLM_NORM_RMS, il);
+        cb(Kcur, "Kcur_normed", il);
+
+        // build_rope already applies RoPE only if the current layer is a RoPE layer
+        Qcur = build_rope(Qcur, inp_pos, il);
+        cb(Qcur, "Qcur_rope", il);
+
+        Kcur = build_rope(Kcur, inp_pos, il);
+        cb(Kcur, "Kcur_rope", il);
+
+        cur = build_attn(inp_attn,
+                layer.wo, NULL, layer.wo_s,
+                Qcur, Kcur, Vcur, nullptr, nullptr, nullptr, kq_scale, il);
+        cb(cur, "attn_out", il);
+
+        // post-attention norm applied to attn output before residual add
+        cur = build_norm(cur, layer.attn_post_norm, NULL, LLM_NORM_RMS, il);
+        cb(cur, "attn_post_norm", il);
+
+        if (il == n_layer - 1 && inp_out_ids) {
+            cur      = ggml_get_rows(ctx0, cur,      inp_out_ids);
+            residual = ggml_get_rows(ctx0, residual, inp_out_ids);
+        }
+
+        ggml_tensor * ffn_inp = ggml_add(ctx0, cur, residual);
+        cb(ffn_inp, "ffn_inp", il);
+
+        // pre-FFN norm
+        cur = build_norm(ffn_inp, layer.ffn_norm, NULL, LLM_NORM_RMS, il);
+        cb(cur, "ffn_norm", il);
+
+        // SwiGLU FFN
+        cur = build_ffn(cur,
+                layer.ffn_up,   NULL, NULL,
+                layer.ffn_gate, NULL, NULL,
+                layer.ffn_down, NULL, NULL, NULL,
+                LLM_FFN_SILU, LLM_FFN_PAR, il);
+        cb(cur, "ffn_out", il);
+
+        // post-FFN norm applied to ffn output before residual add
+        cur = build_norm(cur, layer.ffn_post_norm, NULL, LLM_NORM_RMS, il);
+        cb(cur, "ffn_post_norm", il);
+
+        cur  = ggml_add(ctx0, cur, ffn_inp);
+        inpL = build_cvec(cur, il);
+        cb(inpL, "l_out", il);
+    }
+
+    cur = build_norm(inpL, model.output_norm, NULL, LLM_NORM_RMS, -1);
+    cb(cur, "result_norm", -1);
+    res->t_embd = cur;
+
+    cur = build_lora_mm(model.output, cur, model.output_s);
+    cb(cur, "result_output", -1);
+    res->t_logits = cur;
+}
+
+std::unique_ptr<llm_graph_context> llama_model_domyn_edge::build_arch_graph(const llm_graph_params & params) const {
+    return std::make_unique<graph>(params);
+}
diff --git a/src/models/models.h b/src/models/models.h
index e7849e07d..e0a4db5f7 100644
--- a/src/models/models.h
+++ b/src/models/models.h
@@ -3308,3 +3308,16 @@ struct llama_model_kolibri1 : public llama_model_base {

     std::unique_ptr<llm_graph_context> build_arch_graph(const llm_graph_params & params) const override;
 };
+
+struct llama_model_domyn_edge : public llama_model_base {
+    llama_model_domyn_edge(const struct llama_model_params & params) : llama_model_base(params) {}
+    void load_arch_hparams(llama_model_loader & ml) override;
+    void load_arch_tensors(llama_model_loader & ml) override;
+    llama_rope_params get_rope_params(const llama_cparams & cparams, int il) const override;
+
+    struct graph : public llm_graph_context {
+        graph(const llm_graph_params & params);
+    };
+
+    std::unique_ptr<llm_graph_context> build_arch_graph(const llm_graph_params & params) const override;
+};
diff --git a/tests/fusion/MTL.csv b/tests/fusion/MTL.csv
index 310934e31..295740c7c 100644
--- a/tests/fusion/MTL.csv
+++ b/tests/fusion/MTL.csv
@@ -65,6 +65,8 @@ deepseek4           ,0   ,any     ,UNARY+SQRT+ADD+ARGSORT+GET_ROWS+SUM_ROWS+CLAM
 deepseek41          ,0   ,any     ,MUL+ADD                     ,     12
 deepseek41          ,0   ,any     ,RMS_NORM+MUL                ,     29
 deepseek41          ,0   ,any     ,UNARY+SQRT+ADD+ARGSORT+GET_ROWS+SUM_ROWS+SCALE+DIV,      6
+domynedge           ,0   ,any     ,RMS_NORM+MUL                ,      8
+domynedge           ,0   ,any     ,RMS_NORM+MUL+ADD            ,      3
 dots1               ,0   ,any     ,ADD+ADD                     ,      1
 dots1               ,0   ,any     ,MUL+ADD                     ,      2
 dots1               ,0   ,any     ,RMS_NORM+MUL                ,      9
diff --git a/tests/test-llama-archs.cpp b/tests/test-llama-archs.cpp
index f10404e8c..90a32abc7 100644
--- a/tests/test-llama-archs.cpp
+++ b/tests/test-llama-archs.cpp
@@ -496,16 +496,22 @@ static gguf_context_ptr get_gguf_ctx(const llm_arch arch, const bool moe, const
         ms.add_kv(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, pattern);
     } else if (arch == LLM_ARCH_COHERE2MOE || arch == LLM_ARCH_MIMO2 || arch == LLM_ARCH_STEP35 || arch == LLM_ARCH_SPARK2_5 ||
             arch == LLM_ARCH_MUSE_GLIMMER || arch == LLM_ARCH_MUSE_SPARK || arch == LLM_ARCH_GRANITE_SWA || arch == LLM_ARCH_DOTS3NOTE ||
-            arch == LLM_ARCH_KOLIBRI1 || arch == LLM_ARCH_MAPLE || arch == LLM_ARCH_FLINT || arch == LLM_ARCH_BEAM || arch == LLM_ARCH_RICURSIVE) {
+            arch == LLM_ARCH_KOLIBRI1 || arch == LLM_ARCH_MAPLE || arch == LLM_ARCH_FLINT || arch == LLM_ARCH_BEAM || arch == LLM_ARCH_RICURSIVE || arch == LLM_ARCH_DOMYN_EDGE) {
         std::vector<uint32_t> pattern;
         pattern.reserve(n_layer);
         for (uint32_t il = 0; il < n_layer; il++) {
             pattern.push_back(il % 2);
         }
         ms.add_kv(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, pattern);
-        if (arch == LLM_ARCH_FLINT) {
+        if (arch == LLM_ARCH_FLINT || arch == LLM_ARCH_DOMYN_EDGE) {
             ms.add_kv(LLM_KV_ATTENTION_ROPE_PATTERN, pattern);
         }
+        if (arch == LLM_ARCH_DOMYN_EDGE) {
+            // SWA (rope) layers use a smaller head dim than the full-attention (nope) layers
+            ms.add_kv(LLM_KV_ATTENTION_KEY_LENGTH_SWA,   n_embd_head/2);
+            ms.add_kv(LLM_KV_ATTENTION_VALUE_LENGTH_SWA, n_embd_head/2);
+            ms.add_kv(LLM_KV_ROPE_DIMENSION_COUNT_SWA, n_embd_head/2);
+        }
     } else if (arch == LLM_ARCH_LFM3) {
         ms.add_kv(LLM_KV_ATTENTION_SLIDING_WINDOW_PATTERN, std::vector<uint32_t>({0, 0, 1}));
         ms.add_kv(LLM_KV_ROPE_FREQ_BASE_SWA,               10000.0f);
diff --git a/tests/test-tokenizer-random.py b/tests/test-tokenizer-random.py
index 7f5ea3f45..4b4fbdf75 100644
--- a/tests/test-tokenizer-random.py
+++ b/tests/test-tokenizer-random.py
@@ -80,6 +80,7 @@ class LibLlamaModel:
             raise RuntimeError("error: failed to load model '%s'" % path_model)
         if isinstance(cparams, dict):
             cparams = libllama.context_default_params(**cparams)
+        self.vocab = self.lib.llama_model_get_vocab(self.model)
         self.ctx = self.lib.llama_init_from_model(self.model, cparams)
         if not self.ctx:
             raise RuntimeError("error: failed to create context for model '%s'" % path_model)
@@ -98,10 +99,10 @@ class LibLlamaModel:

     def tokenize(self, text: str, add_special: bool = False, parse_special: bool = False) -> list[int]:
         encoded_text: bytes = text.encode("utf-8")
-        num = self.lib.llama_tokenize(self.model, encoded_text, len(encoded_text), self.token_ids, len(self.token_ids), add_special, parse_special)
+        num = self.lib.llama_tokenize(self.vocab, encoded_text, len(encoded_text), self.token_ids, len(self.token_ids), add_special, parse_special)
         while num < 0 and len(self.token_ids) < (16 << 20):
             self.token_ids = self.ffi.new("llama_token[]", -2 * num)
-            num = self.lib.llama_tokenize(self.model, encoded_text, len(encoded_text), self.token_ids, len(self.token_ids), add_special, parse_special)
+            num = self.lib.llama_tokenize(self.vocab, encoded_text, len(encoded_text), self.token_ids, len(self.token_ids), add_special, parse_special)
         return list(self.token_ids[0:num])

     def detokenize(self, ids: list[int], remove_special: bool = False, unparse_special: bool = False) -> str:
@@ -109,10 +110,10 @@ class LibLlamaModel:
             self.token_ids = self.ffi.new("llama_token[]", 2 * len(ids))
         for i, id in enumerate(ids):
             self.token_ids[i] = id
-        num = self.lib.llama_detokenize(self.model, self.token_ids, len(ids), self.text_buff, len(self.text_buff), remove_special, unparse_special)
+        num = self.lib.llama_detokenize(self.vocab, self.token_ids, len(ids), self.text_buff, len(self.text_buff), remove_special, unparse_special)
         while num < 0 and len(self.text_buff) < (16 << 20):
             self.text_buff = self.ffi.new("uint8_t[]", -2 * num)
-            num = self.lib.llama_detokenize(self.model, self.token_ids, len(ids), self.text_buff, len(self.text_buff), remove_special, unparse_special)
+            num = self.lib.llama_detokenize(self.vocab, self.token_ids, len(ids), self.text_buff, len(self.text_buff), remove_special, unparse_special)
         return str(self.ffi.buffer(self.text_buff, num), encoding="utf-8", errors="replace")  # replace errors with '\uFFFD' # pyright: ignore[reportArgumentType]