Inspiration
One of the most frustrating things at a music festival is finding out that two artists you love are performing at the same time on different stages. You end up having to choose one and miss the other.
For festival organizers, avoiding these clashes is harder than it sounds. They have to work around stage availability, performance slots, headliners, and plenty of other constraints. But there's another thing worth considering: music taste.
Two artists don't have to make the same kind of music to attract people with similar tastes. Someone who listens to Kendrick Lamar might also be a Drake fan, while someone who enjoys Aphex Twin might also be into Boards of Canada. Looking at genres alone doesn't always capture these connections.
That got us thinking: what if festival schedules could be planned around cultural taste, not just genres and time slots?
That's what led us to build ClashDoctor using Qloo's taste intelligence.
What it does
ClashDoctor helps festival organizers find potential clashes in their lineup and create a better schedule without unnecessarily moving artists around.
Here's how it works:
- Upload a festival lineup as a CSV with the artists, stages, and time slots.
- ClashDoctor matches artists through the Qloo API and retrieves relevant cultural taste information.
- It compares artists performing at the same time across different stages to estimate how closely their tastes overlap.
- An interactive 18 × 18 heatmap makes these potential clashes easier to spot, with supporting taste-tag information available for inspection.
- Organizers can enter scheduling instructions in plain English, such as "Keep both headliners fixed and separate the most similar pairs."
- The optimizer uses those priorities to reduce the weighted clash penalty while avoiding unnecessary schedule changes.
- Organizers can review the proposed swaps, lock important performances, and decide which changes to keep.
ClashDoctor isn't trying to predict exactly how many people will show up at each stage. The similarity scores are estimates based on available taste information, not actual audience data. They're meant to help organizers make more informed decisions, not pretend we can predict every festivalgoer's behavior.
How we built it
We built the frontend with Next.js, React, TypeScript, and Tailwind CSS, and developed a Python-based engine to handle schedule optimization.
Qloo provides the cultural taste information behind the analysis. We use the available taste tags to estimate similarity between artists, then present those comparisons in an interactive heatmap so organizers can see where potential conflicts exist.
The scheduling engine was another important part of the project. Simply moving one artist might fix a clash but create a different one somewhere else. Our optimizer balances the estimated severity of clashes against the cost of moving artists, while respecting constraints such as locked performances and stage-slot capacity.
We also wanted organizers to give instructions without having to configure every constraint manually. We built a rule-based parser that converts supported plain-English instructions into optimization rules. It's deterministic, so it behaves predictably for the instructions it supports, although it doesn't understand every possible phrasing.
For the interface, we went with a warm, editorial look instead of the usual generic dashboard. Clean typography, a paper-like background, and vermilion accents help keep the focus on the lineup and its potential conflicts.
Challenges we ran into
One of the biggest challenges was figuring out how to use taste data responsibly. Two artists having similar tastes doesn't necessarily mean their audiences overlap. Without real attendance or audience movement data, we can't prove that a particular clash will cause fans to miss another performance. We decided to present the scores as estimates and let users inspect the available evidence instead of treating them as facts.
Another challenge was turning plain-English instructions into rules the optimizer could actually follow. We wanted the experience to feel simple for organizers without making the scheduling logic unpredictable. A deterministic parser helped with that, but it also meant being clear about which instructions the system currently supports.
Then there was the optimization itself. Fixing one clash can create another, and moving every artist around isn't a useful solution either. We had to balance reducing the weighted clash penalty with keeping schedule changes to a minimum and respecting performances that organizers wanted to lock.
Accomplishments that we're proud of
We're proud that we brought the whole process together, from Qloo-powered taste analysis and conflict visualization to schedule optimization and reviewing proposed changes.
We tested ClashDoctor on a curated lineup of 18 artists across three stages. The initial schedule had eight simultaneous clashes. The optimizer proposed four swaps and reduced the weighted optimization penalty from 8.709 to 0.044, which is approximately a 99.5% reduction.
We also wanted the tool to show its work rather than simply announce that it had found the best schedule. Organizers can inspect artist pairs, explore the available taste-tag evidence, and review the proposed changes. Any remaining conflict stays visible, too.
These results come from our test lineup and optimization setup. The 99.5% figure measures the reduction in weighted optimization penalty, not a proven reduction in real-world audience clashes.
What we learned
Building ClashDoctor taught us that cultural taste can offer a useful perspective that broad genre labels sometimes miss, especially when you're trying to make decisions involving multiple artists and audiences.
We also learned that producing a recommendation isn't enough. People need to understand why a system is making that recommendation and what information it's based on. That's why we made the comparisons inspectable and kept the scheduling constraints visible.
Most importantly, we learned to be careful about what our data actually proves. Taste similarity can help flag potential conflicts, but it can't tell us exactly how people will behave at a festival. Being clear about that limitation makes the tool more useful, not less.
What's next for ClashDoctor
There's plenty we'd like to build on top of the current version.
- Travel-time awareness: Factor in the distance between stages so the schedule accounts for how long attendees need to get from one performance to another.
- Multi-day scheduling: Support larger festivals with more stages, multiple days, and more complicated scheduling constraints.
- Personalized schedules: Let attendees create their own schedules based on their music tastes and find conflicts between artists they want to see.
- Better demand signals: Incorporate attendee voting and other pre-event feedback to understand which performances matter most to the audience.
- More flexible scheduling instructions: Support a wider range of plain-English priorities while keeping the resulting rules clear and predictable.
Ultimately, we want to help organizers put together schedules that work better for their festivals and give fans a better chance of seeing the artists they came for. ClashDoctor is our attempt to bring cultural taste intelligence and optimization together to make that process a little smarter.
Built With
- algorithms
- constraint-optimization
- curation
- data-visualization
- decision-support
- festival-tech
- heuristics
- latex
- linear-programming
- music-tech
- nextjs
- python
- qloo
- qloo-api
- react
- scheduling
- tailwind-css
- taste-intelligence
- typescript
Log in or sign up for Devpost to join the conversation.