Kunquat – a fresh take on old school trackers

Kunquat is a tracker-like music sequencer with strong emphasis on accurate notation of musical performance and expression. The key features to support this goal are continuous time axis and flexible instrument interfaces. Additional goals include support for non-Western musical scales and interactive music composition.

We are still at an early stage. Check us out on GitHub.


Kunquat 0.9.4


This release of Kunquat contains further performance improvements in audio rendering and adds support for improved consistency in the PADsynth and Karplus-Strong processors.

The PADsynth processor can now take advantage of the phase information contained by the source waveform it uses. This allows better control over the tone produced by the processor. Also, while in previous versions of Kunquat the base frequency was subject to interference that led to inconsistent sound, the samples generated by the processor now produce the base frequency reliably.

The Karplus-Strong processor now supports internal processing of the signal using a custom audio rate. This makes the processor usable with low system audio rates and helps control the consistency of the sound output with configurations sensitive to audio rate changes.

Finally, this release of Kunquat fixes several performance issues found in the previous release. Multithreaded audio rendering support has made a comeback with an improved lock-free implementation, and the filter and Freeverb processors have been optimised further.

Kunquat 0.9.3


This release of Kunquat focuses on usability improvements. The new user interface is now scalable and can switch quickly between custom style themes. Also, performance has been improved in many areas that have a direct impact on usability. Finally, there are some fixes and quality improvements to audio rendering.

The most notable part of the release is the new user interface that scales properly to a wide range of display resolutions. The default size is calculated based on physical resolution and size of display and should be fairly consistent across different systems. The user can easily create a custom theme with a different font size if the default scale does not fit their needs. Using custom themes also allows users to change the colour scheme of the entire user interface quickly, which may help them achieve the desired mood for music they are working on.

The performance optimisations improve the user experience in subtle but important ways. First, loading of Kunquat modules with large amounts of sample data is much faster now, which means less time for distraction when continuing work on an existing project. Second, the CPU utilisation of the user interface is significantly lower, which hopefully translates to lower power consumption and more time available for tracking on battery power. Finally, the sequencer and signal processing system have now been optimised for the most computationally demanding scenarios that typically result in peak system load.

This release of Kunquat introduces a new filter implementation based on code generously donated by Sami “Kraku” Koistinen. The new filter has improved stability at a wide range of cut-off settings and handles parameter changes more gracefully.

A couple of small changes, unfortunately, break compatibility with some old Kunquat functionality. The random sources used by the signal processors had to be altered, which means that older Kunquat modules might sound audibly different from this version onwards. Also, this release drops support for the arpeggio events as they were too cumbersome to use. A better solution will become available in a future release.

Last but not least, this release includes first bits of internal documentation that is also supported by additional online introductory material. The internal help page provides a quick reference for commonly used features in score editing.

Kunquat 0.9.2


This is a bugfix release that fixes some issues that came up along the release of 0.9.1. Also, the build procedure has been simplified slightly as the Fabricate build script is now included as part of the Kunquat release package.

Kunquat 0.9.1


This release of Kunquat contains some new signal processor features, bug fixes in the sequencer, some polish in the tracker interface, and a major preparation towards a stable file format.

The PADsynth now supports a resonance envelope for enhanced control of the audio spectrum of the synth. New processors include an early iteration of a looping device as well as a bitcrusher implementation.

The user interface of the tracker has improved in several small ways. The chord editing mode in the composition sheet is now optional, with a more traditional single-column editing mode as the default. Many number editing fields are now more convenient to use and allow more precision where needed. Finally, the sample editor now contains a tool for creating crossfaded loops.

The Kunquat file formats have gone through a major change that helps maintaining backwards compatibility once the file formats have been stabilised. Unfortunately, this change itself breaks compatibility with earlier Kunquat releases, but hopefully this is the last time such a change is required.

Finally, in order to ease adoption for third-party developers, this release introduces libkunquatfile, a C library that has a simple interface for loading Kunquat modules.

Kunquat 0.8.2


This release of Kunquat is mostly a maintenance release with bug fixes in audio rendering and user interface, small performance improvements, and some small new features.

The most important fixes include consistent application of composition random seed (previous versions would fail to set this correctly at the initial start of playback), generation of PADsynth waveforms in some corner cases, and user interface behaviour in the composition sheet with custom grids and hits. The most notable new features include support for channel muting and soloing in the tracker, and storing of default notation in modules. Finally, signal processing is now faster when rendering audio in short sections, and improved resource allocation allows increased polyphony with many complex instruments.



We are delighted to present the very first (to our knowledge) complete composition made with Kunquat Tracker: Reclaiming Myself (FLAC, YouTube)

Kunquat 0.8.1


