Design Token Pipeline
26 JSON token files feed a Python codegen script that emits C++ constexpr headers, TypeScript modules, and CSS custom properties from a single source.
Engineering
Bellweather Studios Engineering
The engineering behind a multi-surface software platform - native C++20 plugins, web services, desktop tooling, validation infrastructure, and architecture visualization - built and maintained solo.
Platform at a Glance
A monorepo, built as one system.
Four production plugins shipping across four formats, five web applications, fifteen shared native modules, and a layered validation stack - all inside a single engineering system.
4
Production plugins
15
Native C++ modules
5
Web applications
4
Plugin formats (VST3/AU/AAX/Standalone)
~630
Test cases (C++ & Python)
16
CMake presets
11
CI workflows
26
Design token sources
System Architecture
How the pieces connect.
The platform is organized as a modular monorepo. Products, apps, shared modules, validation systems, and public-facing surfaces evolve inside one engineering system. For the product-facing side, see the company context and the plugin catalog.
Native Products
Pressure
Dynamics processor
Barometer
Metering & analysis
Ceiling
Limiter
Stratus
Convolution reverb
Web & Desktop
Website
Next.js 16 — product site
Weather Station
Electron 38 — desktop app
Cupola
Three.js architecture viz
Observatory
Validation & telemetry UI
Bellweather Cloud
Ground Control
Licensing & update API
Neon PostgreSQL
Serverless database
CloudFront CDN
cdn.bellweatherstudios.com
Upstash Redis
API rate limiting
Shared Platform
bw_dsp
DSP building blocks
bw_rt
RT-safe base classes & guards
bw_ui
UI components & visualizers
bw_core
Undo/redo, state, serialization
bw_stateflow
Reducer-driven state orchestration
bw_licensing
License validation
Validation & Observability
BPTS
Plugin testing suite (Catch2)
DawDreamer
Python integration tests
BOL Probe
Black-box binary validator
Playwright
E2E journey tests
Observatory
Runops & proof artifacts
Through-lines
Shared schemas, native modules, validation tooling, release workflows, and system documentation connect these surfaces. The design token pipeline, RT-safety enforcement, and contract boundaries keep them coherent as one system.
How It's Built
Four systems that shape everything else.
Each one cuts across the entire platform and defines how products, services, and tooling stay coherent.
RT-Safety Model
The audio thread never allocates, locks, or logs - enforced by RtGuard at compile time, validated with ASan, UBSan, and TSan. Production latency: ~62 µs/block on M4 Pro at 48 kHz/512.
Validation Layers
A 5-stage BPTS pipeline, DawDreamer integration tests, and Playwright E2E journeys cover native, web, and desktop surfaces.
Build & CI
IDE-agnostic CMake with 16 presets targeting universal binaries (ARM + Intel). Apple Developer ID signing, notarization, and Gatekeeper validation. 11 GitHub Actions workflows covering plugin validation, security baselines, drift detection, and release gates.
Enforcement Signals
What is actually enforced.
Tests, package boundaries, validation flows, and reproducibility rules guard the architecture at its seams. Public-facing versions of that validation story live in the Testing Suite and Research Notes.
Boundary tests
Orchestration routes are guarded by seam tests that prevent transport code from absorbing command logic. Contract schemas are shared across surfaces via workspace packages.
Security gates
Binary hardening tests verify compiler flags and symbol stripping. A security audit suite covers malicious state injection, buffer boundary attacks, and RSA credential verification.
Validation lanes
Daily contract smoke tests, weekly security and functional baselines, release-candidate gates, and production smoke tests - each running as named CI workflows.
Reproducibility gates
Environment pins, doctor checks, deterministic JUCE provisioning, and SHA-256 verified distribution artifacts reduce drift between dev, validation, and release.
Validation Pipeline
Five stages, progressive trust.
Each stage must pass before the next begins. Early stages are cheap and fast; later stages are exhaustive. The full pipeline is documented in the Observatory.
1
Characterize
Auto-discover modes, channels, parameter ranges across all plugin formats
2
Topology
Behavioral identity: latency, tail, silence, bypass coherence
3
Spec Validate
40/40 hardware-derived assertions: THD, IMD, noise floor, frequency response across 5 engine types
4
Gauntlet Fuzz
1,043+ assertions covering NaN, Inf, DC offset, denormals, and rapid parameter automation
5
Mutation
Inject faults into DSP path, verify detection, confirm kill rate before release
All pass → ShipAny fail → Reject
Stack
What it runs on.
| Layer | Technologies |
|---|---|
| Native | C++20, JUCE, CMake (16 presets), Catch2, LibFuzzer - VST3/AU/AAX/Standalone, universal binary (ARM + Intel) |
| Desktop | Electron 38, Vite, electron-builder |
| Web | Next.js 16, React 19, TypeScript, Tailwind 4, Zod |
| Data | PostgreSQL (Neon), Prisma 6 |
| Visualization | Three.js, React Three Fiber, React Spring |
| Infrastructure | GitHub Actions (11 workflows), AWS S3 / CloudFront, Vercel |
| Shipping | Apple Developer ID signing, notarization, Gatekeeper validation, S3/CloudFront warehouse, SHA-256 verification |
| Quality | ASan, UBSan, TSan, DawDreamer (174 integration tests), Playwright, BPTS (5-stage pipeline) |
| Tooling | Python (codegen, test automation), Bash (CI helpers, hooks) |
Public Surfaces
Live systems you can inspect.
These surfaces expose parts of the platform directly. The same thread continues through the blog and the Bellweather philosophy.
Ground Control
Licensing and update API. The operational side of the platform.
Open Ground Control →Cupola
Architecture visualization built with Three.js and React Three Fiber.
Open Cupola →Bellweather Studios
The product site. Where the engineering system meets the end user.
Open main site →GitHub
Public profile and links into the broader engineering story.
Open GitHub →Architecture In Motion
Serious systems are rarely static.
Boundaries, validation flows, and shell-versus-domain seams are explicit and test-enforced. Research notes, bug postmortems, and architecture documents track every structural decision as the system evolves.
The architecture keeps moving because the products and delivery surfaces keep moving. Legibility is the constraint — every decision gets documented, tested, or both.