uvspeed

A development platform built on the beyondBINARY prefix system {+1, 1, -1, +0, 0, -0, +n, n, -n, +2, +3} — structurally addressing code with 11 symbols across 20+ languages, each mapping to a quantum gate.

Built with:

Prefix/QuantumGutter · notePad · hexTerm · hexCast · ResearchLab · FREYAunits · History · Search · brotherNumsy · kBatch · HexBench · ArchFlow · gpu/cpu · Dashboard · Jawta · QA · Sponsor

Preview

Quantum Notepad — main interface with prefix gutter, convert timeline, and navigation

Quantum Notepad — prefix gutter, convert timeline, 3D navigation, stream history

More screenshots (click to expand)

brotherNumsy & Freya — endless runner game

brotherNumsy & Freya — endless runner with pixel-art sprites and AI training API

kbatch keyboard analyzer with thermal heatmap

kbatch — keyboard heatmap with thermal contrails and rainbow key lighting

hexcast video broadcast in terminal

hexcast — camera → terminal video streaming with truecolor ANSI rendering

Blackwell NVIDIA data visualization

Blackwell Live — NVIDIA data viz with SM heatmaps and deploy targets

archflow architecture node visualizer

archflow — n8n-style drag-and-drop architecture node visualizer

jawta spatial audio with Strudel live coding

jawta-audio — Dolby Atmos spatial audio + Strudel live coding

questcast Meta Quest broadcast

questcast — Meta Quest broadcast + research tools

Inspect timeline with convert bar

Inspect — convert timeline bar with prefix version history

17+ language benchmark coverage

Language benchmarks — 17+ languages with prefix classification accuracy

Prefix system applied to code

Prefix everything — 11 symbols structurally addressing any codebase

3D quantum navigation panel

Quantum navigation — 3D spatial code navigation with orb visualization

Nyan cat hex stream visualization

Nyan cat hex stream — pixel-art characters in the starfield

FreyaUnits converter cell

FreyaUnits — 27-unit precision converter (Planck length → Parsec)

Mermaid architecture diagram

Mermaid diagrams — inline architecture visualization in the notepad

IDE plugin and Cursor rules

IDE integration — Cursor rules, VS Code, Copilot, Windsurf, MCP server

Visual Slice — 2D prefix cross-section Visual Cube — 3D Rubik's cube navigation Visual Orb — quantum orbital probability

Visual Slice / 3D Rubik's Cube / Quantum Orbital — 3 modes of spatial code navigation

What’s Inside

uvspeed is a collection of developer tools unified by the quantum prefix system. Everything runs in the browser (zero install) or as a native Tauri desktop app.

Desktop App (Tauri)

The launcher opens three modes:

Mode	Description
Instance	Full terminal (`hexterm`) with individual feed windows per stream
Grid View	Single-canvas multi-stream grid — click any cell to open as individual instance
Web	Opens browser PWA — works on phone, tablet, desktop

Plus a {dev} launch mode that opens the terminal with the dev console active.

Web Tools

