SPECTRAL v2.4.0 — RB-420 Acid Tracker Workstation

SPECTRAL v2.4.0 introduces RB-420 Acid Tracker Workstation 1.0: an original, zero-install browser instrument combining a dual-acid groovebox, algorithmic drum machines, visual pattern editing, deterministic and live loop recording, an Impulse-style tracker, and a seeded guitar/synth laboratory.

Open rb-420/index.html directly—no server, Node, npm, build system, framework, cloud service, or network connection required.

What’s new

RB-420 Groovebox

• Two monophonic acid synthesizers
• Sawtooth and square oscillators
• Cutoff, resonance, envelope modulation, decay, accent, and level controls
• Per-machine mute and solo
• Sixteen-step note, accent, gate, and slide programming
• Algorithmically synthesized 808-style and 909-style drum voices
• Kick, snare, closed hat, open hat, clap, and rim lanes
• Euclidean rhythm generator
• Seeded pattern mutation
• Master distortion, filter, delay, feedback, wet mix, and compression
• Live oscilloscope and output meter

No commercial drum samples or proprietary instrument assets are included.

Pattern Master

The new Pattern Master replaces hardware-style pitch entry with a dedicated piano-roll editor for both acid synthesizers.

It supports:

• Direct note placement and removal
• Accent and slide programming
• Step inspector
• Pattern copy and paste
• Transposition
• Seeded variations
• Open .rb420-pattern.json import and export

Dual-mode 30-second recorder

RB-420 provides two clearly separated recording contracts.

Deterministic Render

• Freezes patterns, parameters, BPM, swing, seed, effects, tracker events, and sample identities
• Produces fixed-frame stereo PCM16 WAV
• Supports 44.1 kHz and 48 kHz
• Supports durations from 1 to 30 seconds
• Uses seeded noise and deterministic PCM synthesis
• Exports a reproducibility recipe
• Generates a stable PCM identity digest
• Can send the resulting loop directly into the Tracker

This is a deterministic creative-render contract tied to the RB-420 renderer version. It is not presented as the stronger cross-runtime SPECTRAL Canonical Strict contract.

Live Performance Capture

• Records the actual Web Audio performance
• Captures knob movements, pattern changes, mutes, solos, and tracker playback
• Automatically stops at the selected duration
• Exports stereo PCM16 WAV
• Can send the captured performance directly into the Tracker

Live recordings are intentionally take-specific and do not receive deterministic render recipes.

Impulse-style Tracker

A new eight-channel tracker provides a keyboard-oriented alternative to FastTracker-style composition.

Features include:

• Eight tracker channels
• 32- or 64-row patterns
• Configurable rows per beat
• Note, instrument, volume, and effect columns
• Sixteen sample/instrument slots
• QWERTY piano entry
• PCM16 WAV import
• Browser-decoded fallback for other supported audio formats
• Direct Recorder and Sound Lab integration
• Deterministic tracker-only loop rendering
• Portable project storage with embedded PCM samples

Tracker effect codes are stored in project data for future expansion. Arbitrary Impulse Tracker effect commands are not yet executed.

Sound Lab

The new Sound Lab creates original deterministic guitar and synthesizer loops without bundled samples.

Included synthesis layers:

• Karplus–Strong-style plucked guitar
• Analog-style synth voice
• Triangle-wave sub-bass
• Seeded metallic/noise textures
• Drive and stereo-space processing

Available generative styles:

• Acid Rock
• Machine Funk
• Dark Country
• Industrial
• Tracker Core

Generated loops can be previewed, downloaded as WAV, or sent directly into the Tracker.

Project formats

RB-420 introduces open, inspectable formats:

.rb420.json                 Complete workstation project
.rb420-pattern.json         Acid pattern and parameters
.wav                        Stereo PCM16 audio
.recipe.json                Deterministic render recipe

Projects can embed PCM samples as base64, allowing complete sessions to remain portable as a single file.

Original ReBirth .rbs and Impulse Tracker .it compatibility are not falsely claimed. These are separate binary formats requiring independently tested import and export implementations.

Browser-native architecture

RB-420 follows the established SPECTRAL application philosophy:

• no server
• no localhost requirement
• no Node or npm
• no package manifest
• no build or bundling step
• no external framework
• no CDN or remote assets
• no telemetry or analytics
• no cookies
• no network client
• no proprietary samples

All synthesis, sequencing, visualization, recording, project management, and export operations remain inside the browser.

Verification

The bundled browser-native suite is available at:

rb-420/tests/index.html

It covers:

• repeatable deterministic PCM rendering
• seed-sensitive output identity
• exact PCM16 WAV encode/decode round trips
• stable deterministic recipe identities
• Sound Lab replay equivalence
• malformed WAV rejection

The main application also performs a short deterministic render and WAV round-trip self-check during startup.

Repository updates

The root SPECTRAL README now:

• lists six zero-install browser applications
• adds RB-420 to Project Areas
• includes the RB-420 application and test paths
• links directly to the RB-420 documentation

Quick start

rb-420/index.html

Press PLAY once to initialize Web Audio, program a groove, render or record a loop, and send it to the Tracker.

Gremlin notes

• Browsers require a user gesture before audio playback can begin.
• Live Capture is intentionally affected by performance timing and browser audio scheduling.
• Projects containing several embedded 30-second samples can become large.
• Non-PCM audio formats pass through the browser’s decoder before being frozen into a sample slot.
• Tracker effect codes are stored but not fully executed in v1.0.
• Original .rbs and .it binary import/export are outside this release.
• Deterministic recipes should retain the RB-420 application and renderer versions.

