Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/FormidableLabs/react-music

Make beats with React!
https://github.com/FormidableLabs/react-music

buses instrument lfo music react reactjs

Last synced: about 2 months ago
JSON representation

Make beats with React!

Awesome Lists containing this project

README 

        
[![Maintenance Status][maintenance-image]](#maintenance-status)



react-music





  Make music with React!




***



![http://i.imgur.com/2t1NPJy.png](http://i.imgur.com/2t1NPJy.png)



## Contents



- [Install](#install)

- [Get Started](#get-started)

- [Basic Concepts](#basic-concepts)

- [Instruments](#instruments)

- [Effects](#effects)

  - [Effect Busses](#effect-busses)

- [LFO](#lfo)

- [API](#api)

  - [Top Level](#top-level)

  - [Instruments](#instruments)

  - [Effects](#effects-1)

  - [Special](#special)

- [Known Issues & Roadmap](#known-issues--roadmap)

- [License](#license)



## Install



`npm install react-music`



## Get Started



The easiest way to get started is to clone this repo and run `npm start`. The demo song will be running at [http://localhost:3000](http://localhost:3000). You can open up the `/demo/index.js` file and edit your song there, using the API below as reference.



That said, you can import the primitives yourself and run your own build setup if you want.



## Basic Concepts



#### Song



The first thing you want to do is create a `Song` component. This is the controller for your entire beat. It takes a `tempo` prop where you specify a BPM, and an `playing` prop that configures whether the song should play right away, or wait to press the play button. Set up it like so:



```js



```



#### Sequencer



Your `Sequencer`'s are what you use to define a looping section. They take two props. The first `resolution` is the resolution of steps in your sequence array. This defaults to `16`, which is a sixteenth note. The second is `bars` which is how many bars the sequencer sequences before it loops. You can have multiple sequencers in your song, and the main Song loop is based upon the sequencer with the largest number of bars. Here is an example:



```js



  



  



```



Once you have a `Song` and a `Sequencer` component, you can add instruments to your `Sequencer`. Lets take a look at how these work:



## Instruments



#### Sampler



The sampler component is used to play audio samples. To use it, you must at very least provide two props, `sample` and `steps`.`sample` is a path to an audio file, and `steps` is an array of indexes that map to the steps available based upon the `resolution` and `bars` props of your sequencer. So if you wanted a 4/4 kick line, you would do this:



```js



  

    

  



```



You can also provide an array for a step, where the second value is a tuning, from -12 to 12.



#### Synth



The `Synth` component is used to create an oscillator and play it on steps, just like the `Sampler` does. To use it, you must provide two props, `type` and `steps`. Valid types are `sine`, `square`, `triangle` and `sawtooth`. The `Synth` component also takes an `envelope` prop, where you can specify your ASDR settings. The shape of the `step` prop is a bit different for the `Synth` component, as you must specify an array in the format of `[ step, duration, note || [notes] ]`. The `duration` portion specifies duration in steps. The `note` portion is a string of a musical note and octave like "a4" or "c#1", and for chords, can be an array of the same notes. This would look like:



```js



  

    

  



```



#### Monosynth



The `Monosynth` component is a `Synth` component, but it only plays one note at a time. It also has a `glide` prop that specifies portamento length. So if two notes overlap, the monosynth glides up to the next value on that duration. Check out how:



```js



  

    

  



```



## Effects



There are a ton of new effects added in 1.0.0. You can compose effect chains by wrapping effects around your instruments. Here is an example of how you would do that:



```js



  

    

      

        

      

    

  



```



### Effect Busses



If you want to define an effects bus, which is a set of effects that multiple instruments can send their output to, this is achieved with the `Bus` component.



First you want to create a `Bus` component, and give it an identifier:



```js



  



```



Next, wrap your bus with the effect chain you want to make available, similarly to the way you would wrap effects around an instrument. You generally want to do this with effects that have wet/dry control, and set the `dryLevel` to 0:



```js



  

    

  



```



Finally, to hook an instrument up to your bus, or several busses, add their id's to the `busses` prop on an instrument:



```js



  

    

  

  



```



## LFO



You know whats bananas? LFO. Thats what. You can use an oscillator to modify properties of your instruments and effects. This is done with the `LFO` component. Any node that you want to apply LFO to just needs it added as a child. Then you define a `connect` prop that returns a function that lets you select a parent AudioNode property to oscillate. See the following example.



```js



  

     c.gain}

    />

  



```



## API



### Top Level



---



#### \



**playing** (_boolean_) : Whether the song should start playing automatically



**tempo** (_number_) : Your song tempo



--



#### \



**bars** (_number_) : Number of bars in your sequence



**resolution** (_number_) : Step resolution for your sequence



### Instruments



---



#### \



**busses** (_array_) : An array of `Bus` id strings to send output to



**envelope** (_object_) : An object specifying envelope settings



```js

envelope={{

  attack: 0.1,

  sustain: 0.3,

  decay: 20,

  release: 0.5

}}

```



**gain** (_number_) : A number specifying instrument gain



**glide** (_number_) : Portamento length for overlapping notes



**steps** (_array_) : Array of step arrays for the notes to be played at



```js

steps={[

  [0, 2, "a2"]

]}

```



**transpose** (_number_) : Positive or negative number for transposition of notes



**type** (_string_) : Oscillator type. Accepts `square`, `triangle`, `sawtooth` & `sine`



--



#### \



**busses** (_array_) : An array of `Bus` id strings to send output to



**detune** (_number_) : A number (in cents) specifying instrument detune



**gain** (_number_) : A number specifying instrument gain



**sample** (_string_) : Path to an audio file



**steps** (_array_) : Array of step indexes for the sample to be played at. Accepts arrays for steps in order to provide a second argument for index based detune (in between -12 & 12).



--



#### \



**busses** (_array_) : An array of `Bus` id strings to send output to



**envelope** (_object_) : An object specifying envelope settings



```js

envelope={{

  attack: 0.1,

  sustain: 0.3,

  decay: 20,

  release: 0.5

}}

```



**gain** (_number_) : A number specifying instrument gain



**steps** (_array_) : Array of step arrays for the notes to be played at. Accepts in array in the `[ step, duration, note || [notes] ]` format.



```js

// single note

steps={[

  [0, 2, "a2"]

]}



// chord

steps={[

  [0, 2, ["c2", "e2", "g2"]]

]}

```



**transpose** (_number_) : Positive or negative number for transposition of notes



**type** (_string_) : Oscillator type. Accepts `square`, `triangle`, `sawtooth` & `sine`



### Effects



---



#### \



**bits** (_number_)



**bufferSize** (_number_)



**normfreq** (_number_)



--



#### \



**bypass** (_number_)



**delay** (_number_)



**feedback** (_number_)



**rate** (_number_)



--



#### \



**attack** (_number_)



**knee** (_number_)



**ratio** (_number_)



**release** (_number_)



**threshold** (_number_)



--



#### \



**bypass** (_number_)



**cutoff** (_number_)



**delayTime** (_number_)



**dryLevel** (_number_)



**feedback** (_number_)



**wetLevel** (_number_)



--



#### \



**Q** (_number_)



**frequency** (_number_)



**gain** (_number_)



**type** (_string_)



--



#### \



**amount** (_number_)



--



#### \



**bufferSize** (_number_)



**cutoff** (_number_)



**resonance** (_number_)



--



#### \



**algorithmIndex** (_number_)



**bypass** (_number_)



**curveAmount** (_number_)



**drive** (_number_)



**outputGain** (_number_)



--



#### \



**delayTimeLeft** (_number_)



**delayTimeRight** (_number_)



**feedback** (_number_)



**wetLevel** (_number_)



--



#### \



**bypass** (_number_)



**dryLevel** (_number_)



**highCut** (_number_)



**impulse** (_string_)



**level** (_number_)



**lowCut** (_number_)



**wetLevel** (_number_)



### Special



---



#### \



**fftSize** (_number_) : FFT Size value



**onAudioProcess** (_function_) : Callback function with audio processing data



**smoothingTimeConstant** (_number_) : Smoothing time constant



--



#### \



**gain** (_number_) : A number specifying Bus gain



**id** (_string_) : Bus ID



--



#### \



**connect** (_function_) : LFO property selection function



**frequency** (_number_) : LFO frequency



**gain** (_number_) : A number specifying LFO gain



**type** (_string_) : Oscillator type. Accepts `square`, `triangle`, `sawtooth` & `sine`



## Known Issues & Roadmap



- Currently only the 4/4 time signature is supported

- `Synth` presets need to be added

- Record/Ouput audio file

- Optional working mixing board alongside viz

- Sampler sample maps



## License



[MIT License](http://opensource.org/licenses/MIT)



### Maintenance Status



**Archived:** This project is no longer maintained by Formidable. We are no longer responding to issues or pull requests unless they relate to security concerns. We encourage interested developers to fork this project and make it their own!



[maintenance-image]: https://img.shields.io/badge/maintenance-archived-red.svg