This release of Kunquat introduces many new audio synthesis and signal processing capabilities, adds new ways to control instruments, improves usability, and brings a new polished look for the tracker. Although there are still missing key features and some details are subject to change, it is now possible to make full compositions of rich sound quality with the tracker.

The tracker now supports traditional sample-based synthesis with sample selection based on pitch, force and random chance. Other new software synthesis processors include Karplus-Strong string synthesis as well as the PADsynth algorithm. Other new signal processors include a simple delay and a range mapper that can be used to convert signals between different value ranges.

The tracker also features new ways of controlling instruments. The most notable is the hit interface that can be used to specify controls for drums and other non-melodic instruments. The instrument expression interface can be used to specify different ways to play a single instrument, which is especially useful with guitars and other similar instruments. The old note interface has also been extended with editors for user-defined scales and tunings.

In addition to new features in the synthesiser and sequencer, the tracker features several usability improvements. The composition sheet now supports standard clipboard operations as well as undo and redo. Also, testing of instruments is now easier with extended controls and the ability to select a subgraph of an instrument to be played inside the instrument editor. Finally, the user interface provides better feedback and handles common error conditions more gracefully.

Many things have also changed in the lower level. The Kunquat library now optimises many common signal processing patterns and supports multithreaded audio rendering, significantly reducing the computation time required for playback. Also, the Kunquat project has now migrated to Python 3 and the tracker interface uses the PyQt5 wrapper for accessing the Qt toolkit.

Finally, we have begun the effort of adding macOS support. While it is not yet stable on the platform and there are many rough edges in appearance, it should be possible to use Kunquat Tracker for playing Kunquat modules.

Kunquat 0.7.1


This release of Kunquat features major enhancements in composition editor, instrument and signal processing editors and the audio synthesis pipeline. Other enhancements include basic interactivity support and miscellaneous bug fixes. Despite all the work, Kunquat is still in an early stage of development. However, we encourage you to try the tracker out and let us know how you feel about it!

It is now possible to write compositions consisting of several patterns. All patterns of a composition are displayed together in the sheet, helping the user see the full structure of the composition. We have also reintroduced an improved grid that helps aligning event triggers in the time axis. The user can create customised grid layouts to support tuplets. Custom grids also support shuffled meter.

The audio synthesis editor has been extended to cover most aspects of instrument and signal graph editing. We have combined the concepts of generator and DSP into a new kind of signal processor. These processors can manipulate signals either separately or mixed together. This approach allows for more flexibility in the way audio is synthesised while keeping individual processors simple. Additionally, note pitch and force information is now explicitly produced inside the instrument signal processing system. Finally, the lowpass and stereo panning events have been replaced with more generic events that control user-defined potentiometers of instruments and effects.

To forward the support of composing game music, we have reintroduced editor for composition interactivity. The composer is now able to define environment variables that can be used to alter the way music is played. This provides a convenient interface for programmers who wish to control music playback without having to worry about the internal structure of the music.

Kunquat 0.6.2


In this release, the composition sheet returns with just enough support for creating small polyphonic tunes. Note and rest editing is supported through both mouse and keyboard. We have included a simple mixing graph editor together with limited support for instrument editing. You can also save and load your work using the new save and open buttons.

On the architectural side, we did some internal code refactoring as well as some small adjustments to APIs. As a result, the Kunquat library API now reveals default values of the rendering engine initialization set, removing the need to copy values over to tracker code manually.

We also did a complete renewal of the build process and started using the fabricate build tool. Therefore, you may wish to read the updated installation instructions even if you have built Kunquat before.

Kunquat 0.6.1


There has been silence for some time now when it comes to Kunquat releases. However, the development side has been active during this non-break. We have moved development to GitHub and upgraded our development process to match that.

Since the previous release we have rewritten the tracker several times to experiment with different threading and programming models. While we have now found a model that seems to work, the tracker has lost lots of features that need rewriting to match the new model. We will be returning old features back one by one in future releases.

While many old features were lost in the architecture upgrade, the tracker also gained some new features. The new release introduces an on-screen keyboard that visualizes played notes with intense twinkle. Keyboard jamming is now a recognized use case and the latency and performance of the tracker have been adjusted accordingly. The tracker includes a log window that show what Kunquat events are fired in the background. In addition, some performance measurements are displayed in the about window.

In addition to improvements in the tracker, we have also improved the API and architecture of the Kunquat C library. It is now possible to get an estimate of the duration of a Kunquat song without breaking the playback state. It is also possible to retrieve all fired events regardless of how many events are fired at once. We also added instrument controls that allow the user to rearrange their instruments more efficiently. Finally, we rewrote the sequencer code to give us more flexibility when implementing new features in the playback code.