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.74.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 game where your creatures are real neural networks. Train them by exposing them to environments. Watch them evolve. Battle, build civilizations, and share DNA with the world. Built on the Primecraft Engine.

About SoulGlitch

Scene Gallery

Live

Browse voxel scenes created in Primecraft — the prototype engine behind SoulGlitch. Each scene is a 3D world built and saved by our dev team while testing the 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.

74.6% complete on our roadmap (97 of 130 milestones). Now available for Python, JavaScript, Go, iOS, Android, and WebAssembly.

Python JavaScript Go 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.
🧊 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.

Primecraft scene
Primecraft scene
Primecraft scene
Primecraft scene
In Development

SoulGlitch — Train AI. Evolve Legends.

Design a creature whose brain is a real neural network that you build, train, and evolve. Name your species. Choose their architecture. Feed them experiences and watch emergent behaviour unfold.

Powered by Loom for AI and built on the Primecraft Engine for the 3D world — 100% offline, no cloud required.

About SoulGlitch The Engine Dev Notes
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.

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