Links

• SPECTRAL repository
• RB-420 Acid Tracker Workstation
• SPECTRAL v2.4.0 release

Created by Trent Slade / QSOL-IMC.

SPECTRAL v2.3.0 — Quantum Error Correction Sonification Laboratory

SPECTRAL v2.3.0 introduces the SPECTRAL QEC Sonification Laboratory 1.0: a zero-install browser application for hearing deterministic quantum-error-correction models, error events, syndrome activity, decoder actions, residual errors, and quantum-state signatures.

Open QEC/APP/index.html directly in a modern browser. No server, Node, npm, build system, cloud service, or network connection is required.

Highlights
Render → Commit → Reveal

The new laboratory introduces a receipt-bound observation workflow:

Configure a QEC experiment or load a local dataset.
Keep generated errors, syndromes, corrections, residuals, waveform, spectrum, and hashes observation-dark.
Render deterministic PCM and WAV bytes.
Bind the audio, event stream, recipe, hashes, and observation receipt.
Reveal the corresponding QEC outcomes and visualizations.

Changing a render-identity control immediately invalidates the previous observation and returns the laboratory to its dark state.

This is an epistemic software protocol—not a claim of physical quantum measurement or wavefunction collapse.

Quantum-state signatures

The laboratory includes audible signatures for:

|0⟩, |1⟩, and |+⟩
Bell Φ+, Φ−, Ψ+, and Ψ−
three-qubit GHZ and W states
qutrit Fourier phase lanes
QEC models

Included deterministic classical models and projections:

Bell parity observer
GHZ parity observer
three-qubit bit-flip repetition code
three-qubit phase-flip repetition code
[[5,1,3]] perfect code
Steane [[7,1,3]] code
3×3 surface CSS projection
sparse 12-node QLDPC/Tanner projection
three-qutrit shift code
Error channels and recovery

Error models:

bit-flip X
phase-flip Z
depolarizing X/Y/Z
biased X/Z
correlated bursts
erasure projection
modulo-three qutrit shifts

Decoder projections:

minimum-weight lookup
iterative syndrome descent
observe-only mode
modulo-three recovery
QEC dataset sonification

Local CSV, TSV, and JSON event datasets can be loaded directly into the browser.

Canonical event fields include:

cycle,qubit,error,syndrome,correction,residual

Dataset contents remain hidden until the associated WAV and observation receipt have been rendered. Files are processed locally and are never uploaded.

Example datasets are included under QEC/APP/datasets/.

Musical mapping

QEC information is mapped into a music-ready stereo source stem:

selected state → sustained harmonic signature
error type → pitch and oscillator colour
qubit or qutrit site → stereo position and pitch index
syndrome weight → upper-register check pulse
decoder action → resolving transient
residual error → darker semitone-offset voice
QEC cycle → deterministic event time

Included sonic textures:

Harmonic Glass
MOS 6581 Lattice
Industrial Pauli Frame
Dark Subspace

Additional controls include tuning, tempo, duration, intensity, stereo width, mutation index, and optional state drone.

Post-render visualization

After observation is bound, the laboratory reveals:

amplitude constellation
syndrome lattice
deterministic PCM waveform
time-frequency display
decoder recovery summary
normalized QEC event table
canonical artifact hashes
Determinism and provenance

Two determinism modes are provided:

Canonical Strict — seeded event generation, integer PCM synthesis, canonical serialization, SHA-256 identities, and deterministic bundles.
Replay Safe — explicitly runtime-bound rendering for documented downstream replay workflows.

Each observed experiment can export:

stereo PCM WAV
provenance manifest
canonical render recipe
normalized QEC event stream
observation receipt
deterministic laboratory ZIP bundle

Manifest authentication detects recipe, receipt, or experiment-summary tampering. Dataset-bound replay requires the matching source identity.

Browser contract tests

The release includes a zero-install browser test suite at:

QEC/APP/tests/index.html

The suite contains 28 deterministic contract tests covering:

SHA-256 known-answer vectors
canonical serialization
repeated render identity
mutation, tempo, and texture sensitivity
WAV structure and duration
CSV, TSV, and JSON parsing
all nine QEC model paths
qutrit rendering
manifest authentication
replay equivalence
tamper rejection
dataset identity requirements
deterministic ZIP construction
scientific claim boundaries
Privacy and deployment

The QEC laboratory is fully local and offline-first:

no analytics or telemetry
no external JavaScript
no remote fonts
no network requests
no CDN dependencies
no service worker
no package manager
no build process

Simply download the repository and open QEC/APP/index.html.

Scientific boundary

The application sonifies deterministic classical representations of quantum states, stabilizer checks, error channels, syndrome extraction, and decoder recovery.

It does not claim:

quantum-hardware access
physical state preparation
physical measurement or collapse
state tomography
hardware-calibrated noise inference
fault-tolerance certification
experimental validation of a QEC implementation

See the complete Scientific Boundaries document.

Repository integration

The root SPECTRAL README now lists five zero-install browser applications and includes the QEC laboratory in:

Project areas
browser quick start
contract-test paths
application documentation links
scientific claim boundaries
Upgrade notes

SPECTRAL v2.3.0 is additive. Existing APP, E8 Geometry Studio, Photon-Sphere Laboratory, Photoacoustic Laboratory, scripts, datasets, and previously generated artifacts require no migration.

SPECTRAL v2.2.0 Audible Geometry and Photon-Sphere Sonification

