How user feedback shaped Kine, from a bouncing-note experiment in the browser to a VST with its own synth engine.
Kine started with something we had seen in Max some time before: bouncing objects triggering notes. The idea stayed with us. There was something appealing about watching a movement become a musical event, then hearing the pattern change as the objects kept moving.
We wanted to try making something around that idea ourselves. The first version was HTML, running in a browser. There was no plan for the instrument Kine would eventually become. At that point, the thing we wanted to explore was the bouncing notes.
Once people started using it, their feedback became the basis for what we built next. That continued through the first VST and the addition of a synth engine that hadn't been part of the original MIDI-only plan. Kine took shape through that exchange: people trying a version, telling us about the experience, and helping us decide where to take it.
The idea we saw in Max
The starting point deserves to be acknowledged. We didn't invent the idea of bouncing objects making notes. Seeing it in Max gave us something to be curious about and a reason to start experimenting.
What interested us was the connection between the visible movement and what you could hear. A note has an event attached to it. You can watch something approach a boundary and anticipate the sound, even if you don't know exactly how the next few seconds will unfold. When several objects are moving, their separate paths begin to form a phrase together.
That is a different starting point from entering a sequence of notes. You can spend time with the behaviour before deciding what the music is going to be. The movement gives you something to react to, and listening gives you a reason to change it.
We didn't need a complete product idea to begin following that connection. We needed a version we could run and spend some time with. That became the browser experiment.
The HTML version
Before there was a plugin to install, there was a web version. HTML gave the experiment somewhere to exist outside Max and somewhere for us to develop our own version of the idea.
At this stage, the distance between having an idea and trying it mattered more than where the finished thing would live. A browser version was enough to explore the relationship between the bouncing objects and the notes. It also meant there was something other people could try before we'd committed to making a VST.
That distinction is easy to lose when looking back at a finished plugin. The early version wasn't simply a smaller copy of the current one. Some of the decisions that now seem central to Kine hadn't been made. In particular, we weren't setting out to build a synth. The plan was for MIDI: generate the notes and let another instrument make the sound.
There is a clear appeal to that arrangement. People already have instruments they like. A note-generating tool can sit beside those instruments and give them a different source of musical material. That was the role we initially imagined for Kine.
User feedback changed the direction
The first users were friends of Noem. Sharing the experiment with them brought other ways of using it into the process. Until then, the person making the decisions was also the person who knew why everything was there. Users approached it without that background, and their feedback gave us a view of Kine we couldn't get from building it alone.
Their feedback became the basis for how Kine progressed. We had an idea to start from, but the direction after that came from people trying it and telling us about the experience. That continued as the browser experiment became a plugin.
There wasn't a finished specification waiting to be implemented through all these stages. Sharing the work was part of finding out what to build. The distinction matters because it would be easy to describe the current instrument as if every part had been intended from the beginning. It wasn't.
The bouncing notes remained the centre of it. What changed was the instrument around them: how someone could approach the idea, hear it and use it in their own setup. Having other people involved made those questions more concrete than they could be while the project was only a personal experiment.
Writing the first VST
The next step was writing the first VST. That brought the idea into the environment where people were already making music, alongside their tracks and instruments.
The MIDI-only approach still made sense as a starting point. Kine could produce notes while another plugin supplied the sound. The two parts had separate jobs, and the choice of instrument could completely change what the same movement suggested musically.
But user feedback kept changing what we were building. The significant addition was synthesis for the balls themselves. An experiment that had been intended to send MIDI became an instrument that could make its own sound as well.
That changed the first encounter with Kine. With an internal synth, the movement and its sound could be experienced together inside the plugin. Choosing and routing another instrument could come later. It also brought sound design into the experiment: the character of the voices became something to explore alongside the patterns they were playing.
Adding sound without losing the MIDI idea
The synth grew out of user feedback, rather than the original brief. Giving the balls their own synthesis was a substantial change to what Kine was, but the earlier MIDI idea still had a place.
In the current instrument, synthesis is organised into four parts. You can use those internal sounds, send MIDI to another instrument where your host supports it, or drag a captured phrase into a MIDI track. The MIDI FX version also keeps the original approach available: Kine generates the notes and an instrument after it provides the sound.
Those options reflect the way the project developed. The internal engine makes Kine something you can open and hear. MIDI lets the same underlying idea travel into other instruments and other parts of a session. Adding one didn't require discarding the other.
Looking back, the biggest change to Kine came from listening to the people using it. We started with a way to generate notes. Their feedback helped turn it into an instrument with its own sound, while keeping the original MIDI approach available. That wasn't a direction we had mapped out at the beginning.
Kine began with an idea we'd seen and wanted to explore. Its users helped us work out what it could become.
Try what we make next
If you'd like to beta test what we make in the future, write to us at hello@noemaudio.com. Tell us a little about the music you make and which DAW and operating system you use. We'd like to hear what works for you, what gets in the way and what you find yourself wanting to do next.