Any DJ with a downloads folder knows the problem: hundreds of tracks to review, a generic player, the file manager in another window, and one sloppy drag that leaves a duplicate where it shouldn't be. That's why I built Osky Audio Player, a lightweight player that does exactly one thing: listen to and sort thousands of tracks as fast as possible. You open a track, the player skims through it on its own, and once you know where it belongs you hit 1, 2 or 3: it stops, moves the file to its folder and plays the next one.
This is the project's first review: what it does, how it's built and what worries me.
What it is and where it stands
The repo is public and started on November 12 with two commits. The first one already ships the whole app: automatic point scanning, waveform, configurable destination buttons, move-and-next, undo, single instance, and installation as the default player on Linux. The second one adds cover art from the file's tags, an About window (F1), scrolling in the settings, the license and the README screenshots.
By the numbers: about 1,500 lines of Rust across six files and about 1,100 lines of UI (HTML, CSS and JavaScript). It's version 0.1.0 and it opens MP3, FLAC, WAV, AAC and M4A.

How the workflow goes
The core idea is the auto-scan. The track is split into 12 sections (configurable) and one second plays from a random point inside each, in order. In about twelve seconds you hear the intro, the build, the drop and the outro, which is exactly what you'd do by hand clicking along the timeline. When the pass ends, another one starts with new points. Touch the timeline or use the arrow keys and that track switches to manual; the next one starts in auto again.
Sorting is organized around root folders and destinations. In the settings you add a root (say, Warmup Electronico) and its destinations (Normal, Las que suenan). Any track inside that root, at any depth, shows those buttons, and the button order sets its key: 1 through 9, and 0 for the tenth. When you move a track, it goes straight to the destination together with its .lrc if it has one. When a subfolder runs out, the player jumps to the next one and, if the folder ended up empty, deletes it (you can turn that off).
While you listen you get the waveform (computed in the background, so you can spot the breaks and the drop before you hear them) and quality tags: FLAC and WAV show in green; for lossy formats, 320 kbps or more is green, 256 to 319 is yellow and anything under 256 is red. Low-quality MP3s give themselves away.
The architecture
It's a Tauri 2 app: a Rust backend and a plain JavaScript UI, no framework.
audio.rsis the engine: it drives rodio'sSinkand the scan. A thread checks every 20 ms whether it's time to jump to the next point.decoder.rsdecodes with symphonia directly and computes the waveform (RMS and peak across 1,200 columns) on a separate thread.library.rsbuilds the queue in natural order, reads metadata and cover art with lofty, and moves files or puts them back.config.rsstores roots, destinations and scan parameters in a JSON file.lib.rsexposes everything as Tauri commands that the UI calls throughinvoke.
The decisions worth talking about
A custom decoder. The Decoder bundled with rodio 0.20 doesn't tell symphonia the file size, and without it the FLAC reader can't seek; it also panics on some M4A files. For a player whose whole point is jumping around the track, that was a dealbreaker. The fix was to open the file with symphonia directly and plug it into rodio as a Source. If a format can't seek, there's a fallback: reopen the file when going backwards and discard packets without decoding them until it reaches the target. A damaged packet is skipped instead of stopping the track. And for fragmented MP4 files, which arrive with no duration in the header (Tidal downloads do this), the duration is measured by walking the packets.
Stratified sampling instead of pure randomness. Picking 12 random points across the whole track could leave you five seconds in the intro and nothing in the drop. Spreading them over sections guarantees coverage while keeping variety between passes:
fn generate(&mut self) {
let usable = self.duration - self.segment - 0.5;
if usable <= self.segment { return; }
let max_points = (usable / self.segment).floor().max(1.0) as u32;
let n = self.n_points.clamp(1, max_points);
let section = usable / n as f64;
let mut rng = rand::thread_rng();
for i in 0..n {
let start = i as f64 * section;
let jitter = (section - self.segment).max(0.0);
let offset = if jitter > 0.0 { rng.gen_range(0.0..jitter) } else { 0.0 };
self.points.push(start + offset);
}
}
Never overwrite. Before stopping playback, it checks whether a file with the same name already exists in the destination. If it does, the track keeps playing and the UI lets you move it as name (2), skip it or cancel. If the destination lives on another disk, rename fails with a cross-device error and it falls back to copy-and-delete. Empty-folder cleanup uses remove_dir, which fails if anything is left inside, so by design it can't take files with it, and it never touches the root or the destinations.
Details you notice when you use it. The waveform carries a generation counter: switch tracks before it finishes and the old computation is dropped instead of painting the wrong waveform. Cover art is requested separately so it doesn't slow down loading the track. The config is saved atomically (temp file, then rename). And thanks to the single-instance plugin, double-clicking another file loads it into the window that's already open instead of spawning a new one. On Linux, a script builds it, installs it under ~/.local without sudo, and registers it as the default player for MP3, FLAC, WAV, AAC and M4A.
What I like
The scope is cut cleanly. It isn't a library manager, it has no database and it doesn't try to compete with DJ software: it's a tool for one repetitive task, and every decision pushes toward that task. The "one key, move, next" loop removes exactly the friction that makes sorting take forever.
I also like that file safety was designed in from the start: check for conflicts before stopping, never overwrite, release the file before moving it (essential on Windows), and keep an undo. With a DJ's music, losing one file costs more than any feature is worth.
And the lean dependency diet: rodio only for audio output, symphonia with just the codecs it needs, a release profile with LTO, and a minimal set of Tauri permissions with a content policy that only allows local resources.
What worries me
- Zero automated tests. The most delicate part of the project (
move_track,undo_move,unique_target,prune_empty_dirs) is also the easiest to test with temporary folders. That's the first thing I'd add. - Undo lives in memory. Close the app and the history is gone. Also, one move covers several files (the track and its
.lrc); if putting them back fails halfway, you can end up with one on each side. - A corrupted config is lost silently. If the JSON can't be parsed, the app starts with the defaults. Since every volume change saves the config, the first adjustment would overwrite the damaged file and the roots and destinations would be gone. Keeping a copy of the unreadable file before moving on would fix it.
- Cross-disk moves aren't verified. Copy-and-delete is the right approach, and if the copy fails nothing gets deleted, but the copied file's size isn't checked before the original is removed.
- Cross-platform still to be proven. The code accounts for Windows and macOS (error codes, opening files from Finder,
.icoand.icnsicons), but the install script is Linux-only and there are no published binaries or a pipeline that builds them yet. - Minor details: the UI polls status every 80 ms instead of listening to events, and measuring a fragmented MP4's duration reads the whole file before playback starts.
What's next
What I'd do next, in order: tests for library.rs; a backup of the config when it can't be read; an on-disk move log so undo survives a restart; and a GitHub Actions workflow that builds the Linux, Windows and macOS installers and publishes them as releases, so any DJ can try it without installing Rust.
The project is free software under AGPL-3.0: if you use it, improve it or offer it as a service, the code stays open.