SPECTRAL v2.2.0 brings two new zero-install browser applications into one repository release: SPECTRAL E8 Geometry Studio 1.0 and SPECTRAL Photon-Sphere Sonification Laboratory 1.0.

Both applications run locally by opening index.html. They require no server, Python runtime, Node runtime, npm package, build step, CDN, account, telemetry, or network connection.

Release highlights

SPECTRAL E8 Geometry Studio 1.0

E8/APP/ is a less restrictive, composition-first instrument for experimenting with musical geometry across the complete 240-root E8 system and an evolving eight-dimensional Cartan torus.

Highlights include:

• three hard-separated render domains: Canonical Deterministic, Replay-Safe, and Creative Non-Deterministic;
• five trajectories: Cartan Sweep, Coxeter Orbit, Triality Spiral, Qutrit 4D Orbit, and Root Walk;
• deep and centred φ ladders, harmonic and minor fields, and E8-height pitch mapping;
• eight factory geometries, an eight-axis Cartan mixer, root-density controls, scene A/B capture and morphing, and audio A/B comparison;
• torus, orbit, triality, trinaural, qutrit-4D, and near-mono spatial maps;
• fast 8-second previews and full stereo PCM16 renders up to 120 seconds at 44.1 or 48 kHz;
• waveform, spectrogram, projected 240-root map, and bounded eight-coordinate trajectory views;
• WAV, recipe, fingerprint, manifest, observation contract, trajectory, upload-readiness, and deterministic ZIP-bundle exports.

Canonical mode uses a versioned integer E8/DSP contract for intended cross-runtime byte identity. Replay-Safe binds its Float64 render to the recorded runtime. Creative mode draws fresh local entropy for every take and intentionally refuses exact manifest replay; the WAV hash is the authoritative identity of that performance.

SPECTRAL Photon-Sphere Sonification Laboratory 1.0

SMBH/ is a deterministic auditory model of photon-sphere and whispering-gallery mode families in the curved optical black-hole analogue reported by Xu et al., with a clearly segregated Kerr 220 sonification extension.

Highlights include:

• paper-grounded optical-path relationships for the photon-sphere, edge-WGM, and outer-WGM families;
• inverse-optical-path frequency mapping, editable auditory anchor, partial stacks, and pedagogical Q controls;
• pure ringdowns, mode-family combs, a constructed pump-configuration montage, an analogue laboratory narrative, and a virtual pump-position scan;
• a separate Kerr 220 engine for exploring an audible spin-dependent analytic fit without attributing it to the Schwarzschild microcavity experiment;
• Canonical Strict integer rendering and Replay Safe Float64 rendering;
• local waveform and spectrogram inspection;
• PCM16 WAV, manifest, normalized recipe, fingerprint, and human-readable mode-table exports;
• fail-closed deterministic manifest replay and browser-native known-answer tests.

The laboratory is an auditory interpretation. It does not recreate the microcavity fabrication process, solve the complete Maxwell/eigenmode problem, simulate laser gain or a black-hole merger, or produce a gravitational-wave detector signal.

Shared offline architecture

The two new applications continue SPECTRAL's lean browser workflow:

• direct file:// operation with no installation or localhost service;
• local-only synthesis, analysis, playback, hashing, and export;
• explicit PCM16 quantization and RIFF/WAV writing;
• canonical recipes, SHA-256 identities, manifests, and mode-scoped replay contracts;
• Canvas-based waveform and spectrogram views that do not affect render identity;
• restrictive Content Security Policies and no production network client;
• self-contained browser test pages beside each application.

Documentation update

The repository README now lists both new applications in Project areas and exposes all four browser-native SPECTRAL applications in Quick start:

APP/index.html                 Deterministic Sonification Workbench 2.0
E8/APP/index.html              E8 Geometry Studio 1.0
SMBH/index.html                Photon-Sphere Sonification Laboratory 1.0
PHOTOACOUSTIC/index.html       Photoacoustic Laboratory 2.0

Getting started

git clone https://github.com/QSOLKCB/SPECTRAL.git
cd SPECTRAL

Then open either new instrument directly:

E8/APP/index.html
SMBH/index.html

Their browser-native test suites are available at:

E8/APP/tests/index.html
SMBH/tests/index.html

No migration is required for the existing Python experiments or APP/ Workbench. The new applications are additive. Provenance manifests remain bound to the application, engine, mode, and version that created them.

Important reproducibility notes

• E8 Canonical Deterministic and SMBH Canonical Strict are the archival render paths.
• Replay-Safe artifacts promise exact replay only when the recorded browser/runtime fingerprint matches.
• E8 Creative Non-Deterministic recipes can restore settings for a new take but cannot reconstruct the previous entropy or audio.
• Keep the WAV, recipe, fingerprint, manifest, and contract artifacts together when archiving a render.

Source and citation boundaries

The SMBH optical-analogue mapping is grounded in:

Xu et al. (2026). Photon-Sphere Modes in Curved Optical Microcavities: A Black-Hole Analogue Laser. Advanced Science, 13, e17466. https://doi.org/10.1002/advs.202517466

The E8 Studio is an explicit sonification and composition mapping built from the repository's E8, triality, φ-fractal, qutrit, and provenance-oriented experiments. It does not claim that a rendered WAV is a physical E8 measurement, cosmological observation, or quantum-computing result.

For the wider research context, see the SPECTRAL repository README and the cited Zenodo records for Spectral Algebraics and Collective Modes.

License and credit

Released under the repository's MIT License.

