In this blog post, I want to share how we collaborated with the Cologne University of Applied Sciences (German: TH Köln) to support a new generation of developers exploring C++ and Qt. As a TH Köln alumnus who began his journey at Qt, I was honored by the opportunity to return and contribute. Alongside the course story, we’re highlighting the work of five student teams — sharing their ideas, the applications they built, and what they learned along the way.
The collaboration centered around a new course introduced by Prof. Dr. Jan Salmen, titled Engineering Desktop Applications with C++ and Qt (EDA). It took place during the winter semester of 2024 and was limited to 40 participants. As a newly introduced course covering a wide range of software development topics, we didn’t anticipate an overwhelming response. However, interest exceeded expectations, and all available spots were taken in no time.
Students at our faculty may encounter various programming languages throughout their studies, such as Java, Matlab, and Python. Courses in C/C++ are also offered, but Ulla Derichs and me intentionally wanted to expand this to include application development with Qt. I am familiar with this framework from many years of professional experience and so I was convinced that we can provide highly practice-oriented knowledge in a new course. It was a great coincidence that a student (Lucas Haupt), to whom I had mentioned our plans, connected me with Dennis. The collaboration was fantastic, and the participants definitely benefited from the joint effort. I was grateful that Ulla managed to bring two more motivated students on board as assistants — Meike Goergens and Moritz Ackermann.
~ Jan Salmen
To bring the course to life, Ulla provided C++ lecture videos while I focused on Qt learning material. We supported the students with weekly Q&A sessions, giving them space to ask questions and dive deeper into the topics. Their main assignment was to develop a music player application, either individually or in teams of up to three.
As the course came to a close, it was time for the participants to reveal their projects. Each team tackled the assignment in their own way, and the results were impressive. Let’s dive into their final creations:
TotallyNotSpotify: A Qt-Powered Audio Player That Turns Sound Into Visual Art
When I started working on this project, my goal was simple: create a music player that covers all the essential features while keeping the interface clean and functional. But as I got deeper into the process, I realized I wanted more than just a standard audio player — I wanted to experiment with visualizing sound in ways that make listening to music a more immersive experience. That’s how TotallyNotSpotify came to life.
At its core, TotallyNotSpotify delivers every essential function you’d expect from a modern audio player. You can load and play audio files, create playlists, reorder tracks with intuitive drag-and-drop, and control playback with shuffle and repeat options. The app also supports dark and light modes, letting you tailor the interface to your mood. Beyond these basics, the player goes the extra mile by fetching detailed metadata via the Last.fm API. When available, you’ll see not only cover art but also additional information like the artist, album, genre, and more. Clicking on a track title or artist seamlessly redirects you to the corresponding Last.fm page for a deeper dive into the music.
Building on that foundation, I incorporated spectrum analysis using the KissFFT library, so you can also visualize the frequencies of the song. But during my exploration for even more creative ways to visualize audio, I encountered the fascinating world of Oscilloscope Music.
Oscilloscope Music is a genre where the music essentially creates its own visuals. The same signal that energizes your speakers is fed into an analog oscilloscope, which draws glowing green lines on screen. Here, the left and right audio channels map directly to the horizontal and vertical axes, respectively. Carefully crafted parametric functions then generate synesthetic geometries that blend a retro lab aesthetic with futuristic vibes. The real challenge lies in creating visuals that not only complement the sound but also enhance the listening experience—demanding novel approaches to synthesis, mixing, and mastering.
While exploring this concept, I was fascinated by the work of Jerobeam Fenderson and Hansi3D and their album N-Spheres. Their music is designed to create stunning oscilloscope visuals when played through an appropriate system. After purchasing the album, I wanted to see how these visuals would appear in my audio player, so I implemented modes that display the oscilloscope-style renderings their music produces. In addition to the waveform and spectrum displays, I developed two Oscilloscope modes: one that shows individual dots — each representing a sample from the audio signal — and another that connects these points with smooth lines. The Oscilloscope Dots mode illustrates how every sample’s amplitude (from both left and right channels) translates into a vibrant visual point, while the Oscilloscope Lines mode simply connects all samples in a frame with straight lines, forming structured yet dynamic shapes.
Team 02
by Pia Patza and Natascha Wolf
When we set out to develop our audio player, we wanted the design to be minimalistic and intuitive, yet stylish. We chose a light-themed design with black accents to highlight key features.
Our modular structure allowed us to implement all the essential features you’d expect from an audio player – including adding, deleting, looping, volume adjustment, and more. On top of that, all data is automatically saved as JSON and loaded each time the player starts, so you can pick up right where you left off.
Our personal highlights though are the mini player and sleep timer features. The mini player enables the user to use their screen size more efficiently while still interacting with the app. The sleep timer automatically stops the player after a pre-set amount of time, with the remaining time showing on the screen.
Overall, we really appreciate the opportunity to share our experience with you, as it was our first time interacting with Qt and C++, and we very much enjoyed expanding our toolkit.
EDAmamePlayer
Vinyl records have a timeless charm—the ritual of placing a needle on a spinning disc, the warmth of analog sound, and the carefully designed album covers. But what if we could bring this experience into the digital world? That’s the idea behind our music player, which combines the aesthetics of a turntable with the convenience of modern MP3 playback.
The concept was sparked by a real record player one of us owns, including its digital display, which became a defining element of our UI. We quickly settled on the idea of a vinyl-inspired music player, blending nostalgic design with interactive digital features. After successfully implementing audio playback, our first major milestone was cutting the album cover into a circular shape and making it rotate—a small but satisfying achievement that set the foundation for our interface.
What we’re proud of:
-
A Spinning Digital Vinyl – The record updates dynamically with each track and rotates as the song plays.
-
A Functional Tonearm – Instead of a progress bar, the needle moves along the record, indicating playback position.
-
Retro Digital Display – The blue-screen interface presents song details in a vintage style.
-
Playlist Management – Users can create, load, and delete playlists, as well as add, remove, and rearrange tracks—all seamlessly integrated into the UI via a dockable widget.
Working with C++ and Qt, we encountered a few hurdles. The model/view architecture initially gave us some headaches, but after several refactors, we developed a solid system using different models and proxy models to handle sorting, moving, and shuffling tracks efficiently. The core feature of our player—the spinning record and moving tonearm—was another major challenge. Getting it to a point where it felt intuitive and natural took time. In the end, users can pick up the tonearm and move it manually to skip through a song, which was incredibly rewarding to implement and adds a unique interactive element to the experience.
We’re proud of the final result and hope it brings a little vinyl magic to digital music!
Group 06
by Milan Jezovsek and Markus Heming
At first glance this might look like a classic Audio-Player … well it kinda is. It has all the basics functions every other player has such as playing songs, changing loudness, creating playlists, managing your library and so on. But we also implemented a neat little integration which enables the user to download audio from lots of different websites directly into their library.
Markus: I think one of my highlights of this project was when our code just worked after like an hour of coding without testing in between as “that just works without any problems” was usually never the case. One thing I actually really liked about Qt was signals and how they work. It's like you connect two things, and from then on, they are able to communicate and listen to each other. You need to get into it, but once you do, it's easy to use.
Milan: For me, the best part of this project was learning more about actual software architecture. When I learned about writing code in the past, it was always more about programming paradigms, specific languages, or scripting-related topics. This was the first project in which I felt like actually understanding the importance of software design. Which doesn't mean this project is well-architected, but it taught me a lot.
Check out the application here: https://github.com/MilanJzo/eda-mp3
nimamp - A Modern Take on a Classic Music Player
by Jonathan David Kron and Leo Kling
When we were searching for ideas, we wanted to capture the essence of a classic: Winamp. But instead of just cloning it, we wanted to add a modern twist – think a Spotify-esque queue and playlist management system, a customizable UI, and lyrics support.
nimamp stands out with features such as providing the classic feel of Winamp, paired with modern usability; lyrics support, using either an open-source API or our own Rust-powered API scraping Genius; a customizable UI and modern queue & playlist management for seamless track organization.
Coming from Rust, we approached Qt and C++ with skepticism, and let's just say we had quite the journey.
Initially, we tried using Qt Quick, thinking it would be the easiest way to get a modern UI running. But documentation was sparse, and something as simple as displaying a list of elements was a battle. Lists felt overly optimized for touch interfaces, which wasn't ideal for our desktop-first app. Once we switched to Qt Widgets, things felt much better. More structured, more familiar, and more suited for a traditional desktop application.
Some things in C++/Qt just didn't make sense to us coming from Rust. Why on earth do pop_back() and pop_front() on QLists not return the element they remove? Small quirks like this made the experience unnecessarily frustrating.
Throughout this process, ChatGPT was an invaluable resource. Whether it was helping us understand obscure Qt documentation, debug strange C++ behaviors, or even just brainstorming potential solutions, having an AI assistant sped up our development and reduced some of the frustration. While it didn't replace proper documentation or hands-on coding, it definitely made the journey a little smoother.
While Qt Widgets proved to be a solid framework for desktop applications, the documentation and some of C++'s oddities left us frustrated at times. That said, nimamp is here, and we're proud of what we built!
Check out the application here: https://github.com/nichilum/nimamp
Final Words
We were pleasantly surprised by the high level of interest the new course attracted. The fact that we could only accommodate a third of the interested students highlighted not only the importance of C++ and Qt but also the strong interest in programming graphical user interfaces.
As we all know, the best way to learn programming is by doing it. So we tasked the students with creating a music player app. They started by implementing the standard functions of a music player and, as a final challenge, added a unique feature. The goal was for the best app to win a prize at the end.
We were impressed by the resulting collection of music player apps, each with its own distinctive design and valuable features, which made selecting the best one quite a challenge. Personally, I would love to use these apps, or even better, have a single app that combines all their features to create the ultimate Super Duper Music Player.
One learning we gained from the course is that our Q&A sessions we offered seemed almost redundant in an era where tools like ChatGPT and CoPilot serve as excellent programming aids.
~ Ulla Derichs
Evaluating such amazing projects in just a single session is never perfect—we ranked 'winners' and handed out prizes, but innovation doesn’t fit neatly into a scorecard. What mattered most was that everyone pushed boundaries, took creative risks, and made it an event to remember—for all the right reasons.
from left ro right: Dennis Oberst, Milan Jezovsek, Markus Heming, Mirco Tornow
