Active Development

Where AI
Learns to Play

OpenFluke builds AI tools and games for everyone — from hobbyists to researchers. Our engine Loom runs neural networks on any device. Our game SoulGlitch turns training AI into a living adventure.

Explore Loom SoulGlitch GitHub

What We Build

The OpenFluke Ecosystem

Three things, one vision: portable AI that anyone can run, train, and play with.

Loom

v0.75.0 — Stable

The universal AI engine. Train a neural network once and run it everywhere — Python, JavaScript, Go, your phone, a web browser. No cloud required. Think of it like SQLite, but for AI.

Learn about Loom

SoulGlitch

In Development

A private, on-device AI digital pet with reactive glitch expressions and emotional training. Build a swarm of personalities, train their reactions, and chat entirely offline. Your hardware, your privacy.

About SoulGlitch

Scene Gallery

Live

Browse screenshots and voxel scenes from SoulGlitch and the Primecraft Engine.

Open Gallery

The AI Engine

Loom — The SQLite of AI

Most AI libraries require cloud accounts, GPU servers, and complex setup. Loom is different: it's a self-contained, portable engine that you drop into any project. One model file. Identical results on every platform.

75% complete on our roadmap with the new v0.75 docs and platform updates. Now available for Python, JavaScript, Go, iOS, Android, and WebAssembly.

Python JavaScript iOS / Android WebAssembly WebGPU

Deep dive into Loom

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))
}
        

AI Deep Research

Independent Analysis of Loom

AI researchers produced an exhaustive breakdown of how Loom works — and why it's architecturally different from every other AI framework.

AI-Generated Podcast

Loom AI: 3D Grids & Target Propagation

A narrated deep-dive into Loom's volumetric architecture and how it differs from PyTorch, JAX, and every Go ML framework.

Full Technical Analysis PDF Report

🧊 AI that thinks in 3D

Most AI frameworks process data in a straight line. Loom uses a 3D volumetric grid — signals can jump across regions like neurons in a real brain, not an assembly line.

💾 98.4% model compression

Loom supports 21 numeric types from Float64 down to 1-bit Binary. An AI model that normally takes gigabytes can shrink by 98.4% — small enough to run on your phone, offline.

🧬 Learns without backprop

Loom implements Neural Target Propagation — each layer learns independently without freezing the whole network. More biologically plausible, and works on non-differentiable 1-bit models.

Private AI Digital Pet

SoulGlitch — Chat. Train. Evolve.

SoulGlitch is a private AI digital pet that lives entirely on your device. Train its emotional reactions, chat without the cloud, and build your own swarm of personalities. Our engine Loom drives the brain, ensuring everything stay local and private.

100% offline, no subscriptions, and purely on your own hardware. Where local AI starts feeling expressive and alive.

About SoulGlitch Dev Notes

Watch the trailer for the world's most private AI digital pet.

Other Open Source

More From OpenFluke

Other tools and experiments built alongside Loom and Primecraft.

Open Source · NLP Tool

TokenTrove

Find recurring text patterns across millions of documents. N-gram chain discovery, file-level tracking, and parallel processing — shown here analysing 5,000+ FCC legal documents to surface the most common boilerplate phrases. Built in Go + Fiber.

openfluke/tokentrove

Pattern Mining at Scale

Finds linked n-gram chains across thousands of files — not just single word frequencies, but multi-sentence recurring structures.

Built for Real Corpora

Web UI with real-time stats, parallel processing for speed, numeric pattern filtering. Handles legal documents, FCC filings, research corpora, and plagiarism detection.

Pure Go · Open Source

Same Go + Fiber stack as the rest of the OpenFluke ecosystem. Drop it into any server. MIT licensed.

Star Loom on GitHub

Loom is fully open source. If you find it useful — or just think the idea is cool — a star helps others discover it and keeps the project growing.

Star openfluke/loom

Already have Go/Python/Node.js? Get started in minutes →

Star

Where AILearns to Play