Copyright (c) 2026 Randall Rosas (Slategray). All rights reserved.

🐉 LeylineFilterMini

A fixed-chain desktop voice gate for clean monitoring, simple controls, and fewer audio-routing headaches.

---

Quick Launch

Use the fastest safe path when you want to see the mini app instead of negotiating with a plugin cabinet.

LeylineFilterMini is currently an early scaffold with the fixed GUI, Tauri command surface, fixed processor state, and validation suite in place. Real CPAL stream capture, persistence, parameter smoothing, and live visualizer telemetry are still on the roadmap.

Release binaries will be published from the GitHub Releases page once the real audio path and smoke tests are complete. Until then, build locally:

npm install
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER=rust-lld npm run tauri build

The Windows executable is written to:

target/release/leylinefiltermini.exe

---

Quick Start In 60 Seconds

Clone it, install it, run the checks, then open the desktop shell.

git clone git@github.com:slategraydev/LeylineFilterMini.git
cd LeylineFilterMini
npm install
npm run lint
npm run test
npm run build
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER=rust-lld cargo test --manifest-path src-tauri/Cargo.toml -- --test-threads=1
npm run dev

If your Windows shell already resolves link.exe to the Visual Studio linker, the rust-lld override may not be needed. In this repository’s current shell, link resolves to /usr/bin/link, which is charming in the way a trapdoor is charming.

---

What Is LeylineFilterMini

A plain-English explanation for the developer who wants the signal path without the migraine.

LeylineFilterMini is a focused desktop audio utility built around one fixed voice-processing chain:

Input Device
  ↓
Expander
  ↓
RNNoise
  ↓
Gain
  ↓
Output / Monitoring

The point is not to become a modular plugin playground. The point is to open the app, pick devices, keep monitoring visible, and adjust three always-present processors. No add menu. No drag grid. No tiny remove button hiding in the shrubbery.

---

Feature Overview

Current implementation map, with honest labels so nobody mistakes scaffolding for shipped DSP.

LeylineFilterMini/
├── Fixed Processing Chain
│   ├── Expander              Implemented scaffold, clamped config updates
│   ├── RNNoise               Implemented scaffold, 48000 Hz requirement marker
│   └── Gain                  Implemented scaffold, clamped output gain
│
├── Desktop Shell
│   ├── Device selectors      Implemented UI, backend placeholder devices
│   ├── Monitoring toggle     Implemented command and UI state
│   ├── Metrics panel         Implemented polling and placeholder backend metrics
│   ├── Oscilloscope view     Implemented visual placeholder
│   ├── Spectrum view         Implemented visual placeholder
│   └── Tonality view         Implemented visual placeholder
│
├── Rust Backend
│   ├── MiniSignalChain       Concrete fixed fields, fixed process order
│   ├── Tauri commands        start, stop, monitoring, metrics, devices, config, state
│   ├── Module metadata       Stable fixed IDs for UI compatibility
│   └── Tests                 Construction, routing, latency, defaults
│
└── Validation
    ├── Frontend              TypeScript, Vitest, Vite build
    ├── Rust                  cargo test, clippy
    └── Desktop bundle        Tauri build

---

Capability Matrix

A compact status table, because optimism is useful and surprise is not.

Area	Status	Notes
Fixed three-section GUI	✅ Implemented	Expander, RNNoise, Gain render in order.
Add, remove, reorder removal	✅ Implemented	The UI has no modular workflow.
Tauri command surface	✅ Implemented	Fixed commands return stable state and metrics.
Config update routing	✅ Implemented	Configs route by fixed module ID.
Disabled module latency	✅ Implemented	RNNoise reports 0 latency when disabled.
Metrics polling	✅ Implemented	Frontend polls near 30 fps.
Live CPAL audio streams	🚧 Planned	Real device capture and output are not wired yet.
RNNoise native model path	🚧 Planned	Current RNNoise behavior is a scaffold.
Parameter smoothing	🚧 Planned	Needed before real-time audio use.
Session persistence	🚧 Planned	MiniAppConfig is still pending.
Live visualizer telemetry	🚧 Planned	Current oscilloscope and spectrum are placeholders.
Signed installers	🚧 Planned	Required before a polished public binary release.

---

Developer Installation

Build the project from source when you want full control over the local environment.

Install dependencies:

npm install

Run the full desktop development shell:

npm run dev

Run the frontend only, useful when you want Vite without the Tauri window:

npm run dev:web

Run frontend checks:

npm run lint
npm run test
npm run build

Run Rust checks on this Windows shell:

CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER=rust-lld cargo test --manifest-path src-tauri/Cargo.toml -- --test-threads=1
CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER=rust-lld cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets -- -D warnings

Build the desktop app:

CARGO_TARGET_X86_64_PC_WINDOWS_MSVC_LINKER=rust-lld npm run tauri build

---

Architecture

The repo keeps the frontend, Rust core, and Tauri shell separated enough to avoid a headache later.

Click to explore the current module tree

LeylineFilterMini/
├── src/
│   ├── App.tsx                 Fixed desktop shell and module controls
│   ├── App.test.tsx            Fixed processor and monitoring tests
│   ├── hooks/useEngine.ts      Tauri command hook and polling
│   ├── styles.css              Responsive fixed-chain styling
│   └── types.ts                Frontend engine and module types
│
├── src-tauri/
│   ├── src/lib.rs              Tauri commands and app state
│   ├── src/main.rs             Desktop entry point
│   ├── src/core/chain.rs       MiniSignalChain implementation
│   ├── src/core/modules/mod.rs Retained processor scaffolds
│   └── src/core/types.rs       Backend configs, metrics, and metadata
│
├── tasks/todo.md               Execution tracker
├── TODO.md                     Product implementation checklist
└── .github/workflows/ci.yml    Repository validation workflow

---

Roadmap

The next cuts are deliberately practical.

• Wire real CPAL input and output streams into the fixed chain.
• Move audio-thread configuration updates through prepared state and smoothing.
• Implement real RNNoise integration or a documented substitute path.
• Persist device selection, monitoring, running state, and three module configs.
• Feed live audio telemetry into oscilloscope, spectrum, and tonality views.
• Add signed Windows installers and GitHub Release automation.
• Smoke test monitoring with physical output and virtual cable routes.

---

Contributing

Contributions should keep the mini app mini.

• Keep the production chain fixed as Expander, RNNoise, Gain.
• Do not reintroduce runtime module add, remove, reorder, drag, resize, or registry browsing behavior.
• Keep CPAL callbacks allocation-free after startup setup.
• Add focused tests before broad builds.
• Prefer small cuts, because audio regressions enjoy dramatic entrances.

---

Legal And License

LeylineFilterMini is copyright (c) 2026 Randall Rosas (Slategray). All rights reserved.

This repository is currently private and proprietary unless a separate license file is added. The early scaffold is provided for development and evaluation. Real audio use should wait for CPAL stream wiring, parameter smoothing, and device smoke testing.

Built by Slategray.
Fixed chain, fewer knobs, calmer debugging.

Report a Bug · Request a Feature · Releases