Skip to content
XIONIA AUDIO StarShaper Join First Light

StarShaper for developers. The sound engine inside your experience.

License StarShaper’s engine for your own software. Design the instrument in StarShaper, expose the controls your application needs, and drive them from what is happening on screen.

Register developer interestHear the adaptive score

Commercial embedding and the high-level API are in development. Supported integrations and licensing terms will be announced.

Adaptive music

Signals in. Musical decisions out.

Your code reports what is happening, such as threat, health, speed, where the player is and what has just happened. A director turns those signals into the choices a composer would make, such as when a layer enters, how a transition lands and which notes answer an event. The instrument plays them.

Night Run

A score in D minor for one level of an interactive experience. Press play and the autopilot plays through the level, or take the controls.

From your software

0.05

Alert and Combat begin and end

1.00
0.25
Zone

Events

Intent

The director

  1. Explore
  2. Alert
  3. Combat
  4. Victory

Press play to hear the director at work.

    Your code Example API

      The score

      Section
      –
      Tempo
      –
      Chord
      –
      Key
      –
      Brightness
      –
      Space
      –

      Musical changes wait for the music. A hit waits for the next 16th, a sighting for the next beat, and a new section or an objective for the next bar line. A change of zone is physical, so the mix follows the player at once.

      Generated live in your browser. A small set of musical rules plays the director here, and the API calls are an example, not the final API.

      One experience, many parameters.

      What each input drives in this demo.

      set('threat')
      The section (Explore, Alert, Combat), with hysteresis · the bass’s drive and filter · how bright the pad and arpeggio are · the drum patterns
      set('health')
      A heartbeat in time with the score · darker chords below 0.4 · a darker pad and a mix that closes in
      set('speed')
      Tempo, eased a few BPM a bar · the arpeggio’s rate · hi-hat density · the bass rhythm, from driving to galloping
      state('zone')
      The mix’s filter, room and echoes · an underwater wobble and warble · an ambience of air, drips or bubbles
      trigger('spotted')
      A stinger on the next beat · Alert held for at least four bars
      trigger('hit')
      An impact on the next 16th · the music ducks and the pad flinches
      trigger('pickup')
      Chimes on the next 8th, taken from the chord that is sounding
      trigger('objective')
      A fanfare on the next bar line, resolving to D major
      intent('build')
      Four rising bars of snare, riser and opening filter, then a peak held on the dominant

      Higher-level control, with musical judgement.

      Say what is happening, or what you want next. The director handles the musical detail.

      • Changes land in time

        Musical changes wait for the next beat, bar or phrase. Physical ones, such as diving underwater, follow the player at once.

      • No flicker at the edges

        Leaving a state takes a lower value than entering it, and a section plays for a minimum length, so a value hovering at a threshold can’t make the score stutter.

      • Events answer in key

        Stingers are voiced from the chord that is sounding and placed on the grid, so a hit or a pick-up always belongs to the music.

      • It leads in

        Fills and risers lead into an escalation. Ask for a build and it rises over the bars you give it, then holds at the peak until the moment arrives.

      • It keeps things fresh

        A long stretch of combat gets a breakdown, the arpeggio changes shape from phrase to phrase, and the theme returns in new forms.

      • It talks back

        Section and beat callbacks let your visuals, haptics or interactions move with the score.

      In this demo, a small set of musical rules makes these decisions. StarShaper’s high-level control is in development; its features will be confirmed with the licensing details.

      How it works

      From sound design to software.

      1. Create

        Build the instrument, with its voices, evolving movements and musical relationships.

      2. Shape

        Choose what your software can change, such as threat, speed or the space around the player, and how the whole instrument answers each one.

      3. Connect

        Report the state of your experience and its events from your code. The director turns them into musical decisions, in time with the score.

      Your code

      Example API
      const score = await starshaper.load('night-run');

// Every frame: what is happening
score.set('threat', enemies.threatTo(player));
score.set('health', player.health / player.maxHealth);
score.set('speed', player.speed / player.runSpeed);

// States and one-off events
score.state('zone', 'cavern');
score.trigger('hit');

// Ask for an outcome, not the details
score.intent('build', { bars: 4 });

// Let the music move the experience, too
score.on('beat', () => hud.pulse());
      An example of driving an instrument from your update loop, not the final API. Supported engines and languages will be confirmed with the licensing details.

      Interactive experiences

      Music that reacts to player actions, pace and the state of the experience as it unfolds.

      Installations and playful apps

      Sound people can influence through movement, choices and interaction.

      Meditation and relaxation

      Evolving sound environments with gentle changes guided by the session and the listener.

      Platform

      Built to grow with what you make.

      The time invested in an instrument should keep paying off. StarShaper preserves each instrument’s editable structure, assets, mappings and module versions, so today’s discoveries remain material for future work.

      • Embed the engine

        Commercial integration for interactive experiences, apps and relaxation software, through a high-level API for shaping music and sound.

      • New ways into sound

        A module system for new synthesis mathematics and motion algorithms, including ideas developed with AI assistance.

      • Share what you shape

        Publish instruments that others can play, explore and develop, with their sound sources, controls and credits carried together.

      A module SDK, creator publishing, an API for external assistants and commercial embedding are in development. Availability and compatibility will be announced.

      Developer interest

      Put StarShaper inside your experience.

      Register to hear about engine licensing, the high-level API and developer programmes as they open.

      Your details will be used for StarShaper engine licensing and developer news. We’ll email you a link to confirm your address first. You can unsubscribe at any time. Read how we handle your details in our privacy notice.

      Developer questions

      When can I license the engine?

      Commercial embedding and the high-level API are in development. Licensing terms, supported platforms and integrations will be announced; register your interest to hear first.

      Who is building StarShaper’s engine?

      Xionia Audio, the pro audio division of Xionia Ltd. Xionia’s founder, Stephen Ankelen, is a hands-on technical director and senior developer with more than 30 years’ experience building production software, and he designs and codes the engine himself, as part of a team of experienced senior developers. His background includes enterprise software engineering for aerospace, extensive work integrating AI into real-world systems, and a long history in music technology and audio engineering. We’re building the engine, its API and the support around it for the long term.

      Which real-time engines and platforms will be supported?

      Supported engines, platforms and languages will be confirmed with the licensing details. Tell us what you build with when you register, and it will inform the order we work in.

      Do I need StarShaper to design sounds for my application?

      You’ll design instruments in StarShaper, choose the controls your application needs, and drive them from your code. The exact workflow will be documented before release.

      Is the adaptive score on this page the StarShaper engine?

      No. It’s generated live in your browser. A small set of musical rules plays the director, and the API calls beside it show the shape of the high-level API in development, not its final form.