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.78 BitNet) 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 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.78 ships BitNet b1.58 on packed CPU paths, native per-layer checkpoints, a step mesh for online 3D learning, and welvet for Python, TypeScript, Go, Dart, and WASM.

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+ · CPU packed inference
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.78 — BitNet

M-POLY-VTD engine: 3D grids, 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

On Google Play

A private, on-device AI companion—now on Android. Reactive glitch face, swarm chat, emotion training, all offline. iOS, macOS, Windows, and Linux coming soon.

Get on Google Play

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.78 adds BitNet inference, native dtype checkpoints, Donate Compute, and TANHI telemetry. 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.78 runs BitNet-class models on packed CPU ternary paths—Lucy downloads, SoulGlitch and welvet infer 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. Coming soon: App Store (iOS), Mac App Store, Microsoft Store, and Linux.

Get on Google Play Learn more

Google Play · now iOS · soon macOS · soon Windows · soon Linux · 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 →

Sovereign AI.On Your Hardware.