Preview	Tool	What it does
	quantum-gutter	Prefix system showcase — interactive 3D prefix cube, inverse starfield, live editor, benchmarks, visual slice/orb/hex stream, 17+ language coverage
	quantum-notepad	Code notepad with prefix gutter, 17+ language support, mermaid diagrams, HexStream chat, GPU<>Q sidebar, 8-mode live heatmaps (treemap/bubble/bars/sunburst/orb/lattice/cube/slice), quantum 3D navigation
	terminal (hexterm)	Full terminal emulator — virtual FS, hexcast, kbatch, device presets, sync, gutter, dev/auditor mode, compliance audits, training data capture
	feed	Lightweight video/audio feed window with speech-to-text transcript
	grid	Multi-stream canvas with 2x2/3x3/4x4 layout, device management, dev console
	launcher	Mode picker + command console for controlling all connected devices
	brotherNumsy	Endless runner game with AI training API and FreyaUnits converter
	kbatch	World keyboard analyzer — 8 tabs, 15 layouts, 121 knowledge capsules (10 categories), Symbol Lab, Quantum Lattice 3D, IBM QPU bridge, StenoEngine
	hexcast	Camera → hex video broadcast — 4 encode modes, latency benchmarks
	hexcast-send	Mobile PWA for streaming phone camera to a remote hexcast receiver
	blackwell	NVIDIA Blackwell data visualization + deploy targets (DGX Spark, Lambda)
	questcast	Meta Quest broadcast + research tools
	archflow	n8n-style architecture node visualizer with mermaid export
	jawta-audio	Spatial audio + Morse TX/RX + whisper/truth analysis + Quantum Bridge + biometric pipeline
	hexbench	Voltage lab — PSU monitor, Arduino code editor, node workbench, Pybricks builder
	research-lab	Markdown research editor with node canvas, mermaid preview, console
	freya	Galactic unit converter, scientific calculator, celestial charts, quantum geo navigation
	freya-landing	FreyaUnits showcase — interactive log-scale canvas, live converter demo, roadmap
	history	Universal timeline knowledge graph — ZPF to cosmic scale, block canvas, research viewer, AI persona builder, mass search connectors
	search	Mobile-first universal search PWA — 17 connectors + Document Viewer + tone/heartbeat analysis + economic timeline
	numsy	1080x1080 Instagram visual generator
	sponsor	Sponsor page with Rubik’s cube, inverse starfield, Numsy sprites, tier cards
	github-dashboard	Project health dashboard — phases, deps, community, actions
	qa	QA walkthrough — stage stepper, device preview, annotations, change order export

Shared Modules

Module	Description
quantum-prefixes.js	Shared prefix API — `classifyLine()`, `prefixContent()`, cross-app `BroadcastChannel` sync, IoT WebSocket bridge, global light/dark theme engine
history-search-engine.js	Shared search engine v2 — 17 connectors, document fetching, tone/vocabulary analysis, economic signals, shockwave detection, 3D context coordinates
sw.js	Service worker — offline-first cache for all 24 apps + shared assets

Browser Extension

File	Description
extensions/history-search/	Chrome/Edge/Brave/Opera/Arc/Vivaldi/Firefox extension — injects 17-connector search above Google, Bing, DuckDuckGo, Brave Search, Ecosia, Yahoo results

Install: chrome://extensions → Developer Mode → Load Unpacked → select extensions/history-search/

Mobile: Extensions can’t run on iOS Safari or Android Chrome. Use the Search PWA instead, or the search command in HexTerm.

CLI Tools

Tool	Install	Description
hexcast	`pip install uvspeed-quantum`	Camera → terminal video streaming (truecolor ANSI)
hexcast –receive	same	WebSocket server that renders incoming frames
hexcast –serve	same	Start camera WebSocket server for remote viewers
uvspeed-bridge	same	Quantum bridge server (65+ API endpoints)

Install

Zero install (browser)

Just open any HTML file in web/ — they’re all standalone PWAs:

open web/quantum-notepad.html
# or visit: https://fornevercollective.github.io/uvspeed/web/quantum-notepad.html

Python CLI (hexcast + bridge)

# With uv (recommended)
uv pip install -e .

# With pip
pip install -e .

# Lightweight (no OpenCV/numpy — uses Pillow)
pip install -e ".[lite]"

# Run hexcast
hexcast                    # local camera → terminal
hexcast --serve            # start camera server
hexcast --receive          # receive remote stream
hexcast --connect <IP>     # view remote stream
hexcast --discover         # scan LAN for peers

Tauri Desktop App (macOS)

# Prerequisites: Rust + cargo
cargo install tauri-cli

# Build
mkdir -p tauri-dist && cp -r web/* tauri-dist/
cargo tauri build --bundles app

# Launch
open src-tauri/target/release/bundle/macos/uvspeed.app

From GitHub Releases

Download from Releases:

Package	Contents
`uvspeed-*.tar.gz`	Full platform (web + CLI + Tauri source)
`uvspeed-web-*.tar.gz`	Web apps only (PWA-ready, deploy anywhere)
`hexcast-*.tar.gz`	Hexcast CLI standalone
`*.whl`	Python package (`pip install *.whl`)

Quantum Prefix System

The 11-symbol system (9 core + 2 extended) replaces binary {0, 1} with directional prefixes:

+1:  declaration / structure     (class, struct, interface)
 1:  logic / computation         (if, match, loop body)
-1:  I/O / side effects          (print, write, network)
+0:  assignment / binding        (let, const, var =)
 0:  neutral / pass-through      (else, default, no-op)
-0:  annotation / comment        (// #  /** */)
+n:  entry / import              (import, use, require)
 n:  flow / iteration            (for, while, map)