Created by Trent Slade / QSOL-IMC.

SPECTRAL v2.1.0 — Browser-Native Photoacoustic Laboratory

SPECTRAL v2.1.0 introduces the new SPECTRAL Photoacoustic Laboratory 2.0: a zero-install browser application for deterministic light-to-sound modelling, experimental music generation, WAV transformation, visual analysis, and provenance-bound audio export.

The original Python Photoacoustic Sonifier has been preserved under PHOTOACOUSTIC/scripts/, while the primary interactive implementation now runs entirely inside the browser.

No Python runtime, Node.js, npm, server, build system, CDN, telemetry, or network connection is required.

Simply open:

PHOTOACOUSTIC/index.html

Highlights

• Complete browser-native redesign of the Photoacoustic Sonifier
• Canonical Strict and Replay Safe determinism contracts
• Fixed-point and Float64 photoacoustic DSP paths
• Synthetic light generation and local WAV-through-light processing
• Editable absorber materials and acoustic resonators
• Eight light-source and instrument presets
• Deterministic PCM16 WAV export
• Provenance manifests, fingerprints, stage receipts, and observation contracts
• Deterministic provenance ZIP packages
• Waveform, spectrogram, and model-stage visualization
• Manifest replay and tamper rejection
• IndexedDB render history with session fallback
• Browser-native known-answer and acceptance tests
• Preserved legacy Python implementation
• MIT licensing throughout

Browser-native Photoacoustic Laboratory

The new application models the following simplified signal chain:

light intensity
  → optical absorption
  → material nonlinearity
  → thermal RC response
  → steady-heating removal
  → Γβ pressure conversion
  → direct/derivative pressure blend
  → parallel acoustic resonators
  → optional effects
  → PCM16 quantization
  → canonical WAV

The model is intended for artistic, educational, sonification, and experimental-audio use.

Material and acoustic-cell parameters are illustrative and are not presented as calibrated physical measurements, biomedical claims, engineering predictions, or replacements for physical apparatus modelling.

Two determinism modes

Canonical Strict

Canonical Strict provides the archival and cross-runtime rendering path.

It introduces:

• a Q15 integer signal ABI;
• integer phase accumulators;
• an integer-only Bhaskara sine approximation;
• fixed-point optical absorption;
• fixed-point thermal state;
• fixed-point pressure conversion;
• fixed-point state-variable resonators;
• deterministic fixed-point effects;
• safe-integer canonical JSON;
• bundled SHA-256;
• explicit PCM16 quantization;
• canonical little-endian WAV serialization;
• deterministic ZIP packaging;
• and strict integer-PCM WAV parsing.

The strict backend is a separately versioned browser DSP ABI. It does not claim byte parity with NumPy or SciPy.

Its intended contract is:

same application and engine versions
+ same Canonical Strict mode
+ same normalized recipe
+ same source bytes
+ same seed and mutation index
= same PCM, WAV, fingerprint, contract, manifest, and ZIP bytes

Replay Safe

Replay Safe provides the creative and Python-inspired Float64 path.

It includes:

• Float64 optical and thermal processing;
• nonlinear absorber response;
• SciPy-compatible cavity peak coefficients;
• explicit Float64-to-PCM16 quantization;
• deterministic linear resampling;
• PCM and IEEE Float WAV input;
• runtime fingerprinting;
• and same-runtime replay verification.

Strict and Replay Safe outputs occupy separate recipe and contract domains.

Light-source and musical presets

Eight browser presets are included:

• Industrial Fibonacci — Fibonacci optical impulses through charcoal and industrial-pipe modes
• Soot Music — melodic light modulation through a soot-and-glass-jar model
• Resonant Gas Cell — optically chopped harmonic excitation through ethene and an H-type cell
• Ultrasonic Edge — fast dual-pulse excitation through the CS/PDMS model
• Dark Thermal Drone — slow industrial modulation through black aluminium and Helmholtz modes
• Evolving Material Demo — a four-stage material and resonator progression
• Pulse Laboratory — editable optical pulse generation
• Tone Laboratory — direct optical-carrier and cavity-response experimentation
• WAV Through Light — local audio interpreted as positive-biased optical modulation

The evolving demo moves through:

1. soot and glass jar;
2. charcoal and industrial pipe;
3. ethene and H-type cell;
4. CS/PDMS and the broad open-response model.

Its complete expanded schedule is recorded in the render recipe and stage receipt.

Absorber material registry

The browser laboratory preserves the original material families:

• Soot / candle black
• Charcoal
• Ethene gas cell
• CS/PDMS nanocomposite
• Black aluminium foil
• Custom material

Editable parameters include:

• optical absorption;
• thermal time constant;
• Grüneisen scaling;
• expansion scaling;
• material nonlinearity;
• and relative laser power.

Acoustic resonator registry

Included resonator models are:

• Glass jar
• Helmholtz resonator
• H-type photoacoustic cell
• Open-air approximation
• Industrial pipe or duct
• Custom resonator

Custom resonators support between one and eight explicit modal frequencies and Q factors.

Canonical Strict validates custom modes against the fixed-point stability domain and rejects invalid, mismatched, non-positive, or unsupported configurations.

WAV Through Light

Local WAV files can now be used as optical-intensity modulation sources.

The bundled RIFF parser supports:

• PCM8
• PCM16
• PCM24
• PCM32
• IEEE Float32
• IEEE Float64
• mono and multichannel downmixing
• explicit deterministic resampling

Canonical Strict accepts integer PCM sources. Float WAV inputs are restricted to Replay Safe.

