Frequently Asked Questions

LOOM (Layered Omni-architecture Openfluke Machine) is a high-performance GPU-accelerated neural network framework written in Go. It features WebGPU compute shaders for parallel execution and WebAssembly export for browser deployment.

LOOM offers unique features:

• Native Mixture of Experts: Grid Softmax provides MoE in 2 lines vs 200+ in PyTorch
• True Cross-Platform: Same code runs in browser (WASM), desktop, and mobile
• Go Simplicity: Clean, simple codebase without Python dependency hell
• WebGPU Acceleration: Modern GPU compute with automatic CPU fallback
• Multi-Language: Use from Go, Python, JavaScript, C#, C/C++, Rust

LOOM is under active development and released under Apache 2.0 license. All 5 layer types have been empirically validated with 98.6% loss reduction and perfect classification. While stable for many use cases, we recommend thorough testing for production deployments.

LOOM supports 5 layer types:

• Dense: Fully-connected layers with element-wise activations
• Conv2D: 2D convolutional layers with configurable kernels
• Multi-Head Attention: Transformer-style attention mechanism
• RNN: Recurrent Neural Networks with BPTT
• LSTM: Long Short-Term Memory with gated cells

Grid Softmax applies independent softmax normalization per row in a 2D grid, making it mathematically equivalent to Mixture of Experts (MoE) - the same architecture used in GPT-4, Switch Transformer, and Mixtral. LOOM provides this in 2 lines of code vs 200+ lines in PyTorch/TensorFlow, with 97.1% loss reduction and perfect gradient matching proven in examples/moe_proof_demo.go.

GPU acceleration status:

• Dense: ✅ Full GPU support (forward & backward)
• Multi-Head Attention: ✅ Hybrid GPU/CPU (1.07x speedup)
• Conv2D: ⚠️ CPU fallback (GPU implementation has bugs)
• RNN: ❌ CPU only (sequential nature incompatible with GPU)
• LSTM: ❌ CPU only (sequential nature incompatible with GPU)

Yes! LOOM compiles to a 5.4MB WebAssembly module with full training support. You can train networks with all 5 layer types directly in the browser with zero dependencies. See wasm/example.html for a complete demo.

Performance varies by layer type and batch size:

• Dense layers: 0.38x at small batches (overhead dominates), faster at large batches
• Multi-Head Attention: 1.07x speedup (batch=32, seq=256, dim=512)
• Small models: CPU often faster due to GPU overhead
• Large models: GPU provides significant advantages

Run Option 14 in fabric for comprehensive benchmarks on your hardware.

LOOM supports 100+ layers in a single network using grid-based architecture (rows × columns × layers per cell). Maximum size is limited by available memory. Grid architecture allows flexible organization of complex networks.

Currently, LOOM focuses on single-device training with GPU acceleration. Distributed training and multi-GPU support are planned for future releases.

Yes! LOOM provides bindings for:

• Python: welvet package (pip install welvet)
• JavaScript/TypeScript: WASM module (npm install @openfluke/welvet)
• C# / .NET: P/Invoke bindings (dotnet add package Welvet)
• C/C++/Rust: C Foreign Function Interface (build from source)

Yes! Models saved as JSON work across all platforms and languages. You can train a model in Go and deploy it in Python, JavaScript, C#, or C/C++. The model format is language-agnostic with base64-encoded weights.

Yes! The C-ABI supports Android and iOS with cross-compilation for ARM64, ARMv7, x86_64, and x86 architectures. Build with build_all.sh android arm64 or build_all.sh ios xcframework.

Yes! LOOM is open source under Apache License 2.0. You can view the source code, contribute, and use it freely at github.com/openfluke/loom.

Contributions are welcome! You can:

• Report bugs via GitHub Issues
• Submit pull requests with bug fixes or new features
• Improve documentation and examples
• Share your LOOM projects with the community

Resources for getting help:

• GitHub repository - README and documentation
• Issue tracker - Bug reports and questions
• Examples directory - Code samples
• Documentation - Comprehensive guides