-n:  exit / return               (return, yield, throw)

Supported in 20+ languages: Python, JavaScript, TypeScript, Rust, Go, Swift, Kotlin, C/C++, Java, C#, Ruby, PHP, Dart, Lua, Shell, R, Haskell, Elixir, Zig, WGSL.

Architecture

uvspeed/
├── web/                         # 24 standalone HTML apps (PWA-ready)
│   ├── quantum-gutter.html      # Prefix system showcase + 3D cube
│   ├── quantum-notepad.html     # Main notepad with prefix gutter
│   ├── terminal.html            # Full terminal emulator (hexterm)
│   ├── research-lab.html        # Research editor + node canvas + Gold Standard workflow
│   ├── quantum-prefixes.js      # Shared prefix API (cross-app sync)
│   ├── quantum-prefixes.d.ts    # TypeScript type definitions
│   ├── quantum-theme.css        # Shared light/dark theme module
│   ├── wasm-loader.ts           # WASM prefix engine loader (JS fallback)
│   ├── sw.js                    # Service worker (offline cache)
│   └── ...                      # hexcast, hexbench, blackwell, archflow, sponsor, etc.
├── crates/prefix-engine/        # Rust prefix classifier (native + WASM + C FFI)
│   ├── src/lib.rs               # Core regex classifier (11 symbols)
│   ├── src/ast.rs               # Tree-sitter AST-backed classifier (zero false positives)
│   └── src/simd.rs              # SIMD-vectorized engine (100M+ lines/sec target)
├── src-tauri/                   # Tauri v2 desktop app (Rust)
│   ├── src/main.rs              # Window management, menus, IPC commands
│   └── src/prefix_engine.rs     # Tauri IPC → Rust classifier bridge
├── editors/                     # IDE plugins
│   ├── vscode/                  # VS Code extension (gutter + status bar + commands)
│   └── neovim/                  # Neovim plugin (Lua, extmarks)
├── src/bridge/                  # Go WebSocket bridge server
├── src/shaders/                 # WGSL GPU compute shaders
├── scripts/                     # Build automation
│   ├── build.nu / test.nu       # Nushell pipelines (build, test, audit)
│   ├── build-wasm.sh            # Rust → WASM compilation
│   ├── version-sync.sh          # Cross-file version alignment
│   └── watch-dev.sh             # Dev file watcher (web/ → tauri-dist/)
├── .github/workflows/           # CI/CD (4 workflows)
│   ├── ci.yml                   # Rust + Python + WASM + prefix validation
│   ├── health.yml               # Weekly health checks for all 24 apps
│   ├── pages.yml                # GitHub Pages deploy
│   └── release.yml              # Tagged release builds
├── .pre-commit-config.yaml      # Pre-commit hooks (ruff, clippy, prefix, version)
├── uvspeed_cli.py               # Python CLI (serve, classify, prefix, stats, health)
├── pyproject.toml               # Python package config
├── tsconfig.json                # TypeScript config
└── install.sh                   # Full install script

Multi-Stream Architecture

┌─────────────────────────────┐
│  Launcher (mode picker)     │
│  ┌────┐ ┌────┐ ┌────┐     │
│  │inst│ │grid│ │ web│     │
│  └─┬──┘ └─┬──┘ └─┬──┘     │
│    │       │       │ {dev}  │
│  command console             │
└────┬───────┬───────┬────────┘
     │       │       │
     ▼       ▼       ▼
  Terminal  Grid   Browser
  (hexterm) (canvas) (PWA)
     │       │
     ▼       ▼
  Feed windows (lightweight)
  ┌─────┐ ┌─────┐ ┌─────┐
  │video│ │video│ │video│
  │audio│ │audio│ │audio│
  │chat │ │chat │ │chat │
  └─────┘ └─────┘ └─────┘

All windows communicate via BroadcastChannel('hexterm'):

Feed windows send keystrokes → master terminal’s single kbatch
Feed windows send transcripts → master for centralized logging
Launcher console sends commands → all windows

