# OpenFluke — Sovereign AI on Your Hardware (Golang AI Engine)

> OpenFluke builds Loom, a pure Golang AI engine (Apache 2.0, zero CGO) for CPU, GPU, and WebGPU on every OS; SoulGlitch, a private offline AI digital pet on Google Play; and Primecraft, a voxel simulation engine.

Canonical: https://openfluke.com/

---

Star
openfluke/loom
Open-Source AI Infrastructure Lab
Sovereign AI.
On Your Hardware.
OpenFluke builds foundational tools so intelligence can run locally—private, portable, and free of cloud lock-in.
Loom (v0.79 Bedrock) is the M-POLY-VTD engine: 3D volumetric networks, 21 numeric types, and welvet bindings on every major OS.
SoulGlitch shows what that feels like: a living AI companion that never phones home.
Explore Loom
Why Loom?
Loom docs
SoulGlitch on Play
SoulGlitch for Linux
Source on GitHub
Who We Are
An open-source AI infrastructure lab
Most AI today lives in someone else's data center. OpenFluke is an independent R&D lab building
the opposite: edge-native, privacy-first infrastructure that puts training and inference on the devices people already own.
We ship real software—not slide decks. Loom is the engine. SoulGlitch is the proof.
Everything is open source so developers, researchers, and hobbyists can inspect, extend, and ship without permission.
100% offline capable
Loom Apache 2.0
Phone to server
Your data stays yours
Why Loom vs the industry
No cloud required
Run models on laptops, phones, and browsers. No API keys, no subscriptions, no upload pipeline.
One engine, many surfaces
Drop Loom into Python, JavaScript, Go, Flutter, or WASM—the same weights, the same behavior.
Built to be felt
SoulGlitch turns abstract ML into something expressive: chat, train emotions, and evolve personalities on-device.
The Engine
What is Loom?
Loom is our Apache 2.0 M-POLY-VTD engine—CPU and GPU capable, OS-agnostic,
and designed like SQLite for neural networks : one library you embed, not a cloud you rent.
v0.79 hardens the CPU bedrock : volumetric train → native save → reload → infer (Lucy seven-layer suite),
MHA decode , and C-ABI 461/461 —on top of BitNet, asm Dense forward, step mesh, and welvet on every OS.
The Loom runtime — runs everywhere
Silicon & acceleration
x86_64, ARM64, ARMv7
CPU inference & training
GPU via WebGPU / native paths
WebAssembly in the browser
Operating systems
Windows
macOS & iOS
Linux & Android
Node.js, Bun, browsers
📦 Drop-in portability
Prebuilt native libraries ( .dll , .so , .dylib ) install beside your app. Train once, ship everywhere.
💾 Native precision on disk
21 DTypes from Float64 to 1-bit binary—checkpoints store packed weights per layer, not FP32-only JSON. BitNet and Qwen3 load from Hugging Face via Lucy.
🎯 Bit-exact reproducibility
Deterministic execution across CPU, GPU, and language bindings—same inputs, same outputs, every time.
🧬 Biological learning
3D volumetric networks with target propagation—layers learn locally without classic backprop lock-in.
Deterministic AI on any CPU or GPU
Loom is built as a Deterministic Neural Virtual Machine (DNVM) : the same model weights, prompts, and settings
produce bit-identical behaviour whether you run on Apple Silicon, x86, WebGPU, or inside SoulGlitch via
Lucy and the welvet C-ABI.
Apache 2.0 License
Why Loom?
Loom overview
Read docs
Hugging Face · local inference
Models Lucy & SoulGlitch support
Download checkpoints into your local Hugging Face hub cache. Lucy (CLI) and SoulGlitch share the same
approved model list—load safetensors, run chat offline through Loom/welvet.
Model family
Hugging Face repo
Typical use
SmolLM2 Lite
HuggingFaceTB/SmolLM2-135M-Instruct
Phones · fast reactions · default SoulGlitch brain
SmolLM2 Balanced
HuggingFaceTB/SmolLM2-360M-Instruct
Desktop · everyday chat
SmolLM2 Deep
HuggingFaceTB/SmolLM2-1.7B-Instruct
Stronger private hardware · deeper replies
BitNet b1.58
microsoft/bitnet-b1.58-2B-4T
Low-bit ternary weights · Loom v0.78+ infer · v0.79 native save/reload
Qwen3 Lite
Qwen/Qwen3-0.6B
GPU-friendly · strong quality per GB
Qwen3 Balanced
Qwen/Qwen3-1.7B
Desktop · sharded safetensors
Qwen3 Heavy
Qwen/Qwen3-4B
Large GPU / patient downloads
Custom volumetric networks (XOR, NEAT, DNA splice) are built in Loom/poly—no HF download required.
What We Build
The OpenFluke ecosystem
Infrastructure, a flagship app, and community tools—one vision of local, sovereign AI.
Loom
v0.79 — Bedrock
M-POLY-VTD engine: 3D grids, CPU train/save/reload bedrock (v0.79), BitNet on CPU, transformers via WebGPU, NEAT/DNA evolution.
Apache 2.0 — train once, ship in Python, JS, Go, Flutter, or the browser.
Why Loom?
Documentation
Loom overview
SoulGlitch
Android & Linux
A private, on-device AI companion—on Android and Linux (x86_64). Reactive glitch face, swarm chat, emotion training, all offline.
iOS, macOS, and Windows coming soon.
Get on Google Play
Linux download
Scene Gallery
Live
Screenshots and voxel scenes from SoulGlitch and the Primecraft engine—see the worlds we're building.
Open gallery
For developers
Get started in minutes
Loom is a self-contained C-ABI library ( welvet ) you embed in any stack.
v0.79 validates CPU train/save/reload and transformer decode; rebuild welvet natives after upgrade. BitNet, Donate Compute, and TANHI from v0.78 still ship.
One model file, identical results on Windows, Linux, macOS, iOS, Android, and WASM.
Install via pip install welvet , npm install @openfluke/welvet , or embed natives in Flutter—as SoulGlitch does.
Full reference: openfluke.com/docs .
Python
JavaScript
Go
iOS / Android
WebAssembly
WebGPU
Loom documentation
Product page
Python
Node.js
Go
# Install
pip install welvet
# XOR in 10 lines
from welvet import Network, train
net = Network({
"id": "xor", "depth":1,"rows":1,"cols":1,
"layers_per_cell":2,
"layers": [
{"l":0,"type":"dense","input_height":2,
"output_height":8,"activation":"relu"},
{"l":1,"type":"dense","input_height":8,
"output_height":1,"activation":"sigmoid"}
]
})
losses = train(net,
[[[0,0],[0,1],[1,0],[1,1]]],
[[[0],[1],[1],[0]]],
epochs=100, learning_rate=0.1)
print(f"Final loss: {losses[-1]:.4f}")
# Install
npm install @openfluke/welvet
# Usage
const { Network } = require('@openfluke/welvet');
const net = new Network({
id: "demo", depth:1, rows:1, cols:1,
layers_per_cell: 1,
layers: [{ l:0, type:"dense",
input_height:4, output_height:2 }]
});
// Same model, same weights, identical output
// whether running in Node or a browser.
// go get github.com/openfluke/loom/poly
package main
import (
"fmt"
"github.com/openfluke/loom/poly"
)
func main() {
net := poly.BuildNetwork(poly.Config{
ID: "demo", Depth:1, Rows:1, Cols:1,
LayersPerCell: 1,
Layers: []poly.LayerDef{
{L: 0, Type: "dense",
InputHeight: 4, OutputHeight: 2},
},
})
state := net.NewState(poly.Float32)
state.SetInput([]float64{1,0,1,0})
state.Step()
fmt.Println(state.Output(0))
}
Deeper dive
How Loom differs architecturally
Independent analysis of Loom's 3D volumetric design, compression pipeline, and target-propagation learning—
for readers who want the technical story behind the marketing.
Architecture reference: docs overview · comparative analysis on the research page .
Technical research
Loom: 3D grids & target propagation
Comparative analysis vs PyTorch, JAX, and Go ML stacks—architecture, DNVM determinism, and edge deployment.
Read full analysis
🧊 Thinks in 3D
Signals move across a volumetric grid—not only through a rigid layer stack—closer to spatial brain topology than a factory line.
💾 Up to 98.4% compression
Bit-packed serialization from Float64 down to 1-bit binary—gigabyte-class models can shrink enough to run on a phone, offline.
🧬 Target propagation
Layers learn independently via localized target signals—more biologically plausible, and viable on non-differentiable low-bit models.
⚡ BitNet on device
v0.79 fixes native ternary checkpoints end-to-end—Lucy, SoulGlitch, and welvet infer BitNet-class models on packed CPU paths without a cloud API.
Available on Android
SoulGlitch — chat, train, evolve
SoulGlitch is what local AI feels like when it has a face. Ask a swarm, train emotions on your photos, and watch a
glitchy entity react—all powered by Loom on your phone with no cloud.
Download now on Google Play or Linux (x86_64). Coming soon: App Store (iOS), Mac App Store, and Microsoft Store.
Get on Google Play
Linux
Learn more
Google Play · now
Linux · now
iOS · soon
macOS · soon
Windows · soon
Loom × SoulGlitch — models run on your PC; TANHI streams execution live to your phone so you watch mixed layers and remote links in 3D, in real time.
SoulGlitch trailer — private AI companion on your hardware.
×
‹
›
More open source
Built alongside the ecosystem
Utilities and experiments from the same lab.
Open source · NLP tool
TokenTrove
Find recurring text patterns across millions of documents—n-gram chains, file-level tracking, and parallel processing.
Shown here on 5,000+ FCC filings to surface common boilerplate. Built in Go + Fiber.
openfluke/tokentrove
Pattern mining at scale
Linked n-gram chains across thousands of files—not just word counts, but multi-sentence recurring structures.
Built for real corpora
Web UI, parallel processing, numeric filtering—legal docs, filings, research sets, plagiarism workflows.
Pure Go
Same stack as the rest of OpenFluke. Drop it on any server.
Join the project
Loom is Apache 2.0 and fully open source. Stars help others discover it;
issues and PRs shape what ships next.
Contribute on GitHub
Read the docs →
·
API reference →