v0.1.10

v0.1.10 — physical defragmentation (cortiq convert --defrag)

v0.1.9

v0.1.9 — native v-bit (variable-bit) quantization

- cortiq convert / import-gguf --quant vbit now encode the grouped variable-bit
  format natively in Rust: per-row bit-width (3-8, water-filled by log2 row
  amplitude toward a 4.25-bit budget), per-32-group f16 scale, MSB-first
  packing — byte-compatible with cortiq-core::dequant_vbit. Round-trip unit
  test + real-model convert->run verified (~40% smaller than q8, coherent).
- Only the GPTQ-calibrated v-bit variant (needs an activation Hessian) still
  uses the Python converter; the weight-only path is fully native.

v0.1.8

v0.1.8 — full native GGUF quant coverage + f16 subnormal fix

Fixed
- cortiq-core f16_to_f32 halved every subnormal half-float (subnormal biased
  exponent was 127-15-e, should be 113-e). This corrupted GGUF K-quant
  super-block scales (frequently subnormal) → garbage output. Now correct,
  with round-trip tests.

Added
- import-gguf: native dequant for every common ggml type — Q4_0/1, Q5_0/1,
  Q8_0, Q2_K..Q6_K, Q8_K, BF16, IQ4_NL/XS (faithful ports of ggml
  dequantize_row_*). Q4_K/Q5_K/Q6_K unit-tested vs fp16 ground truth; all nine
  Qwen2.5 GGUF quantizations convert and generate coherently. IQ1/2/3 grid
  codebooks are refused with a clear error (no silent garbage).
- import-gguf accepts an HF repo id (best .gguf auto-picked + downloaded) or
  owner/repo/file.gguf; --hf-token. Linear-attention/SSM (GatedDeltaNet) GGUFs
  are refused with a pointer to the safetensors path.
- convert: native fused-GatedDeltaNet split (qwen3_next/AgentWorld
  in_proj_qkvz/ba group-interleaved → canonical hub tensors); pure row
  permutation, unit-tested. Not yet generation-verified on real fused weights.
- convert: actionable error for a GGUF-only repo instead of a raw config.json 404.

v0.1.7

CMF v0.1.7 — native GatedDeltaNet (Qwen3.5)

Added

• GatedDeltaNet linear attention (Qwen3.5) now converts natively in cortiq convert — the per-layer linear/full schedule, the canonical GatedDeltaNet core, zero-centered (1+w) norms, gate-critical f16 projections, and the multimodal-wrapper tensor names are all handled in Rust.
  • Validated: Qwen3.5-0.8B converts and generates identically to the reference Python converter ("The capital of France is Paris.").
  • Fused qwen3_next / AgentWorld checkpoints still use the Python path.

With this, cortiq convert covers dense, MoE, and GatedDeltaNet models natively — no Python. Prebuilt binaries attached below. cargo install cortiq-cli.

v0.1.6

CMF v0.1.6 — native GGUF importer + MoE

Added

• cortiq import-gguf <file.gguf> --output model.cmf — a native Rust GGUF importer (F32 / F16 / Q8_0; llama / qwen2 / qwen3). It also reconstructs a Hugging Face tokenizer.json from the embedded ggml metadata, so the result is runnable. No Python. (K-quants Q4_K/Q5_K/Q6_K still use the Python importer.)
  • Validated: a qwen2 Q8_0 GGUF imports and generates identically to the HF-safetensors path.
• Mixture-of-experts in cortiq convert — router + per-expert matrices are converted and the runtime dispatches the sparse FFN (qwen2-moe / qwen3-moe).

Note

• Linear-attention (GatedDeltaNet, Qwen3.5) conversion still uses the Python path.

Prebuilt binaries are attached below. cargo install cortiq-cli.

v0.1.5

CMF v0.1.5 — converter hardening

Added

• cortiq convert --quant q8_2f — two-field (𝒲×θ) int8 that recovers most of the int8→fp16 quality gap at the same size.
• Prebuilt cortiq binaries attached to this release (Linux x86_64, macOS arm64/x86_64) — use it with no Rust toolchain.
• Converter round-trip tests (q8 / q8_2f / q4 + a tiny end-to-end) in CI.

Changed

• Byte-faithful conversion: round-half-to-even quantization → weights byte-identical to the reference Python converter (286/290 tensors match; generation identical).
• Lighter: input safetensors are memory-mapped and processed one tensor at a time — peak RAM ≈ the output, not the whole model.
• Resilient downloads: each byte-range chunk retries with exponential backoff, with a live percentage.

cargo install cortiq-cli — or grab a binary below.

v0.1.4

CMF v0.1.4

The full HF → .cmf conversion now lives in one place — cortiq — so anything downstream (like a gateway) just calls the binary.

Added

• cortiq convert --model <owner/name> accepts a Hugging Face repo id and downloads it (config + tokenizer + safetensors) before converting. --hf-token for gated/private repos. Cache: ~/.cache/cortiq/hf.
• Parallel downloads — weight files are pulled in concurrent 32 MiB byte-range chunks over reused connections (saturates bandwidth for single-file and sharded models). Tunable via CORTIQ_HF_THREADS (default 8).

Example: cortiq convert --model Qwen/Qwen2.5-0.5B-Instruct --quant q8 --output model.cmf — no Python.

v0.1.3

CMF v0.1.3

Added — native Rust converter (no Python)

• cortiq convert --model <hf-dir> --quant q8|q4|f16 --output model.cmf converts a Hugging Face checkpoint (config.json + *.safetensors + tokenizer.json) to .cmf entirely in Rust — no numpy, no torch. It reads safetensors, quantizes with f16-rounded row scales, embeds the tokenizer + chat template, and writes via cortiq_core::CmfModel::write.
• Output is generation-identical to the reference Python converter on standard dense transformers (qwen2 / qwen3 / llama / mistral-style). MoE / linear-attention models still use the Python path.

Install / update: cargo install cortiq-cli

v0.1.2

CMF v0.1.2

Makes cortiq serve embeddable as a managed local model server — the change that lets an external process (e.g. an LLM gateway) install CMF from crates.io and run it as a local backend.

Added

• cortiq serve --host <HOST> — control the bind address (default 0.0.0.0; set 127.0.0.1 for a local-only server).
• /healthz liveness endpoint on the server, so a process manager can wait until the model has loaded and is ready.

Install / update: cargo install cortiq-cli · Full notes: CHANGELOG.md

v0.1.1

CMF v0.1.1

Added

• cortiq run --max-tokens <N> (short -n) to cap the number of generated tokens (default 256).

Changed

• Rewritten README — leads with the problem it solves and why, adds a "who it's for" section, benefit-framed points, an inline N-skills comparison, and a real cortiq run transcript. Now grounded in measured, public numbers (e.g. −24.9% task perplexity for a skill vs its backbone). Regenerated in Russian and Chinese.
• Fixed the import_gguf quick-start command (positional: GGUF → HF dir → .cmf).

Install: cargo install cortiq-cli · Full notes: CHANGELOG.md