Struct Qwen38Cfg 

pub struct Qwen38Cfg {

    pub d: usize,
    pub layers: usize,
    pub full_attn_every: usize,
    pub dff: usize,
    pub vocab: usize,
    pub h: usize,
    pub kv: usize,
    pub hd: usize,
    pub rope_dim: usize,
    pub rope_theta: f64,
    pub rms_eps: f64,
    pub gdn_k_heads: usize,
    pub gdn_v_heads: usize,
    pub gdn_head_dim: usize,
    pub conv_taps: usize,
    pub ctx_len: usize,
}

Everything the emitter needs, read from the checkpoint rather than assumed. Field names mirror the GGUF metadata keys so a mismatch is easy to spot.

Fields

d: usize

layers: usize

full_attn_every: usize

dff: usize

vocab: usize

h: usize

kv: usize

hd: usize

rope_dim: usize

rope_theta: f64

rms_eps: f64

gdn_k_heads: usize

gdn_v_heads: usize

gdn_head_dim: usize

conv_taps: usize

ctx_len: usize

Implementations

impl Qwen38Cfg

pub fn real() -> Self

The real Qwen3.8-27B shape, as read from Qwen3.8-27B-Q8_0.gguf (see benchmarks/results/qwen38_arch.json).

pub fn tiny() -> Self

A structurally faithful miniature — same op sequence, same hybrid schedule, tiny dimensions. Used to exercise the whole authored program on every backend without 29 GB of weights.

pub fn mini() -> Self

Qwen38Cfg::tiny with the real model’s HEAD PATTERN at a size that splits: 8 query heads over 2 KV heads and 4/8 Gated-DeltaNet heads, so it admits 2 and 4 chips of tensor parallelism — at 4 each KV head is replicated on two chips, as the real model’s 4 KV heads are over its 8.

pub fn gdn_qk(&self) -> usize

GDN q/k width — k_heads · head_dim.

pub fn gdn_v(&self) -> usize

GDN v/gate width — v_heads · head_dim (ssm.inner_size).

pub fn aq(&self) -> usize

Attention query width — h · hd.

pub fn akv(&self) -> usize

Attention K/V width — kv · hd.

pub fn from_spec(spec: &ModelSpec) -> Result<Qwen38Cfg, NotYet>

Layer l is full attention when (l+1) % full_attn_every == 0 — indices 3, 7, 11 … for interval 4. The configuration of a checkpoint’s own spec: a Qwen3.5/3.8 hybrid, its attention every full_attn_every-th layer, every attention layer alike, every Gated-DeltaNet layer alike, every FFN a dense SwiGLU. Refused by name for anything else — and refused unless the configuration writes the checkpoint’s own program, the decode step the author writes for spec (model::program), so no bundle lowered from it can be another model’s.

pub fn is_attn(&self, l: usize) -> bool

pub fn attn_layers(&self) -> usize

How many of the layers are attention (the rest are GDN).

pub fn spec(&self) -> ModelSpec

The model this configuration describes, as a ModelSpec: every full_attn_every-th layer gated attention (partial NEOX rotation, QK-norm, a sigmoid output gate), the rest Gated DeltaNet, each with a dense SiLU FFN.

pub fn layer_spec(&self, l: usize) -> ModelSpec

The spec of this configuration reaching layer l: its layers, or as many more of its pattern as layer l needs — the model a single-layer form of layer l is written from.

impl Qwen38Cfg

pub fn state_bytes_per_seq(&self, maxseq: usize) -> usize

Bytes of per-sequence state a batched decode must hold: the GDN memories, the conv rings and the KV caches. This is what actually bounds the batch size, not the weights.

Trait Implementations

impl Clone for Qwen38Cfg

fn clone(&self) -> Qwen38Cfg

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Qwen38Cfg

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.