Development

# Clone
git clone https://github.com/fornevercollective/uvspeed.git
cd uvspeed

# Python tools
uv pip install -e ".[dev]"

# Tauri dev mode
mkdir -p tauri-dist && cp -r web/* tauri-dist/
cargo tauri build --bundles app

# Run tests
pytest                                    # Python tests
cargo test -p uvspeed-prefix-engine       # Rust prefix engine tests

# Lint
ruff check .                              # Python lint
cargo clippy -p uvspeed-prefix-engine     # Rust lint

# Build WASM
bash scripts/build-wasm.sh               # Rust → WASM → web/wasm/

# Nushell pipelines (optional)
nu scripts/build.nu all                   # Build everything
nu scripts/test.nu all                    # Run all test suites
nu scripts/audit.nu health                # Check dev tool versions

# Version management
bash scripts/version-sync.sh              # Check version consistency
bash scripts/version-sync.sh set 4.33.0   # Set all versions at once

# Pre-commit hooks (one-time setup)
pip install pre-commit && pre-commit install

Gold Standard Workflow

Edit code → git commit (pre-commit: ruff + clippy + prefix headers + version sync)
         → git push   (CI: Rust tests + WASM build + Python tests + health check)
         → Runtime    (JS engine / WASM engine / Tauri IPC / Go bridge / Python CLI)
         → Output     (BroadcastChannel → 24 PWA apps, WGSL GPU shader, Quantum QPU)

10 languages: TypeScript, Rust, Python, JavaScript, Go, CSS, Shell, Nushell, WGSL, TOML/YAML

v4.33 — Quantum Bridge + Biometrics + Compliance + Portfolio Capsules + QA

Quantum Bridge Integration — 6 new Jawta API endpoints in bridge server v3.4: Morse encode/decode (PARIS timing, Q-codes, prosigns), whisper/sub-vocal analysis (NLP markers, voice stress 8-12Hz), truth/deception fusion (6-signal weighted scoring), biometric snapshots, transcript deep analysis (concept extraction, Flesch-Kincaid). 5 WebSocket message types for real-time streaming.
Jawta Audio Bridge Connector — QuantumBridge module in jawta-audio.html with auto-reconnecting WebSocket + HTTP fallback. All cross-tool bridges (kbatch, persona, steno, morse) now push to bridge server. New “Quantum Bridge” button runs full pipeline: whisper + truth + transcript + biometric in parallel.
Compliance Engine — 6 compliance frameworks (HIPAA, OpenSSF Scorecard, SPDX/SBOM, CMMI Level 3, SOC 2 Type II, OSINT Best Practices) in bridge server. Pattern matching, file existence checks, scoring with critical gaps and recommendations. HexTerm comply commands for interactive audits. SBOM generation in SPDX-2.3 format.
Project Portfolio Capsules — 23 new knowledge capsules from external Figma/app projects (ClayDayzZ ceramics, Cube Neural speedcubing, HaloID face scanning, Mars Boarding Pass, OP-1 Field synthesizer, NEUwave typography, GeoSonic live coding, FontLab writing systems, ASCII Art Camera, Video Feeds multi-stream, and 12 more). 121 total capsules across 10 categories. 90+ new LEXICON terms.
Dev/Auditor Terminal Mode — HexTerm devmode toggle unlocks audit, stack, train, bench, exec, comply commands with bridge server WebSocket connection. Training data capture collects screenshots, audio, command logs, device info, code context (does not train a model).
QA Walkthrough PWA — qa.html stage-based testing tool. Steps through all 24 apps with live iframe preview, device simulation (desktop/tablet/mobile/mobile-sm), pass/flag workflow, per-stage annotations (note/bug/suggestion/change), auto-batched change orders, JSON + Markdown export. Keyboard shortcuts: arrows/enter/f/e.
Mobile Responsive Overhaul — All 24 apps now have -webkit-text-size-adjust, touch-action:manipulation, -webkit-tap-highlight-color. 6 apps got new @media breakpoints (feed, grid, hexcast-send, history, launcher, search).
ML Export — quantum-gutter.html buildUnifiedDataset() now includes jawta bridge status, whisper physio/eye/truth, morse config, and async fetchBridgeData().
Bridge Server v3.4 — 65+ endpoints across 11 categories. New QA category: git changes, app health (13 checks per app), change order management. New compliance category: audit, frameworks, SBOM. New training loop: stack info, training history.

v4.19 — Search Context Intelligence + KBatch Expansion + CRDT Collab

Search Context Intelligence — history-search-engine.js v2 with 17 connectors (added FRED, World Bank, CoinGecko), document fetching, writing tone analysis (academic/marketing/educational/narrative/legal/crisis), vocabulary profiling, monetary signal detection, shockwave analysis, and heartbeat metric.
Document Viewer — Slide-in panel in search.html and Inspector Doc tab in history.html for deep-dive content analysis with tone bars and AI self-awareness.
Economic Timeline — history.html gains an economic heatmap overlay with shockwave lines from historical crises (Great Depression, dotcom, 2008, COVID).
3D Quantum Coordinates — contextToCoordinates() maps document context to [x, y, z] quantum space (sub-references, vocabulary richness, tone complexity).
KBatch Expansion — 8-tab system: Analyzer, Layouts, Dictionary, Capsules (8 demographic language sets), Symbol Lab (multi-script + Unicode analysis), Quantum Lattice (3D keyboard visualization), Quantum (IBM bridge), Training.
PWA Manifest Generator — generateManifest() and exportAppAsPWA() in shared module for one-click PWA export of any uvspeed app.
CRDT Collaborative Editing — BroadcastChannel-based LWW register sync for multi-tab real-time editing in quantum-notepad.
Launcher Overhaul — All 24 apps now linked from the launcher hub.
TypeScript Defs — Full type coverage for QPU simulation, context coordinates, and history-search-engine.d.ts for the search engine API.
CI Health — Updated required exports check (14 functions including simulateCircuit, submitToIBM, hellingerFidelity, contextToCoordinates).

v4.3 — Multi-Architecture + AI + AST

Multi-GPU Architecture Views — Blackwell dashboard now supports 5 manufacturers: NVIDIA Blackwell, AMD CDNA 4, Intel Xe3, Apple M4, Qualcomm Adreno X1. Click chips in header to swap layer stacks, specs, heatmaps, and deploy targets.
AST-Backed Classification — Tree-sitter integration in Rust prefix engine. Zero false positives. Exact node-type classification for Python, JS, TS, Rust, Go, C. Regex fallback for unsupported languages. Accuracy comparison API built in.
Batch-Optimized Engine — New simd.rs module with first-byte dispatch tables and SIMD-friendly batch processing. Target: 100M+ lines/sec.
AI Game Training — BrotherNumsy blocks builder now generates real executable code. Neural network agent (nn_simple mode) trains on gameplay with online weight updates. numsyAI.train(episodes, agentFn) API for automated training sessions.
Dimensional Diff — Quantum Notepad tracks X/Y/Z spatial changes between snapshots. notebook.showDimensionalDiff() shows prefix shifts, not just line changes. Terminal command: diff or qdiff.
Quantum Circuit Mapping — QuantumPrefixes.toQuantumCircuit(code, lang) maps prefix symbols to quantum gates (H, CNOT, X, Rz, I, S, T, SWAP, M). ASCII circuit diagram output. sendToQPU() relays to IoT bridge.
IDE Plugins — VS Code extension (editors/vscode/) and Neovim plugin (editors/neovim/) with gutter decorations, status bar, and classification commands.
HexTerm Launch Fix — Cleaned splash: no more auto-camera popup, proper branded intro with 2.5s auto-dismiss, prefix header added.

uvspeed is solo-built and open source. Sponsorships fund full-time development, test hardware, and infrastructure.

Tier	Amount	Perks
Contributor	$5/mo	Name in README, sponsor badge
Builder	$15/mo	Priority issues, early access
Studio	$50/mo	Roadmap input, custom configs
Agency	$200/mo	Logo in README, support channel

Also accepted: Ko-fi · PayPal · Open Collective

See SPONSORS.md for full details and goals.

License

MIT — see LICENSE

_{beyondBINARY · {+1, 1, -1, +0, 0, -0, +n, n, -n} · fornevercollective}

This site is open source. Improve this page.