Source files are:

• processed locally;
• never uploaded;
• hashed before rendering;
• limited to 128 MiB;
• and constrained to a maximum 120-second rendered output.

The parser fails closed on malformed RIFF boundaries, duplicate canonical chunks, missing padding, unsupported codecs, invalid alignment, non-finite float samples, and incompatible formats.

Post-processing

Versioned browser-native effects include:

• optical saturation and distortion;
• three-band tone shaping;
• modulated-delay chorus;
• and four-tap chamber reflection/reverb.

The identity-bearing processing order is:

distortion → EQ → chorus → reverb

Disabled-effect parameters and unused generator controls are excluded from normalized recipe identity.

Export profiles

Archive

• 44.1 kHz
• PCM16 mono
• −0.70 dBFS ceiling
• intended for analysis and preservation

Suno Seed

• 48 kHz
• PCM16 dual mono
• −6.00 dBFS ceiling
• conservative headroom for original source-stem workflows

Laboratory Hot

• 44.1 kHz
• PCM16 mono
• −0.10 dBFS ceiling
• intended for aggressive local experiments

Suno Seed is a technical headroom profile. It is not a detector bypass, copyright-evasion mechanism, or external upload guarantee.

Provenance artifacts

Every completed render can generate:

audio.wav
manifest.json
fingerprint.json
stage_receipt.json
derivation_graph.json
upload_readiness.json
README_ORIGIN.txt
photoacoustic_provenance.zip

The deterministic ZIP uses:

• lexically sorted entries;
• fixed DOS epoch fields;
• explicit CRC-32 values;
• no comments;
• no extra fields;
• and uncompressed storage.

Recipe and observation contract

Each normalized recipe freezes:

• application and engine versions;
• algorithm and schema versions;
• determinism mode;
• preset and consumed generator parameters;
• sample rate and integer duration;
• expanded material parameters;
• expanded resonator modes;
• laser power and pressure method;
• enabled effects and their parameters;
• export profile;
• source-byte identity;
• seed and mutation index;
• and Replay Safe runtime identity where applicable.

Observation contracts bind:

• recipe SHA-256;
• PCM SHA-256;
• canonical WAV SHA-256;
• fingerprint SHA-256;
• stage-receipt SHA-256;
• signal ABI;
• sample format;
• sample rate;
• channel count;
• frame count;
• and replay requirements.

Manifest replay

The browser application can replay exported manifests.

Replay fails closed when it encounters:

• an unsupported schema or engine version;
• an unknown preset or generator;
• modified recipe or contract data;
• missing source audio;
• changed source bytes;
• runtime mismatch in Replay Safe;
• WAV-hash mismatch;
• contract mismatch;
• or manifest-core mismatch.

Failed and cancelled renders create no partial artifact set.

Fingerprinting and readiness

The local deterministic fingerprint records:

• PCM and WAV hashes;
• peak and RMS;
• DC offset;
• zero crossings;
• clipping count;
• fixed-size PCM chunk hashes;
• exact repeated-chunk observations;
• and a 64-bin RMS-envelope hash.

Upload readiness is an offline technical advisory only. It does not query or emulate Content ID, Suno, Spotify, YouTube, or another external matching service.

Visualization and interface

The new laboratory provides:

• interactive PCM waveform rendering;
• FFT spectrograms;
• logarithmic and linear frequency display;
• light-intensity traces;
• thermal-response traces;
• pressure traces;
• acoustic-output traces;
• playback transport;
• render metrics;
• hash summaries;
• accessible stage navigation;
• responsive desktop and mobile layouts;
• render progress reporting;
• and explicit stale-output warnings after parameter changes.

Identity-bearing controls are frozen during rendering so the visible interface cannot drift away from the sealed recipe.

Local storag...

SPECTRAL v2.0.0 — Deterministic Sonification Workbench & Audible Geometry Platform

SPECTRAL v2.0.0

SPECTRAL v2.0.0 is a major architectural and research release.

The centrepiece is the new SPECTRAL Deterministic Sonification Workbench 2.0: a zero-install, browser-native application for transforming data, symbolic systems, images, binary streams, and QEC-style event streams into reproducible WAV source stems with deterministic provenance.

The repository has also expanded substantially across E8-inspired synthesis, astronomical sonification, receipt-bound information-lattice sonification, OMI/XOR experiments, photoacoustic modelling, visualization, research datasets, and publication support.

Compared with v1.0.0, this release contains 84 commits and introduces five major project areas:

APP/
E8/
OMI-ISA/
PHOTOACOUSTIC/
SONIFICATION/
Major addition: browser-native Workbench 2.0

The new APP/ directory provides a complete local DHTML application that runs by opening:

APP/index.html

No installation or local server is required.

The Workbench uses:

no Node.js;
no npm;
no build system;
no bundler or transpiler;
no CDN;
no cloud service;
no telemetry;
no network requests;
and no server-side processing.

The browser is the complete application runtime.

Two determinism modes
Canonical Strict

Canonical Strict is designed for archival, publication, and cross-runtime reproducibility.

It introduces:

signed interleaved PCM16 as the signal ABI;
integer phase accumulators;
explicit fixed-point gains and modulation;
deterministic rounding and clipping;
canonical WAV packing;
bundled bitwise SHA-256;
canonical JSON serialization;
deterministic PRNG operation;
fixed sample-count rendering;
domain-separated recipe, fingerprint, contract, and manifest hashing;
and exclusion of runtime observations from strict render identity.
Replay Safe

