GSOC 2027 Ideas

Student Project Ideas for Google Summer of Code 2027

This page lists the suggested tasks to build a 90 hour (small sized) a 175 hour (medium sized) or 350 hour (large) project for Google Summer of Code 2027. The ideas are already assigned to example projects, but you are encouraged to use them for building your own project adding your own ideas and make it suit perfectly to you, your skills and your time line.

If you are interested in applying to GSoC, read GSoC Advice before applying or getting involved. Only beginner contributors that are active members of the Mixxx community are accepted. If this is not the case yet, just say hello at https://mixxx.zulipchat.com and discuss your Ideas and discus cases with us.

Adding an AI infrastructure with cross-platform hardware acceleration

Typical AI applications in the DJ environment (STEM separation, music analysis) require very high computing power. However, as the commercial DJ software DJay Pro demonstrates, it is possible to perform these on modern laptop hardware in real time with high audio quality. This is made possible by the use of the dedicated Neural Processing Unit (NPU) or powerful Graphical Processing Units (GPU). As cross-platform software, Mixxx must be able to do this on:

• macOS (ARM M1/2 with Neural Engine NPU)
• macOS (x64 with GPU only)
• Linux with various NPU and GPU solutions from different manufacturers
• Windows with various NPU and GPU solutions from different manufacturers

Today, there is only one AI framework that supports full hardware acceleration across all these platforms, which is ONNX Runtime (onnxruntime.ai). In GSoC 2025, our student Anmol Mishra not only converted the widely recognized best STEM separation model DEMUCS to ONNX, but also benchmarked the achievable performance on different hardware: https://mixxx.org/news/2025-10-27-gsoc2025-demucs-to-onnx-dhunstack/ As successor, this project is about the integration of ONNX Runtime with ExecutionProviders for CPU (all operating systems), as well as at least one NPU or GPU acceleration solution into Mixxx. This project explicitly includes contributions to third-party projects, in particular to the package managers VCPKG and the Linux distribution Debian/Ubuntu, which Mixxx uses to integrate dependencies. A further aspect to handle is, that these libraries, as well as, the AI models itself are significiantly larger than the current dependencies that come with Mixxx. This requires the development of suitable solutions for the continuous code integration (CI) and for the distribution to the end users.

• Expected Outcome: ONNX Runtime with ExecutionProviders for CPU (all operating systems), as well as at least one NPU or GPU acceleration solution builds within the Mixxx environment. All changes on third-party code is contributed upstream to the particuar projects. Our ONNX DEMUCS model is executable in Mixxx.
• Skills: Knowledge of CMake, C++. Basic experience with contributing packages to package managers/Linux distributions.
• Possible Mentor: Jörg
• Difficulty: Medium
• Size: 350 h

AI music analyzer to detect Beats, Downbeats, Phrases

While Mixxx has a solid analyzer for beat/tempo detection, it is traditionally DSP-based, while the state of the art has moved to a hybrid approach of AI models that include some DSP routines for data pre-processing. Commercial DJ software with such AI music analyzers (DJay Pro, DJ Studio) demonstrates virtually always perfect beat recognition in DJ Medien's tests, even on challenging tracks with a variety of tempo changes. There are OpenSource music analyzer models available, nanmely https://github.com/JoergAtGithub/all-in-one (https://huggingface.co/spaces/taejunkim/all-in-one / https://taejun.kim/music-dissector/0427_justthewayyouare). While a science project with impressive results, this is a PyTorch model that cannot be used in a C++ project with support for any kind of acceleration hardware (it's based on the Demucs HT model above), also here an ONNX model is needed. This project is about building an infrastructure that allows Mixxx developers to optimize the analyzer, check the correctness of the results and generate production-ready ONNX models for the Mixxx DJ software in an automated workflow. In particular, the process when a user reports a track with incorrectly detected beats/downbeats/phrase-length/phrase-type and we need to optimize the model needs to be implemented. The main focus of this process is to ensure that the optimization for one track does not lead to worse recognition for other tracks.

• Skills: Knowledge of C/C++. Sound experience with the creation of AI models - preferably in ONNX.
• Possible Mentor: Daniel Schürmann
• Difficulty: Difficult
• Size: 175 h

Using The Harmonix Set to automatically evaluate the output of our music analyzers

The Harmonix Set https://github.com/urinieto/harmonixset repository contains human annotated labels for 912 Western Pop music tracks. This is a great base to benchmark current and future music analyzers in Mixxx. This project is about the automatic execution of the Mixxx Analyzer in a local development environment using all tracks of the Harmonix Set, that are available on the developer's local hard disk and generate a report that visualizes the deviations.

• Expected Outcome: A lightweight tool or script that can be executed out-of-the-box on Windows, macOS and Linux.
• Skills: Experience C++ and a common scripting environment like Python
• Music files: The Mixxx project cannot provide the music files, so the students must have a larger number of the music files listed in The Harmonix Set available themselves.
• Possible Mentor: Jörg
• Difficulty: Easy
• Size: 175 h

Graphical representation of BPM and Musical Keys in the waveform

