Technology Stack

Isomorphic Architecture

Runs in React (browser) and Bun (server) with shared logic for physics and control, reducing divergence across environments.

GPU-Agnostic Acceleration

WebGPU in the browser with a native Vulkan backend for consistent, high-performance compute across platforms and vendors.

Paragon AI Framework

Custom AI framework in Go with Vulkan support for automation, neural controllers, and adaptive behaviours within physical scenes.

Technology Decisions

The current technology stack balances development speed, deployment compatibility, and raw performance. Go was selected for its simplicity and near-C++ performance without the OS-binding complexity of C++. Jolt provides an open-source physics core proven across multiple domains. WebGPU with Vulkan ensures GPU coverage across ~80% of devices, avoiding vendor lock-in. JSON acts as the universal format for portability between browser, server, and native runtimes.

 Open Full Page

Blurring Industry Boundaries

Game Development ↔ Robotics: Real-time physics with robust constraint management supports both play and automation.

Web Tech ↔ Native Performance: Browser-first workflows with desktop-class throughput via isomorphic design.

AI ↔ Physics: Neural controllers learn and adapt to complex physical environments for autonomous behaviours.

Simulation ↔ Reality: Accurate modelling that helps bridge virtual prototyping and real-world tasks.

Core Capabilities

Real-Time Physics Neural AI WebSocket Multiplayer Layer Management Action Recording Constraint Systems Performance Analytics Import / Export Cross-Platform GPU Accelerated

Technical Capabilities

Advanced Physics

Built on Jolt with optimisations for web and native targets. Supports complex constraints for robotics and gameplay systems.

Isomorphic Runtime

Single codepath across React (browser) and Bun (server), keeping client and server behaviour aligned.

GPU Acceleration

WebGPU in browsers and Vulkan natively enable high-throughput compute for simulation and learning.

Distributed Networking

WebSocket management for multi-server monitoring, remote viewing, and multiplayer experiences.

How It Compares

A quick look at portability, browser/server parity, controller format, and GPU flexibility.

Feature / System Openfluke Isomorphic Engine Unity ML-Agents Unreal RL Isaac Sim Gazebo / ROS OpenAI Gym / MuJoCo
Isomorphic (Frontend + Backend parity) ✅ Browser + Backend (same JSON) ❌ Engine-bound ❌ Engine-bound ❌ Native only ❌ Native only ❌ Python only
Physics Engine ✅ Jolt (WASM + native) ✅ PhysX ✅ PhysX/Chaos ✅ PhysX ✅ ODE/Bullet/DART ✅ MuJoCo / custom
AI Controller Format ✅ Portable JSON (automation/NN) ❌ C#/Python + models ❌ C++/Blueprints ❌ Python APIs ❌ ROS nodes ❌ Python code
Runs in Browser ✅ Yes ❌ Limited ❌ No ❌ No ❌ No ❌ No
Runs Natively (Server) ✅ Bun + Vulkan/WebGPU ✅ Yes ✅ Yes ✅ Yes (GPU) ✅ Yes (Linux) ✅ Yes (Python)
WebGPU-Agnostic AI ✅ Same NN front/back ❌ Converts (ONNX/TF/Torch) ❌ Converts ❌ CUDA-centric ❌ ROS-centric ❌ Python ML only
Multi-Server Overlay / Layering ✅ Built-in (transparent layers) ❌ ❌ ❌ ❌ ❌

Comparison is directional and feature-focused; names and trademarks belong to their respective owners.

FAQ

Does it run in a browser and on servers?
Yes — the same scene & controllers run in both.

How are AI controllers defined?
Portable JSON describing observables, controllables, and actions (automation or NN).

GPU requirements?
Browser uses WebGPU (with fallbacks); native uses Vulkan, with CPU fallback.

About This Project

This work explores how physics simulation, interactive 3D, and AI can operate in a single, consistent environment. The platform combines Jolt and Three.js with a Go/Vulkan AI framework to support rapid iteration across browser and native contexts.

Current Status

Active development with the following modules in place:

Physics Core
AI Integration
Cross-Platform
WebSocket I/O
Neural Controllers
Advanced UI
Explore Stack See Capabilities Learn More

Paragon — AI Framework

Type-generic, modular, and distributed neural networks with WebGPU acceleration, micro-network surgery, and ADHD metrics (Accuracy Deviation Heatmap Distribution).

Go + Vulkan WebGPU Type-Generic ADHD Metrics
  • Modular layers/activations (linear, relu, softmax…)
  • Browser WebGPU & native Vulkan acceleration (CPU fallback)
  • ADHD deviation heatmaps + final score
  • JSON model save/load for portable benchmarking
Repository
Code example
// Go
package main

import (
    "fmt"
    paragon "github.com/openfluke/paragon/v3"
)

func main() {
    // Create a type-generic neural network
    nn := paragon.NewNetwork[float32](
        []struct{ Width, Height int }{
            {28, 28}, // Input
            {16, 16}, // Hidden
            {10, 1},  // Output
        },
        []string{"linear", "relu", "softmax"},
        []bool{true, true, true},
    )

    // Enable WebGPU/Vulkan acceleration when available
    nn.WebGPUNative = true

    // Train (placeholders for brevity)
    nn.Train(inputs, targets, 100, 0.01)

    // Evaluate ADHD metrics and final score
    nn.EvaluateModel(expected, actual)
    fmt.Printf("Final Score: %.2f\n", nn.ComputeFinalScore())
}