u/AshR75

Dots on GitHub in case you need to yank some confs: https://github.com/rccyx/osyx

Requirements: Electricity (maybe)
Cost: $0

lol, hope this convinces you to move off

windows could never 🥱

This is Debian btw on Hyprland, if you need to take some confs, here
https://github.com/rccyx/osyx

GitHub: https://github.com/rccyx/osyx

Built a perception-aligned terminal audio visualizer in Rust that prioritizes physical weight over raw FFT data.

I've always used CAVA, you're probably using CAVA too. So is everyone. The video below is Lookas (left) vs CAVA (right), both on defaults.

The problem with it is that the raw FFT data always felt nervous and disconnected from how humans actually perceive audio, especially on certain material.

It uses logarithmic binning and quadratic gravity, which is great for responsiveness but lacks inertia.

I wanted bars that feel like real objects responding to sound, not merely pixels jumping to a height coordinate.

So this runs on different algos.

Mel-scale filterbank instead of linear FFT bins. Derived from psychoacoustic research. Energy maps to perceptual equal intervals, not mathematical ones, so bars sit where the sound feels heavy. Every transient hits at full resolution immediately, decay uses an exponential moving average. 0 latency on the upstroke & physical weight on the downstroke.

Spring-damper model with lateral energy diffusion. Bars have mass, they accelerate, decelerate, and release with inertia. Neighboring bands bleed energy into each other the way physical acoustics does, so the spectrum moves as one fluid wave instead of independent twitching columns.

Couldn't find anything that does this, so I built it.

Rust-based so you can cargo install lookas and you're in.

Type 1 mic / 2 system audio / 3 mix / q quit.

Full breakdown, math, comparison, and configs @ source: https://github.com/rccyx/lookas

I'm a chronic terminal user & an average music enthusiast, studio headphones on & something playing in the background whenever the rig is up, and tbh most terminal visualizers feel like watching a sterile data readout with absolutely no soul.

Bars snap to a height, gravity pulls them down, and...they repeat. It looks reactive, sure, but it feels completely disconnected from the music. CAVA etc, you might be familiar with.

I built Lookas around the idea that raw FFT output has nothing to do with how humans actually perceive sound. The human ear is non-linear & our pitch resolution and loudness sensitivity don't map to linear bins and basic gravity falloff. And...I don't listen to deep house all day, sometimes I might go classical, etc, it won't feel so natural having a visualizer bouncing up and down like a 90s disco floor.

So, I had to build something that aligns those pixels with biological reality and physical weight. Human hearing aligned physics so the bars feel like real sound propagating through air.

Here's a summary of how it works:

For the frequency mapping it uses a Mel scale so bar density actually matches how our ears resolve pitch. For the animation, the bars are driven by a second order spring damper system, which gives them real mass AND momentum AND organic decay tail.

Adjacent bars also share energy, so instead of acting like isolated digital spikes the spectrum moves together as one continuous fluid wave. For perceptual loudness it uses continuous percentile tracking for dynamic range and A weighting to balance frequencies proportional to what you actually hear, NOT what a meter measures.

To make this feel immediate and fluid the underlying engine is built for low latency and zero visual stutter. The audio capture runs on its own dedicated thread and continuously fills a ring buffer. The render loop reads from that buffer independently always grabbing the latest audio window. They never wait on each other, zero stalling on the capture side. On the render side the entire frame is built in memory first and then written to the terminal in one contiguous shot.

There's no line by line output and no partial redraws. The screen only fully clears on a resize event and every other frame just overwrites in place.

This yields zero flicker even pushing 60+ FPS in dense Unicode.

Deps are cpal and parec for audio capture and rustfft for the heavy lifting and crossterm for the terminal backend.

Both PulseAudio and PipeWire work flawlessly.

If you want to try it out it requires zero configuration out of the box and will automatically try to hook into your system audio or fallback to your mic.

You can install it with cargo.

For the source code, documentation, math used, demo videos (with sound) and a detailed breakdown of how it compares to standard tools like CAVA, etc @ the repo:

https://github.com/rccyx/lookas

Sup guys, I made a perception-aligned terminal visualizer that prioritizes physical weight over raw data (different from how CAVA & others work)

It's Rust-based so you can install it with cargo

You can toggle your inputs with 1 for mic, 2 for system audio, or 3 for the mix. Press q when you're done

(also configurable).

Src, details, configs, full thorough breakdown:

https://github.com/rccyx/lookas