# Why Loom? Golang AI vs PyTorch, llama.cpp & Cloud AI — OpenFluke

> Why choose Loom: pure Golang AI engine (Apache 2.0, zero CGO), offline DNVM, 21 dtypes, WebGPU, vs PyTorch, JAX, llama.cpp, GoMLX, and cloud chatbots. Open source engine + SoulGlitch proof.

Canonical: https://openfluke.com/why-loom

---

Golang AI · Edge · Open Source
Why Loom vs the rest of AI
Cloud chatbots rent intelligence. PyTorch rents a Python runtime. Loom is a
pure Go AI engine you embed—offline, deterministic, Apache 2.0—with a shipped app
( SoulGlitch ) that proves it on real phones.
Interactive 3D
Loom overview
Documentation
GitHub
Skip to comparisons ↓
What you get
The OpenFluke stack
Not a single API—an open-source AI infrastructure lab : engine, bindings, docs, and products built on the same runtime.
Loom (Apache 2.0)
M-POLY-VTD engine: train + infer, 21 dtypes, WebGPU, BitNet CPU, C-ABI welvet , native release binaries.
Polyglot bindings
Python, TypeScript/npm, Go, Dart, C#, Java, WASM—one engine, same weights, embed like SQLite for neural nets.
SoulGlitch (product)
Offline AI companion on Google Play—swarm Q&A, emotion training, reactive face. Living proof of on-device Loom.
Primecraft + lab tools
Voxel simulation with embedded AI, scene gallery, Lucy CLI for local HF models—same sovereignty story.
Open source means Loom: source, license, and rebuildable natives on GitHub.
Releases ship prebuilt .so / .dylib / wheels so you don't have to compile Go—same pattern as PyTorch pip wheels or llama.cpp binaries.
SoulGlitch is a product on Google Play (app code not necessarily OSS).
Model weights come from Hugging Face under their own licenses.
Advantages
What Loom does differently
Compared to cloud AI, Python frameworks, LLM-only runners, and other Go ML libraries.
Sovereign & offline
No API keys. Prompts and training stay on your hardware—privacy by architecture, not policy PDFs.
Pure Go, zero CGO
Golang AI without a Python runtime or CUDA-only trap. Single-binary deployment story for edge and servers.
3D volumetric mesh
Networks as spatial grids—not only nn.Sequential . Native target propagation and step mesh learning.
21 dtypes + BitNet
Float64 down to 1-bit binary per layer. Native packed checkpoints with verified save/reload (v0.79). BitNet b1.58 on CPU since v0.78.
DNVM determinism
Bit-identical behaviour across CPU, WebGPU, and bindings—reproducible research and embedded systems.
WebGPU everywhere
Cross-vendor GPU: Windows, Linux, macOS, Android, browser—without shipping CUDA toolchains per platform.
DNA & NEAT built-in
Topological comparison of whole networks, evolution in-engine—not just weight checkpoint diffing.
Shipped proof
SoulGlitch on Play Store today. Not slides—a consumer app running local LLMs via Loom/welvet.
Vs the industry
Quick comparisons
Cloud AI (ChatGPT, etc.)
Them: Intelligence in their datacenter
Loom: Engine in your process
Them: No embeddable runtime
Loom: C-ABI for your app
PyTorch / JAX
Them: Python + huge CUDA stack
Loom: Go binary, edge-first
Them: 1D autograd DAG
Loom: 3D mesh + target propagation
llama.cpp / Ollama
Them: LLM inference focus
Loom: Train + small nets + NEAT + DNA
Them: GGUF decode excellence
Loom: Full engine for products
GoMLX / Born ML
Them: 1D stacks or OpenXLA/CGO
Loom: Zero CGO + WebGPU
Them: Narrower scope
Loom: DNVM, BitNet, DNA, shipped app
Feature matrix
Loom vs PyTorch & Go ML (summary)
Capability
Loom
PyTorch / JAX
llama.cpp
Core language
Pure Go (golang AI)
Python + C++/CUDA
C/C++
Offline / embed
First-class (C-ABI, WASM)
Possible, heavy
Inference-focused
Training + custom nets
3D mesh, NEAT, DNA
Autograd ecosystem
Mostly inference
Quantization
21 native dtypes + BitNet CPU
TorchAO add-ons
GGUF quants
GPU path
WebGPU (cross-platform)
CUDA / ROCm / TPU
CPU/GPU backends
Determinism (DNVM)
Bit-exact claim
Not guaranteed
Varies
Open source
Apache 2.0 engine + binaries
Framework OSS
OSS inference
Deep dive: M-POLY-VTD architecture research ·
docs overview
Fit
When to choose Loom
Choose Loom if you need…
Offline AI inside your app (Flutter, Go, WASM)
A golang AI / Go ML stack without Python
Bit-exact, auditable local inference
BitNet or sub-byte models on CPU
3D / NEAT / DNA research in one engine
Apache 2.0 you can fork and ship
Use something else if you need…
Largest cloud models with zero setup (use hosted APIs)
Massive PyTorch ecosystem & HF fine-tune recipes day one
Fastest GGUF Llama on Mac CPU only (benchmark llama.cpp)
Enterprise MLOps (Kubeflow, etc.) out of the box
Ready to try the golang AI engine?
Star the repo, read the docs, or install SoulGlitch and run models offline today.
openfluke/loom
Deploy with welvet
SoulGlitch