Built by the Winnex technical team, winnex-nano is the native inference layer of the Winnex ecosystem. Its core is a deterministic, invertible, vocabulary-free spectral tokenizer built on group isomorphism — no BPE, no training, no external files. It depends on winnex-madhava >= 1.8.1 and reuses its kernels (QKᵀ + selective top-K with Cauchy-Schwarz bounds).
winnex-nano (v0.1.11) is the native inference layer of the Winnex ecosystem, built by the Winnex technical team. It is a young, experimental project with the same BSL 1.1 license and the same honest documentation style as the rest of the stack.
| Module | Declared role | State (verified) |
|---|---|---|
| SpectralTokenizer | Char → quaternion spectrum (no BPE, no vocab) | Functional and tested |
| WeightBalancer | Multi-model fusion: W' = Σ αᵢ R(qᵢ) Wᵢ | Basic blend implementation |
| StreamEngine | Chunk generation via Madhava fast build | Streaming interface with callbacks |
| server_sse | OpenAI-compatible /v1/chat/completions | Present (optional extra) |
The most developed core — and the only one the Kaggle notebook actually exercises — is the SpectralTokenizer.
The SpectralTokenizer, built by the Winnex technical team — a deterministic, invertible encoding based on group isomorphism.
The encoding is deterministic and invertible, built on group isomorphism. Each UTF-8 byte b at position pos generates pure-phase spectral modes:
ψⱼ = e^(i · (b + pos + j) · 2π / 256)
(represented as a quaternion [w, x, y, z])
Decode is the analytic inverse — not a correlational probe:
b = arg(ψ) · 256 / (2π) − pos − j (mod 256)
There is also the compact version (1 sample per byte, invoking Nyquist): 2 floats per character instead of embed_dim × 4. The notebook shows a 64× reduction in bits/char (8192 → 128) with round-trip preserved.
This comes from the ΨQRH / PsiQRH framework (Zenodo 17171112), by the same team. There is no vocabulary, no training, no external files — pure arithmetic.
The public notebook winnex-nano-benchmark-spectral is transparent and well structured.
10 languages: English, Portuguese, French, Spanish, German, Japanese, Russian, Arabic, Chinese, Korean.
| Script group | Languages | CER |
|---|---|---|
| Latin | English, Portuguese, French, Spanish, German | 0.00000 |
| CJK | Japanese, Chinese, Korean | 0.00000 |
| RTL / Cyrillic | Arabic, Russian | 0.00000 |
Perfect round-trip in all 10 — this validates the mathematical invertibility.
encode_compact / decode_compact| Chars | Enc (chars/s) | Dec (chars/s) |
|---|---|---|
| 100 | ~11k (setup overhead) | ~1.78M |
| 1,000+ | ~2.2–2.3M | ~8.8M |
| 100,000 | 2.26M | 10.96M |
Encode sustains ~2.2–2.3M chars/s on texts ≥1k; decode runs at 6–11M chars/s. At 100 chars, encode is slower (setup overhead).
| Representation | Bits/char |
|---|---|
| Full spectral | 8192 bits/char |
| Compact (Nyquist, 1 sample/byte) | 128 bits/char (64× smaller) |
| BPE effective | ~4–8 bits/char |
Even compact, the representation is ~16–28× less dense than BPE. The compact path uses the Nyquist theorem with round-trip preserved O(1).
Up to 1M characters: decode runs at ~10M chars/s, ~97 ns/char, with round-trip still correct. Encode at 1M is acceptable (~580 ms).
The documented trade-off: the spectral tokenizer is 100% deterministic with no vocabulary dependency, but 50–70× slower and ~1000× less compact than BPE. It is an autonomous encoding for the native multi-model engine — not a drop-in BPE replacement for a BPE-trained model.
Each component, built by the Winnex technical team, assessed against what the code and the notebook actually demonstrate.
Perfect multi-language round-trip is real. Determinism and absence of vocabulary are genuine advantages for regulated / auditable / multi-model systems. The analytic O(1) decode is elegant, and the compact mode brings 8192 → 128 bits/char, making it usable.
The honest boundary: it remains far less compact and slower than BPE / SentencePiece. There is no public evidence yet that this spectral representation is a good embedding basis for a trained LLM — the notebook does not train or evaluate perplexity / downstream tasks.
A linear weighted blend of tensors with quaternion rotation. It works for the toy example in the README ([1,2,3,4] + [10,20,30,40] → mean). There are no public benchmarks yet of real large-model fusion (Qwen + DeepSeek, etc.).
Where it points: the declared multi-model fusion (W' = Σ αᵢ R(qᵢ) Wᵢ) is the next validation frontier — weight preservation and manifold fusion are validated inside the stack; end-to-end quality of fused models is the open question.
A streaming interface with callbacks and an OpenAI-compatible SSE server exist. The reported 1.7 ms for 3 chunks (vs ~2.1 s of HTTP BPE in the README) is an infrastructure micro-benchmark — not a measure of generation quality.
Real use case — drop-in endpoint swap. An application already speaking OpenAI's protocol can point its base URL at the Winnex SSE server and reuse its client and streaming UI unchanged, while gaining the deterministic stack underneath.
Same company as winnex-madhava. GitHub with 0 stars, very recent release. BSL 1.1 license. The ΨQRH framework behind it is ambitious — reimagining transformers with quaternions + spectrum + lattice — and currently stands as proof-of-concept / experimental code.
What works well, and where the engine fits — and where it is not the right tool.
What works well. Deterministic, invertible, vocabulary-free multi-language tokenizer. Compact mode + O(1) analytic decode. Consistent integration with the Madhava engine. Documentation and benchmark notebook that are notably transparent about limitations.
Still early. Not a BPE replacement for existing models. The "native multi-model engine" and "model-agnostic" positioning await public evidence of quality text generation (perplexity, MMLU, human eval). Representation density and encode speed remain clear disadvantages versus conventional tokenizers.
Where it fits. winnex-nano makes sense inside the Winnex ecosystem (alongside Madhava) when the goal is:
• Fully deterministic, auditable inference systems
• No dependency on external vocabularies
• Multi-model fusion with quaternion rotation
• Experimentation with the ΨQRH framework
For general LLM use (chat, RAG, code), it does not compete with the Hugging Face / vLLM / llama.cpp + BPE stack. It is a piece of a larger, coherent experiment — still experimental.
In summary: the spectral tokenizer is mathematically clean, and the notebook proves what it promises — perfect round-trip and fast decode. The rest of the native inference engine needs more empirical evidence of generation quality before it is a realistic alternative to established inference engines. The Winnex team is transparent about the trade-offs, which is the right foundation to build on.