Replay Safe provides a deterministic creative workflow while permitting controlled Float64 DSP.

It includes:

explicit PCM16 quantization;
recorded runtime fingerprints;
no hidden entropy;
no mutable engine state;
runtime-scoped replay guarantees;
and mode-separated recipe and contract identities.

Canonical Strict and Replay Safe outputs cannot accidentally share the same SPECTRAL recipe identity.

Initial engine registry

Seven versioned engines are included:

omi_xor_ring
e8_cosmovirus
e8_bell
qec_triality
spectral_algebraics
image_scan
data_mapper

Each engine declares its:

identifier and version;
supported determinism modes;
parameter schema;
presets;
export profile;
claim boundary;
and tone-plan compiler.

The registry is extensible without redesigning the central application.

Data and file inputs

The Workbench can process:

CSV;
TSV;
JSON;
plain text;
pasted numerical text;
arbitrary binary files;
byte streams;
PNG;
JPEG;
and WEBP images.

Input handling now includes:

canonical filename-extension routing;
raw source-byte hashing;
versioned input adapters;
deterministic numeric token extraction;
quoted CSV and TSV support;
JSON-number mapping;
binary-byte mapping;
adapter identity in render recipes;
and separation between compressed image identity and browser-decoded pixel observations.

Browser-native image decoding is intentionally restricted to Replay Safe mode.

Deterministic audio pipeline

The new audio layer provides:

deterministic DSP;
PCM16 stereo synthesis;
explicit WAV serialization;
fixed sample-rate export profiles;
deterministic normalization;
deterministic fades and clipping;
chunked rendering;
cancellation support;
and byte-identical strict rendering when the complete recipe is unchanged.

Three export profiles are included:

Archive — 44.1 kHz PCM16 stereo
Suno Seed Export — 48 kHz PCM16 stereo with conservative headroom
Brutalist — 44.1 kHz PCM16 stereo for aggressive experiments

Suno Seed Export is a technical headroom profile for original material. It is not presented as a detector bypass or upload guarantee.

Provenance and reproducibility system

Every Workbench render can produce:

audio.wav
manifest.json
fingerprint.json
upload_readiness.json
derivation_graph.json
README_ORIGIN.txt

These artifacts can also be packaged into a deterministic, uncompressed ZIP archive.

The ZIP implementation provides:

lexically sorted entries;
fixed DOS epoch fields;
no comments;
no extra fields;
explicit CRC-32 values;
and reproducible bundle bytes.
Render recipes and observation contracts

Identity-bearing render recipes now preserve:

application version;
engine version;
determinism mode;
parser and canonicalization versions;
DSP, PRNG, and WAV-writer versions;
normalized engine parameters;
export-profile configuration;
seed and mutation index;
duration in integer samples;
source hash and byte length;
and Replay Safe runtime identity where applicable.

Observation contracts record:

recipe hashes;
source hashes;
PCM payload hashes;
canonical WAV hashes;
fingerprint hashes;
backend and ABI;
sample format;
replay requirements;
and engine claim boundaries.

The pipeline avoids circular self-hashing by separating the manifest core from its final envelope.

Manifest replay

A new fail-closed replay workflow regenerates audio from an exported manifest.

Replay requires:

a supported manifest schema;
the exact engine version;
matching source bytes when a source was used;
a matching regenerated WAV hash;
and a matching regenerated contract hash.

A replay is accepted as a persisted job only after verification succeeds.

Audio fingerprinting and readiness analysis

The deterministic local fingerprint now includes:

exact content hashes;
peak level;
RMS level;
DC offset;
zero-crossing rate;
stereo correlation;
clipping-sample count;
PCM chunk hashes;
repeated exact-chunk observations;
and RMS-envelope hashes.

Upload readiness provides offline advisory checks for:

clipping;
excessive or insufficient peak level;
DC offset;
exact repeated chunks;
aggressive export settings;
and provenance-bundle completeness.

Local replay detection remains outside deterministic artifacts so browser history cannot change exported identities.

Visualization and playback

The Workbench introduces:

interactive Canvas waveform rendering;
wheel zoom;
drag panning;
selection ranges;
FFT spectrogram rendering;
256, 512, 1024, and 2048-point windows;
linear-frequency display;
logarithmic-frequency display;
local audio playback;
seeking;
looping;
and two in-memory A/B comparison slots.

Visualization settings are observational only and cannot modify generated PCM.

Derivative lineage

SPECTRAL v2.0.0 adds explicit derivative-lineage documentation.

Users can:

preserve an immutable source-render contract;
hash a later derivative locally;
declare the relationship between seed and derivative;
document authorship and transformation notes;
update derivation_graph.json;
embed lineage into the manifest envelope;
and rebuild the deterministic provenance package without pretending the derivative existed at seed-render time.
Local persistence and privacy

The browser application uses IndexedDB to retain:

completed jobs;
presets;
manifests;
contracts;
fingerprints;
canonical WAV files;
and render history.

Additional behaviour includes:

retention of the most recent 24 jobs;
eviction of older jobs before new writes;
in-memory fallback when local-file storage is unavailable;
reconstruction of PCM and ZIP data from stored canonical WAVs;
and continued playback and download when persistence fails.

All source material remains local.

The application creates no cookies and contains no production network client.

Browser test suite

A browser-native known-answer suite is included at:

APP/tests/index.html

Coverage includes:

SHA-256 standard vectors;
UTF-8 encoding;
canonical JSON;
decimal scaling and rounding;
deterministic PRNG vectors;
exact PCM16 WAV construction;
deterministic ZIP output;
engine-registry validation;
strict-mode image safety;
repeated-render equality;
seed and mutation identity changes;
determinism-mode separation;
manifest replay;
receipt-layer tamper rejection;
changed-source rejection;
lineage-manifest replay;
CSV, JSON, text, and binary golden vectors;
cancellable rendering;
browser-history isolation;
IndexedDB persistence;
actual page-reload persistence;
and absence of remote resource loads.
E8 research expansion

The E8/ collection adds new E8-inspired sonification generators, research inputs, demonstration renders, and supporting artifacts.

New generators include:

E8 triality fractal sonification;
Bullet Cluster E8 sonification;
M87 E8 fractal sonification;
simplified M87 sonification;
M81/Hubble sonification;
NGC 2525 sonification;
QEC v167 symbolic sonification generation;
and extended QSOL source preparation.

New research and demonstration material includes:

M81 Hubble WAV and MP3 renders;
M87 full and shortened E8 renders;
Bullet Cluster source imagery and audio;
NGC 2525 audio;
triality-standard renders;
qutrit-4D triality renders;
trinaural triality renders;
QEC v167 MIDI, WAV, JSON, and visualization artifacts;
collective-modes source audio;
molecular sonification examples;
terpene-entourage sonification;
astronomical source imagery;
and associated scientific reference material.
OMI-ISA experiments

A new OMI-ISA/ research area introduces:

OMI/E8 XOR-ring sonification;
deterministic XOR and rotation-state mapping;
E8 fractal-cosmovirus sonification;
Ouroboros-style feedback structures;
demonstration WAV files;
and symbolic engines later incorporated into the browser Workbench.
Photoacoustic sonification

A new PHOTOACOUSTIC/ project introduces a deterministic, simplified photoacoustic sonifier and music generator.

It models:

modulated light intensity;
absorption and thermal inertia;
tem...

Spectral Algebraics v1.0.2 — stable release

🎛 Spectral Algebraics v1.0.2 — Major E8 & Fractal Visual-Audio Update
Release date: 2025-11-09

What’s new:

Introduced enhanced E8 Fractal Power Engine with deeper golden-ratio modulation and expanded 3D lattice rendering.

Added 30 new audio-visual presets (bringing the total to 50) that leverage the new engine and realtime geometry mapping.

Upgraded visualization module: now supports dynamic camera motion, adaptive lighting and interactive fractal overlays during audio playback.

Improved performance across platforms: optimized the rendering pipeline and reduced memory footprint by ~40 %.

Added CLI build tools for customizing presets and visuals, with Python scripting examples for batch generation.

Updated documentation: clear “Getting Started” guide, new “Preset Workshop” section, and full visual asset gallery.

First “major” version bump (1.0 → 1.0.2) to reflect significant addition of features and polish.

Why this matters:
This release further blurs the boundary between mathematics, sound and visual art: by leveraging the exceptional symmetry of E8, fractal structures and signal synthesis we provide a truly novel playground for creators to “hear geometry and see sound”. Whether you’re composing a soundtrack, designing a visual installation or exploring generative audio-visual workflows, this version gives you richer tools.

How to get started:

Download the ZIP from the release assets on GitHub.

Open README.md and run the “Quick Start” demo preset named Quantum Drift 2.0.

Load the visual engine and explore the “Fractal Lattice” mode to see the E8 lattice morph in realtime with your audio.

Use the included CLI scripts (in /tools) to create your own custom preset pack or visual mappings.

Credits:
Designed & developed by Trent Slade (QSOL-IMC / LostSound Technologies) — inspired by years of research into symmetry, acoustics and visual geometry.

Known issues / future roadmap:

On lower-end GPUs the visualization may drop frames in high resolution—expected fix in v1.1.0.

Preset browser lacks tagging/filtering UI—future update will add “Tag & Search” capability.

Community contributions for new presets and visual mappings are welcome via GitHub issues or pull requests.

Links & resources:

GitHub repo: https://github.com/QSOLKCB/SPECTRAL

Documentation: [link to docs directory or website]

License: Apache 2.0

Spectral Algebraics v1.0.1 — E8 Audio-Visual Toolkit (Stability & Sync Release)

Spectral Algebraics v1.0.1 — E8 Audio-Visual Toolkit (Stability & Sync Release)

Release date: 2025-11-09
Repository: https://github.com/QSOLKCB/SPECTRAL
License: Apache 2.0
DOI: (to be minted via Zenodo integration)

---

Overview

This maintenance release finalizes the Spectral Algebraics toolkit as a stable, DOI-ready software companion to the published research paper.
It unifies the E8 Fractal Power Module, visualization system, and preset-pack architecture into a single reproducible framework.
The focus for v1.0.1 is synchronization: metadata alignment, file structure cleanup, and Zenodo integration reliability.

---

✨ What’s New & Improved

• Verified Zenodo ↔ GitHub integration with .zenodo.json, CITATION.cff, and proper ORCID metadata.
• Updated README and Release Notes to match QSOL IMC DOI conventions.
• Minor refactors for cross-platform audio handling and dependency clarity.
• Added checksum validation for demo assets (e8_demo.wav, preset CSVs).
• Improved documentation of preset parameters in E8_Spectral_Algebraics_PresetPack.md.
• Adjusted color gradients and shader interpolation for consistent 3D visual output.
• Clarified licensing (Apache 2.0) and citation instructions.

---

🧠 Purpose