Nowadays DJs depend more and more on visual information and metadata than on their ears and knowledge of music/tracks. Features that once were gimmicks or nice-to-haves became for a lot of DJs relying info, for others crucial. Information as BPM and Musical Key is displayed as an one-value-field showing the most occuring / average value. This project is about displaying the complete detailed information. Goals:

• BPM is now displayed as a single value, while the analysis results in a detailed overview of the beat positions, a consistent graphical representaion of the analysed BPMvalues (eg with use of Savitzky-Golay filter) as an optional overlay in the waveform. In this way the DJ will be able to see the BPM changes (Break, bridge, intermezzo) and the correct values in the waveform.

• Musical KEY is now displayed a single value while the analysis results in a detailed list of KEYS, eg refrain, bridge, break, instrumental break, intermezzo can have a different (not displayed) key. The DJ should have the option to view a graphical representation of the musical Keys in the waveform.

• As the BPM & Key representation in the waveform require a points in the waveform where the values change, these points should be showed on the waveform as POIs (Points of Interest): BPM-Change-Points & Key-Change-Points, the DJ should have the possibility to display these points, and eventually create hotcues, loops, beatjumps ... based on the position of these points.

• The data to create the graphical representation of BPM-curve, Musical KEY-curve and POIs needs to be saved in an interchangeable format for easy recreation on other systems, other CMRT (see other GSoC idea)

• Expected Outcome: A new visual representation of changing keys and BPMs.

• Skills: Experience C++ and user interface design, OpenGL

• Possible Mentor: Evelynne, Daniel

• Difficulty: Medium

• Size: 175 h

Auto completion for the Genre track metadata

Mixxx allows to assign a Genre to a track. This is currently a free text field that allows different spellings for the same Genre like Hiphop, Hip-Hop or Hip Hop. If you use all of these, you will not see all tracks when filtering. This project shall fix it.

We have started this project last year and did some important steps regarding requirement engineering and data modeling. We initially underestimated the required work, so we have decided to split it up. The first phase ended with a working prototype not merged into the Mixxx source code.

This year we like to revise the requirement and decision by testing the prototype and start over making use of the good foundation we have created.

The project may feature

• auto-complete the Genre when entering
• add multiple Genres to a track
• Backed up by an N-N genres relationship tree/net
• Genre Import from Discogs and MusicBrainz

It is up to the contributor to focus on one ore more topic that the project scope is kept small and the goal code get merged.

Last years project description

• Expected Outcome: A new auto completer for the Genre edit box
• Skills: Basic SQLite, Good C++
• Possible Mentor: Daniel Schürmann
• Difficulty: Medium
• Size: 90 h

Replace the outdated portmidi library in Mixxx by libremidi

Since the begining, Mixxx uses portmidi https://github.com/PortMidi/portmidi to implement the low-level MIDI communcation over USB. This cross-platform library is written in C and has a very limited feature set. With the upcomming of the MIDI 2.0 standard, Mixxx needs to switch to another libray for MIDI communication. The library of choice is https://github.com/celtera/libremidi, a cross-platform MIDI library written in modern C++. libremidi offers not only MIDI and MIDI 2.0 on all platforms, but also much more sophisticated support features for device detection and hot-plugging. As there are hundreds of MIDI mappings for Mixxx out in the field, the main point of this work is to achieve 100% compatibility. This project is not about using the new features of libremidi yet. The project should start with improving the automatic test cases for MIDI. Once this is done, the library change itself should be done.

• Expected Outcome: A fully compatible Midi implementation using libremidi, with compatibility proven by systematic tests
• Skills: Experience in C++ and accessing USB-MIDI devices
• Hardware: The Mixxx project cannot provide hardware. The student must own at least one USB-MIDI device, preferable a DJ controller.
• Computer: The student should have access to computers of at least two of the Mixxx supported platforms: Linux, macOS or Windows
• Possible Mentor: Jörg
• Difficulty: Medium
• Size: 175 h

Test our controller scripting libraries using Fuzzing

