Welcome to our tech articles and guides directory. Here we write about topics pertaining to ShoggothOx, including graphics programming, cellular automata, warp tables, bilinear interpolation, formal verification with Verus, music visualizer history, and building high-performance web applications with Rust and WebAssembly.
An introduction to specifications, proof code, and SMT solving in Verus, followed by the actual bounds proofs behind ShoggothOx's four-neighbor flame lookup table.
ShoggothOx makes fire by averaging four neighbouring pixels and subtracting one. This post takes the flame kernel apart: why sampling below makes brightness rise, why the subtraction is what guarantees darkness, and what separates the twelve modes.
How ShoggothOx grew a palette-matched environment, particles, and echo aura around its 3D surfaces; why music drives continuous motion clocks instead of positions; and how a malformed fullscreen triangle made the whole environment disappear on a Pixel.
Exploring real-time frequency spectrum analysis in ShoggothOx, Hann windowing to prevent spectral leakage, and our optimized fixed-point Q14 Cooley-Tukey radix-2 FFT implementation in Rust.
How ShoggothOx turns categorical visualizer settings into a discrete configuration space, finds an exact-length route through curated anchors, and expands it into deterministic transitions that change only one parameter per state.
How a six-second dead patch survived several GPU fixes, why replaying the indexed buffer exposed two competing state schedulers, and how authoritative playlist playback restored audio dynamics without disabling the playlist's own mutations.
Why an indexed palette that works as a 2D framebuffer can turn into featureless white paint on a curved surface, how geometry-derived lighting separates material from emitted audio activity, and why an eight-turn spiral needs eight texture cycles to stay visually active.
Why a low-resolution simulation buffer benefits from linear filtering while its palette lookup table must remain nearest-neighbor, how one shared sampler coupled those policies, and why fixing a real shader bug did not fix an unrelated mesh.
A deterministic video frame stayed rough after three rendering fixes. Tracing the active mode revealed an eight-turn NearRing with only 16 polygon edges per revolution and a camera sized for much smaller meshes. Here is how tessellation budgets and projection math fixed it.
Why latitude-longitude texture mapping crushes 160 texture columns into a shimmering pinwheel at a sphere's poles, and how scaling each ring's UV span by sin(φ) — the classic sinusoidal equal-area projection — removes the pinch in one line without reopening the texture seam.
Why a live simulation buffer must show a seam when wrapped around a sphere or torus, the mathematics of mirrored wrapping (and why a reflection is always continuous), and before/after comparisons from ShoggothOx's deterministic render pipeline.
Tracking down the hard-edged tearing artifacts on ShoggothOx's 3D sphere and ring display modes: how a missing depth buffer turns visibility into “last triangle wins,” with frame-by-frame before/after comparisons from a deterministic re-render.
An interactive math playground illustrating how overlapping orthogonal sine waves generate Lissajous patterns. Features dual phase-drift and electron beam sweep controls on a simulated analog CRT oscilloscope.
An example-driven guide to bilinear interpolation math, visualizing how values are scaled across 2D coordinate spaces, and detailing how ShoggothOx offloads this work to GPU hardware samplers.
Exploring how precomputed translation tables convert complex trigonometric spatial warping functions into efficient single-pass array lookups, with an interactive visual feedback loop demo.
An introduction to Cellular Automata, comparing Conway's discrete Game of Life with ShoggothOx's continuous, heat-diffusion CA model, and explaining how it is scaled to millions of cells using WebGPU shaders.
Explore the history and evolution of real-time audio visualization, detailing feedback loop mechanics, retro PC demoscene roots, Winamp AVS, and classic visualizers of the 90s and 2000s.
A deep dive into compiling Rust code to WebAssembly, using hardware-accelerated shaders for color palette lookup, and designing high-fps browser rendering pipelines.