TarsosDSP: pure-Java audio processing algorithms you can read

Pure Java with no dependencies, and that is the whole point

The README describes TarsosDSP as a Java library for audio processing, aiming to provide an easy-to-use interface to practical music processing algorithms implemented as simply as possible in pure Java and without any other external dependencies.

That last clause is the design decision everything else follows from. There is no JNI, no native library, no audio backend you have to install. It also means the library tries to hit a stated sweet spot: capable enough to get real tasks done, but compact and simple enough to serve as a demonstration of how DSP algorithms work.

That second framing is worth taking seriously, because it changes what you are evaluating. Plenty of audio libraries are better at the job. If your requirement is production-grade resampling or a low-latency output callback, TarsosDSP is not the answer. If your requirement is understanding or extending a pitch detector in a language you already know, the lack of dependencies is the feature.

It is GPL-3.0 licensed, written in Java, and the source is compatible with Java 11. It has 2,192 stars and 498 forks, the fork count being high relative to the stars, which fits a library people vendor into their own projects. The repository is not archived and the last push was on 2026-06-18.

Three pitch detectors, an onset detector and DTMF

The algorithm list in the README is the real specification of the library. For pitch detection it implements YIN, the McLeod Pitch Method, and a Dynamic Wavelet Algorithm Pitch Tracking algorithm. There is also a percussion onset detector.

For signals rather than musical content, there is a Goertzel DTMF decoder, which is the algorithm you want for detecting telephone keypad tones because it is efficient at a small set of known frequencies.

The rest covers transformation: a WSOLA time stretch algorithm, resampling, filters, simple synthesis, some audio effects, and a pitch shifting algorithm.

Having three pitch detectors side by side is more useful than it first appears, because pitch detection is genuinely ambiguous and each method fails differently. YIN is autocorrelation-based and robust. The McLeod method uses a normalised square difference function and is generally sharper. The dynamic wavelet approach is time-domain and fast. Being able to switch between them against the same audio is a better way to find out which suits your material than reading about it.

The project is also citable, which is unusual and useful. The README points to a paper, TarsosDSP, a Real-Time Audio Processing Framework in Java, by Joren Six, Olmo Cornelis and Marc Leman, published in the Proceedings of the 53rd AES Conference in 2014, and asks that academic users cite it. A BibTeX entry is provided.

Adding the dependency means using the author's own repository

This is the part that catches people out, so it is worth stating directly. The artifacts are published to a repository hosted by the author at mvn.0110.be, not to Maven Central. You have to declare that repository before the dependency will resolve.

For Gradle:

repositories {
    maven {
        name = "TarsosDSP repository"
        url = "https://mvn.0110.be/releases"
    }
}
dependencies {
    implementation 'be.tarsos.dsp:core:2.5'
    implementation 'be.tarsos.dsp:jvm:2.5'
}

And for Maven:

<repository>
  <id>be.0110.repo-releases</id>
  <name>0110.be repository</name>
  <url>https://mvn.0110.be/releases</url>
</repository>

The two artifacts split along the same line the repository tree uses. `core` holds the algorithms with no audio I/O at all, so it is usable in a headless test or a server-side pipeline. `jvm` provides JVM audio I/O, which is what lets the library open a microphone or a sound file. Depending on both is right for an application, and depending on `core` alone is right when you already have audio arriving through some other route.

The current published version in these snippets is 2.5.

Examples double as the documentation

The examples are organised so that running one is the fastest way to understand a feature. Building the examples produces a shadow jar that carries both the graphical and command line tools:

gradle shadowJar
java -jar examples/build/libs/examples-all.jar

Started with no arguments, the jar opens a window listing the graphical examples. Started with an example name and a file, it runs that command line example. The README gives a concrete invocation, `feature_extractor` on an audio file, which extracts pitch from it, and you can list everything available with the `list` argument.

The repository tree matches the three-module split the README describes: `core/src/main/java` for the main functionality, `examples/src/main/java` for the applications, and `jvm/src/main/java` for audio I/O. There is also an `AGENTS.md` and a `LICENSE` at the root, and a `.github/` directory holding the Gradle build workflow that produces the status badge.

A dedicated `examples/` directory with a `build.gradle` of its own is a good sign for a teaching-oriented library, because it means the examples are built and kept working rather than rotting in a folder nobody compiles.

The credits section is the honest engineering record

The acknowledgements are unusually detailed, and they document the actual provenance of each algorithm rather than a generic thank-you list. It is worth reading because it tells you which implementations are ports and which are original.

The onset detector is based on a VAMP plugin example by Chris Cannam, following a paper on drum source separation using percussive feature detection and spectral modulation. The YIN implementation used the YIN paper and the GPL-licensed aubio implementation as references, and Matthias Mauch contributed a FastYin implementation that uses an FFT to calculate the difference function, which the README says makes the algorithm up to three times faster. The Average Magnitude Difference pitch estimator was implemented by Eder Souza and adapted for the library.

The McLeod method follows A Smarter Way To Find Pitch by Philip McLeod and Geoff Wyvill. The dynamic wavelet algorithm follows Larson and Maddox, with the implementation based on Antoine Schmitt's DYwavelet library, released under the MIT licence, which the README notes is compatible with GPL. WSOLA follows Verhelst and Roelands, with SoundTouch by Olli Parviainen as the reference implementation. The FFT implementation is JTransforms by Piotr Wendykier, described as the first open source multithreaded FFT for the JVM.

Noting that a MIT-licensed dependency is GPL-compatible, and spelling out which parts are adapted rather than written from the paper, is the kind of care that makes a GPL library trustworthy. The project also documents its own history: developed at University College Ghent, School of Arts between 2009 and 2013, and supported from late 2013 by University Ghent, IPEM.

Building from source, and what the versioning tells you

The source builds with the Gradle wrapper, and the README's three commands are the whole procedure:

git clone --depth 1 https://[email protected]/JorenSix/TarsosDSP.git
cd TarsosDSP
./gradlew build

The `--depth 1` flag is worth keeping in mind if you intend to contribute. A shallow clone gives you no history to branch from, so you would need to fetch more depth before making commits. For building and experimenting, it is simply faster.

The tree carries `gradlew` and `gradlew.bat` alongside `build.gradle` and `settings.gradle`, so the wrapper is checked in and the build does not depend on a system Gradle install.

On versioning, the repository listing shows no tagged releases, and the dependency snippets pin 2.5. A library that has been in use since at least 2009 and whose paper is from 2014 is doing something right in terms of staying put. The 2,192 stars and 498 forks, with 113 open issues, suggest an active project with a large body of users rather than a neglected one, and the 2026-06-18 push date is recent.

Editorial conclusion

TarsosDSP earns its place when you want to see how an algorithm works as much as when you want to call it. Every method it ships is implemented in pure Java with no external dependencies, which means you can open the source for any of them and read the maths in the same language you are writing your application in. Pitch detection is the strongest area, with YIN, the McLeod method and the dynamic wavelet approach all present, and FastYin available as an FFT-based variant the README credits as up to three times faster. The practical caveat is packaging: the artifacts come from a repository at mvn.0110.be rather than Maven Central. Start with the `core` module and the command line examples, since running `feature_extractor` on a file is the fastest way to see what the library actually does.

Frequently asked questions

Official sources

1. Issues
2. JorenSix/TarsosDSP on GitHub
3. License: GPL-3.0
4. Project website
5. README