Mixxx contains several JavaScript libraries (like https://github.com/mixxxdj/mixxx/blob/main/res/controllers/midi-components-0.0.js) which allow a wide area of inputs and complex decision trees. Fuzzing seems to be a promissing method to detect flaws in these libraries. Googles https://github.com/google/oss-fuzz might be a good platform for such a setup.

• Expected Outcome: A working Fuzzing setup for all JavaScript libraries in the Mixxx controller code and the proper fix of some detect bugs
• Skills: Practical experience with Fuzzing and systematic software testing
• Possible Mentor: tbd.
• Difficulty: Medium
• Size: 175 h

Spin-Up/Spin-Down effect

Some Controller mappings have implemented a Spin-Up/Spin-Down to mimic the inertia of a turn table. This should be moved into the engine, so that it is accessible without a controller.

Part of the project is to record the spin up of a real turn table to get to know of the real acceleration curve and model this via software. You may also deal with the BPM sync feature, in a way that the spin up and down integrates faultlessly into a mix.

https://github.com/mixxxdj/mixxx/issues/8867

• Expected Outcome: A flawlessly working spin up and down effect accessible without controller
• Skills: Good understanding of sound processing, C++
• Possible Mentor:
• Difficulty: Medium
• Size: 350 h

Sharp Scratching

Currently crossfader changes are stretched on audio buffer time to avoid pop sounds. This is too long for some scratching styles. During this project you need to dive into the audio engine code find the code that is responsible for crossfading and make it independent from the audio buffer size.

https://github.com/mixxxdj/mixxx/issues/8899

• Expected Outcome: Cut type crossfader curve, suitable for scratching.
• Skills: Good understanding of sound processing, C++
• Possible Mentor:
• Difficulty: Medium
• Size: 175 h

Graceful recovery of controllers

If a controller is accidentally unplugged it has to be manually reconfigured, which is a party stopper. Mixxx should do it automatically. This project has two stages, fist behave like a real DJ: fix the issue but faster. So the the time of silence on the dance floor is kept short. The advance stage of this project is to implement real Hot Plug And Play. In order to that you likely need to touch the low level inside third party libraries.

The required controller can be provided on loan.

• Expected Outcome: Re-power the controller and continue to use it, on your target platform.
• Skills: Good understanding of the USB stack, C++
• Possible Mentor: Daniel Schürmann
• Difficulty: Easy / (Hot Plug And Play = Difficult)
• Size: 175 h / (Hot Plug And Play = 350 h)

Graceful suspend/resume support:

Mixxx should be able to continue playing after cumming back from the suspend state of the PC. This requires to detect the faulty state after resume and reinitialize the required parts of Mixxx.
https://github.com/mixxxdj/mixxx/issues/9099

• Expected Outcome: The sound output shall continue after sleep.
• Skills: Good understanding of the USB stack, C++
• Possible Mentor:
• Difficulty: Difficult
• Size: 175 h

Track suggestion feature

Mixxx shall suggest compatible tracks matching the current playing one. The feature may use existing meta data like bpm genre and key or tab online resources like LastFM and similar. https://github.com/mixxxdj/mixxx/issues/9328

• Expected Outcome: A dynamically changing list of suggested tracks.
• Skills: Experience with web services, C++
• Possible Mentor:
• Difficulty: Medium
• Size: 350 h

Support of RTMP and SRT as additional streaming protocols

Mixxx supports the Shoutcast and Icecast protocols for radio DJs, but not the streaming protocols used by platforms like Twitch, Youtube or Mixcloud.

• They use the RTMP protocol, which is also the most common input format for OBS.

• While RTMP is still the defacto standard, OBS reccomends to use SRT in future.

• Both protocols are implemented in FFMPEG, which is also used inside Mixxx for other purposes.

• Expected Outcome: A rock solid RTMP and SRT audio streaming output.

• Skills: Experience with FFMPEG and C++

• Possible Mentor:

• Difficulty: Medium

• Size: 350 h

Track encoding offset correction

Different codecs used to encode sound files introduce slight shift in the audio samples comparing the input with the output stream. This is no issue when you use always the same file and the same decoder. It becomes however an issue when the decoder is updated or replaced because than all stored metadata like waveform, beat-grids and cue points are no longer at the correct position. To protect against surprises Mixxx has unit-tests to verify that seeks inside that track do not introduce an offset and checks if the fist sound sample can be found at the expected time.

We have currently the issue that the Microsoft has introduced such a breaking change in Windows 11. https://github.com/mixxxdj/mixxx/issues/11094 In this project we need to investigate the issue and implement a fix so that the stored metadata of a user are still valid after an upgrade to Windows 11. As a project extension, this may also fix an issues that prevents us from moving to ffmpeg as an encoder wrapper where the underlying encoder library is no longer in control of us.

• Expected Outcome: No Beat-Grid offset after Windows 11 update
• Skills: Experience and C++
• Possible Mentor:
• Difficulty: Medium
• Size: 175 h (350 h for a general solution)

Address sanitizer facilities

Sometimes we have reports of hard to find crashes that my have to do with dangling pointer or other memory addressing issues. When hunting such a general environment that helps to find it would be great. However it is often not worth the effort for that particular issue and that's why we don't have it. This project is for contributors who have real experience with such memory sanitizer facility. We like to learn from you, what is reasonable to use and how we can integrate checks in out continuous integration. This may also something integrated in Mixxx itself to have more info users can provide in case of a crash.

• Expected Outcome: A new workflow how to deal with crasher bugs along with an improved set of tools.
• Skills: Experience with address sanitizer tools like ASAN or Valgrind and CMake
• Possible Mentor: Jörg Wartenberg
• Difficulty: Medium
• Size: 175 h

Something Else!

As always with Summer of Code, you aren't limited to the suggestions we've made here. If you've got a great idea for a project involving Mixxx then we're looking forward to hearing about it. We recommend spending more than a few days using Mixxx and participating in the community to develop a better understanding of areas where Mixxx could use improvement. Our issue tracker is full of feature requests and other ideas scattered throughout, so if you browse through it, you may find many more ideas for GSoC projects.

IMPORTANT: You should contact us first to get feedback if you're going to submit a proposal for your own project idea! We very rarely approve ideas students propose. If you're not already experienced with DJ equipment, we recommend sticking with one of the ideas above.