v1.0.1 locks the Spectral Algebraics software release to the corresponding research record on Zenodo, ensuring reproducibility across QSOL IMC’s broader frameworks (UFF, QEC, AIMM).
It’s the stable archival version for long-term reference and collaboration.

---

🧩 Technical Details

• Core engine: Python 3.13, NumPy, Matplotlib, PyOpenGL.
• Visualization: OpenGL/GLSL real-time renderer + export to video frames.
• Audio: custom E8 mapping of frequency / amplitude modulation with φ-scaled spectra.
• Preset packs: 20 sound sets integrating ternary qutrit modulation and Coxeter-plane rotation.

---

🐞 Fixes

• Removed redundant files from previous upload; adjusted paths in build_summary.py.
• Patched Unicode errors in Windows CLI runs.
• Corrected audio playback offset for non-44.1 kHz systems.

---

🚧 Known Issues

• 4K export still in testing branch (dev-visual-enhancements).
• Linux users may need manual PyOpenGL install.
• High GPU load at >60 FPS visualization.

---

🚀 Quick Start

git clone https://github.com/QSOLKCB/SPECTRAL.git
cd SPECTRAL
pip install -r requirements.txt
python build_summary.py

python e8_fractal_power_module.py --demo

🧭 Next Steps

v1.1.0: introduce real-time WebGL frontend and Spectral Graph exports.

v2.0.0: full integration with AIMM and UFF for cross-domain semantic synthesis.

📚 Citation

If you use this software, please cite:

Slade, Trent (2025). Spectral Algebraics: Audible Geometry via E8-Inspired Signal Synthesis and 3D Visualization (v1.0.1) [Software]. QSOL-IMC. DOI: 10.5281/zenodo.XXXXXXX

Licensed under the Apache License 2.0.

Spectral Algebraics v1.0.0 – first official public release

Spectral Algebraics v1.0.0

Release date: 2025-11-09
Repository: https://github.com/QSOLKCB/SPECTRAL
DOI: (to be minted via Zenodo)

Overview

This first official public release of Spectral Algebraics marks the moment you can dive into the full audible-geometry audio/visual engine: built around the E₈ lattice-inspired mapping, signal-synthesis presets, 3D visualization pipelines, and demo assets.
If you’ve been waiting to explore algebraic manifolds through sound and image — your launch pad is here.

What’s New (Major Highlights)

• E8 Fractal Power Module integrated: mapping structure from the E₈ lattice into frequency/amplitude modulation.
• PresetPack-v1: 20 audio presets (industrial-metal / dark-country tonal palettes) with matching 3D visual assets.
• 3D Visualization Engine now supports real-time rendering (OpenGL/GLSL) of spectral geometry, with export to video frames.
• Demo Assets Included: e8_demo.wav, high-resolution visuals, example workflows.
• Documentation Upgrade: Added E8_Project_Summary.pdf, detailed parameter guide (E8_Spectral_Algebraics_PresetPack.md), CSV summary of presets.
• GitHub + Zenodo Integration Ready: Release tag v1.0.0 triggers snapshot archiving and DOI minting.

Improvements & Enhancements

• Optimised code paths for audio processing (reduced latency by ~30% on typical desktop setups).
• Refactored module architecture: e8_fractal_power_module.py now decoupled from UI layer for easier integration.
• Cleaned up dependencies: minimal external libraries, inline documentation for better “lean-is-holy” ethos.
• Enhanced visual shaders with additional colour mappings and export capability.

Bug Fixes & Tweaks

• Corrected waveform aliasing issue at high-frequency mod indexes.
• Fixed UI preset load error when running on non-SSD systems.
• Addressed mismatched sample-rate issue in demo audio for non-44.1 kHz systems.
• Minor documentation typos and parameter-naming consistency fixes.

Known Issues

• Visual export currently limited to 1080p; 4K export planned for next version.
• Linux build may require manual installation of PyOpenGL due to distro differences.
• Some presets assume stereo output; mono fallback may yield different spatial mapping.
• Real-time 3D rendering performance may dip on older GPUs (< 2015).

Migration Notes / For Existing Users

If you’ve experimented with pre-release code versions:

• Check the parameter names for the Fractal Power Module — some config keys were renamed (modIndex → mod_factor).
• Visual export directory default changed from ./export to ./renders; please update scripts accordingly.
• Preset file format v1 now uses JSON header (was plain CSV); legacy presets are still supported for fallback but conversion is recommended.

Getting Started

See the README.md in the repo root for installation instructions:

git clone https://github.com/QSOLKCB/SPECTRAL.git  
cd SPECTRAL  
pip install -r requirements.txt  
python build_summary.py  

Demo assets and usage guidelines are in the docs/ folder.
For full paper reference, see DOI: [your paper DOI here] (“Spectral Algebraics: Audible Geometry via E₈-Inspired Signal Synthesis and 3D Visualization”).

How to Cite

If you use Spectral Algebraics in your research or project, please cite:

Trent Slade (2025). Spectral Algebraics: Audible Geometry via E₈-Inspired Signal Synthesis and 3D Visualization (v1.0.0) [software]. QSOL-IMC. DOI: 10.xxxx/zenodo.xxxxx
Also include Apache 2.0 license: “Licensed under the Apache License, Version 2.0”.

Looking Ahead

What’s next on the roadmap:

v1.1.0 — 4K/8K visual export, VR integration, additional lattice mappings (E₇, E₆).

Beta build of “Live Performance Mode”: able to drive visuals in real time from external MIDI and audio input.

Community preset pack release: invite contributions, user-generated mappings.