A visualiser for Sonic Pi 3

Every since Sonic PI had a transparency mode added (not available on the Raspberry Pi versions) I have been interested in adding a Visualiser graphics display as a backdrop. The built in Scope can give attractive displays, but I wanted something with a bit more colour, and which covered the whole screen. I did some experiments with the iTunes visualiser which added quite a nice backdrop, but only with a significant delay between the audio and the fluctuations of the display. The recent arrival of Sonic Pi 3 allowed for further possibilities, because it enabled the use of OSC messaging. I did a trawl of the internet and came across a promising looking processing sketch which produced a pattern which reacted to incoming audio. It was written several years ago and was only monochrome based. I played around with this, upgrading it to work on the latest version of Processing, and added some colour. I experimented with adding further  basic shapes to the display (it originally used an ellipse primitive, set up to give concentric circles, which could also be driven to produce a star burst effect). I added rectangles and star shapes and experimented with off-setting these as the program ran, and also with using more than one basic shape at the same time. I then added some code so that the sketch could receive incoming OSC messages sent from Sonic Pi 3, which could be used to control various parameters for the shapes, such as stroke width, colour, and offsets on the screen. I added further flexibility such as the ability to rotate the shapes, and to shift the whole display vertically and horizontally across the screen. The final setup works well with Sonic Pi 3, which controls the patterns both with the Audio signal it produces, and also with OSC messages which can be sent to the sketch display code. These can be timed appropriately with the musical content.

The code for the sketch is shown below

//Visualiser for use with Sonic Pi 3 written by Robin Newman, September 2017
// based on an original sketch https://github.com/andrele/Starburst-Music-Viz
//Changes: changed to full screen, updated for Processing 3, added colour, added rectangle and star shapes
//added OSC input (from Sonic Pi) to alter parameters as it runs, removed slider inputs.
//input OSC:   /viz/float       updates STROKE_MAX, STROKE_MIN and audioThresh
//             /viz/pos         updates XY random offset values (can be zero)
//             /viz/col         updates RGB values
//             /viz/shapes      sets shapes to be used from S, E and R (or combinations thereof)
//             /viz/stardata    sets data for star shapes
//             /viz/rotval      turns rotation of shapes on/off
//             /viz/shift       turns XY shift across screen on/off
//             /viz/stop        initiates sending stop all signal back to Sonic Pi port 4557

import ddf.minim.analysis.FFT;
import ddf.minim.*;
import oscP5.*; //to support OSC server
import netP5.*;

Minim minim;
AudioInput input;
FFT fftLog;

int recvPort = 5000; //can change to whatever is convenient. Match with use_osc comand in Sonic Pi
OscP5 oscP5;
NetAddress myRemoteLocation; //used to send stop command b ack to Sonic PI

// Setup params
color bgColor = color(0, 0, 0);

// Modifiable parameters
float STROKE_MAX = 10;
float STROKE_MIN = 2;
float audioThresh = .9;
float[] circles = new float[29];
float DECAY_RATE = 2;
//variables for OSC input
float [] fvalues = new float[5]; //STROKE_MAX, STROKE_MIN,audioThresh values
int [] cols = new int[3]; //r,g,b colours
int [] positions = new int[2];// random offset scales for X,Y
int [] stardata = new int[4];// data for star shape, number of points, random variation
int shiftflag = 0; //flag to control xy drift across the screen set by OSC message
int two = 0; //variable to force concentric shapes when more than one is displayed
String shapes = "E"; //shapes to be displayed, including multiples from S,E,R
int rotval =0;
int xoffset = 0,yoffset = 0;
int xdirflag = 1,ydirflag = 1;

void settings() {
  fullScreen(P3D);
}

void setup() {  
  frameRate(60);
   myRemoteLocation = new NetAddress("127.0.0.1",4557); //address to send commands to Sonic Pi
  minim = new Minim(this);
  input = minim.getLineIn(Minim.MONO, 2048); //nb static field MONO referenced from class not instance hence Minim not minim

  fftLog = new FFT( input.bufferSize(), input.sampleRate()); //setup logarithmic fast fourier transform
  fftLog.logAverages( 22, 3); // see http://code.compartmental.net/minim/fft_method_logaverages.html

  noFill();
  ellipseMode(RADIUS); //first two coords centre,3&4 width/2 and height/2
  fvalues[0]=1.0;
  fvalues[1]=0.0;
  fvalues[2]=0.32;
  cols[0] = 255;
  cols[1]=0;
  cols[2]=150;
  positions[0] = 50;
  positions[1]=40;
  stardata[0]=2;
  stardata[1]=4;
  stardata[2]=3;
  stardata[3]=5;
  /* start oscP5, listening for incoming messages at recvPort */
  oscP5 = new OscP5(this, recvPort);
  background(0);
}

void draw() {
  background(0);
  pushMatrix();
  //calculate changing xy offsets: shiftflag set to 0 to siwtch this off
  xoffset += 10*xdirflag*shiftflag;
  yoffset += 10*ydirflag*shiftflag;
  if(shiftflag==0){xoffset=0;yoffset=0;} //reset offset values to zero if shifting is off
  //reverse directions of shifting when limits reached
  if (xoffset >displayWidth/3){xdirflag=-1;}
  if (xoffset < -displayWidth/3){xdirflag=1;} if (yoffset > displayHeight/3){ydirflag=-1;}
  if (yoffset < -displayHeight/3){ydirflag=1;}
  //transform to new shift settings
  translate(displayWidth/2+xoffset, displayHeight/2+yoffset); //half of screen width and height (ie centre) plus shift values

  //optional rotate set by OSC call
  rotate(float(rotval)*(2*PI)/360);
  
  //get limits for stroke values and audiThreshold from OSC data received
  STROKE_MIN=fvalues[0];
  STROKE_MAX=fvalues[1];
  audioThresh=fvalues[2]; 
  //println("fvalues: ",STROKE_MIN,STROKE_MAX,audioThresh); //for debugging

  // Push new audio samples to the FFT
  fftLog.forward(input.left);

  // Loop through frequencies and compute width for current shape stroke widths, and amplitude for size
  for (int i = 0; i < 29; i++) {

    // What is the average height in relation to the screen height?
    float amplitude = fftLog.getAvg(i);

    // If we hit a threshold, then set the "circle" radius to new value (originally circles, but applies to other shapes used)
    if (amplitude < audioThresh) { circles[i] = amplitude*(displayHeight/2); } else { // Otherwise, decay slowly circles[i] = max(0, min(displayHeight, circles[i]-DECAY_RATE)); } pushStyle(); // Set colour and opacity for this shape circle. (opacity depneds on amplitude) if (1>random(2)) {
      stroke(cols[0], cols[1], cols[2], amplitude*255);
    } else {
      stroke(cols[1], cols[2], cols[0], amplitude*255);
    }
    strokeWeight(map(amplitude, 0, 1, STROKE_MIN, STROKE_MAX)); //weight stroke according to amplitude value

    if (shapes.length()>1) { //if more than one shape being drawn, set two to 0 to draw them concentrically
      two = 0;
    } else {
      two = 1;
    }
    // draw current shapes
    if (shapes.contains("e")) {
      // Draw an ellipse for this frequency
      ellipse(random(-1, 1)*amplitude*positions[0]*two, random(-1, 1)*amplitude*positions[1]*two, 1.4*circles[i], circles[i]);
    }
    if (shapes.contains("r")) {
      rectMode(RADIUS); 
      rect( random(-1, 1)*amplitude*positions[0]*two, random(-1, 1)*amplitude*positions[1]*two, 1.4*circles[i], circles[i]);
    }
    if (shapes.contains("s")) {
      strokeWeight(3); //use fixed stroke weight when drawing stars
      //star data Xcentre,Ycentre,radius1,radius2,number of points
      star(random(-1, 1)*amplitude*positions[0]*two, random(-1, 1)*amplitude*positions[1]*two, circles[i]*stardata[0], circles[i]/stardata[1], int(stardata[2]+random(stardata[3])));
    }
    popStyle();

    //System.out.println( i+" "+circles[i]); //for debugging
  } //end of for loop
  popMatrix();
}

void oscEvent(OscMessage msg) { //function to receive and parse OSC messages
  System.out.println("### got a message " + msg);
  System.out.println( msg);
  System.out.println( msg.typetag().length());

  if (msg.checkAddrPattern("/viz/float")==true) {
    for (int i =0; i<msg.typetag().length(); i++) {
      fvalues[i] = msg.get(i).floatValue();
      System.out.print("float number " + i + ": " + msg.get(i).floatValue() + "\n");
    }
  }

  if (msg.checkAddrPattern("/viz/pos")==true) {
    for (int i =0; i<msg.typetag().length(); i++) {
      positions[i] = msg.get(i).intValue();
      System.out.print("pos number " + i + ": " + msg.get(i).intValue() + "\n");
    }
  }

  if (msg.checkAddrPattern("/viz/col")==true) {
    for (int i =0; i<msg.typetag().length(); i++) {
      cols[i] = msg.get(i).intValue();
      System.out.print("col number " + i + ": " + msg.get(i).intValue() + "\n");
    }
  }
  if (msg.checkAddrPattern("/viz/shapes")==true) {
    shapes=msg.get(0).stringValue();
    //for(int i =0; i<msg.typetag().length(); i++) {
    // shapes += msg.get(i).stringValue().toLowercase();      
    //}
    System.out.print("shapes code "+ shapes + "\n");
  }
  if (msg.checkAddrPattern("/viz/stardata")==true) {
    for (int i =0; i<msg.typetag().length(); i++) {
      stardata[i] = msg.get(i).intValue();
      System.out.print("stardata number " + i + ": " + msg.get(i).intValue() + "\n");
    }
  }
  if (msg.checkAddrPattern("/viz/rotval")==true) {
    rotval =msg.get(0).intValue();
    System.out.print("rotval code "+ rotval + "\n");
  }
  if (msg.checkAddrPattern("/viz/shift")==true) {
    shiftflag =msg.get(0).intValue();
    System.out.print("shiftflag code "+ shiftflag + "\n");
  }
  if (msg.checkAddrPattern("/viz/stop")==true) {
    kill(); //stop Sonic Pi from running
  }
}

//function to draw a star (and polygons)
void star(float x, float y, float radius1, float radius2, int npoints) {
  float angle = TWO_PI / npoints;
  float halfAngle = angle/2.0;
  beginShape();
  for (float a = 0; a < TWO_PI; a += angle) {
    float sx = x + cos(a) * radius2;
    float sy = y + sin(a) * radius2;
    vertex(sx, sy);
    sx = x + cos(a+halfAngle) * radius1;
    sy = y + sin(a+halfAngle) * radius1;
    vertex(sx, sy);
  }
  endShape(CLOSE);
}

void kill(){ //function to send stop message to Sonic Pi on local machine
  OscMessage myMessage = new OscMessage("/stop-all-jobs");
   myMessage.add("RBN_GUID"); //any value here. Need guid to make Sonic PI accept command
  oscP5.send(myMessage, myRemoteLocation); 
}

The basis of a visualiser depends on doing a fast fourier transform analysis of the incoming audio, and calculating amplitudes related to the different frequency components of the audio, which is continuously monitored input buffer by input buffer. I don’t intend togo anywhere near the complex mathematics involved, but there are a lot of useful articles at different levels which you can read on the subject. I quite liked this one on the Fourier Transform. https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/. Also it is useful to look at the documentation of the minim library analysis section http://code.compartmental.net/minim/index_analysis.html if you want more detailed information on the calls employed.
You may find it easier to look at the original sketch from which I started https://github.com/andrele/Starburst-Music-Viz before taking on board the additions I have added to make the sketch more flexible and wide ranging.
I have added various transformations. Starting at the beginning of the main draw() function there are x and y offsets which increase each time the loop iterates, until a maximum offset is reached, when they reverse in direction. This causes the shapes to move smoothly left and right and up and down the screen. a shiftflag eanbles this to be siwtched on and off by one of the control OSC messages.
There follows an optional rotate command which can rotate the axis of the shapes being drawn, again controlled by an incoming OSC message.
Next values for setting the limits on the stroke size being used to render the shapes are read from data received by an OSC message, together with an audioThreshold setting.
A buffer from the input audio is now processed, and amplitude values for different frequency ranges are stored in an array of “circle” settings. NB the name circles is used for the variable as this was the only shape used in the original.Perhaps it might be better names shapes() now as there are three different classes of shapes used. A new value for the “radius” is stored if it is less than the audioThreshold setting, otherwise, a “decayed” value of the currently stored value from the previous iteration is stored. (suitable minimum values are set).
rgb colour values are set using values received from an OSC message, and these are then swapped at random, before setting the stroke colour attributes  to be used.
Next a flag two is set according to whether  one or more than one shapes have been selected. In the latter case the shapes are forced to be drawn concentrically, by nullifying the offset values by setting two = 0. The selected shapes are then drawn, before the loop starts a further iteration.

The oscEvent(OscMessage msg) function is triggered when an OSC message is received. It contains sections to parse the various OSC messages which can be sent from Sonic PI to the processing sketch. The parameters for each command are used to update various lists containing information used by the draw function.eg cols[ ] holds rgb values, startdata[ ] holds the parameters for the star shapes, fvalues[ ] holds the floating point values for the STROKE_MAX, STROKE_MIN  and audioThresh settings. These and other similar settings are updated when the relevant OSC messages are received, so Sonic PI can control the operation of the sketch as it runs.
The star functions draws the star shape. It is lifted straight from the star example here https://processing.org/examples/star.html.
The final function kill( ) is used to send a /stop-all-jobs OSC message back to Sonic PI to stop all programs running on that machine. It can be triggered by a /viz/stop OSC message being sent from Sonic PI to the Sketch.

As far as Sonic Pi is concerned, it produces two sorts of input. First the audio that it produces is fed back to the sketch which looks at the default audio input. On my Mac I used the program Loopback ( https://rogueamoeba.com/loopback/ ) to perform this. This is a paid for program, but you can use it for free for 10 minutes or so at a time.It is based on the previous free SoundFlower utility, but this has not been fully updated for recent MacOS and you may find it difficult to get it to work instead. The setup I used is shown below:Note that Sonic Pi is added as a Source and that its output is monitored through the speakers, so that the audio is fed both there and to the processing sketch. This loopbackdevice will appear in the list of devices in the MIDI audio setup program, and should be selected as the default input device,

Secondly, Sonic PI is used to send OSC messages to the processing sketch to control its various parameters. this can be done by sending “one off” messages or by putting the message sender into a live loop, sending messages at regular intervals. An example is shown below, where the OSC messages are combined with the program producing the music, but they can  be run as a separate program in a different buffer, which is an advantage if you are visualising a linear piece and do not want to restart it every time you press run to update the OSC messages sent.

#Program to drive Sonic Pi 3 visualiser written in "processing"
#by Robin Newman, September 2017
#see article at https://rbnrpi.wordpress.com
#set up OSC address of processing sketch
use_osc '127.0.0.1',5000
#select shapes to show
osc "/viz/shapes","e"  #"s" "e" "r" Star,Ellipse, Rectangle or combination
sleep 0.1

live_loop :c do
  #choose starting colour for shapes
  osc "/viz/col",rrand_i(0,64),rrand_i(128,255),rrand_i(0,255)
  sleep 0.1
end

live_loop :f do
  #set Stroke max min widths and audioThreshold
  osc "/viz/float",([8.0,5.0,3.0].choose),[1.0,2.0].choose,(0.4+rand(0.3))
  sleep 2
end

#set range of random positional offset (can be 0,0)
#automatically disabled when showng more than one shape
osc "/viz/pos",20,0

#control "bouncing" shapes around the screen 1 for on 0 for off
osc "/viz/shift",0

live_loop :s do
  #setup star data inner/outer circle radius, number of points
  #and random variation of number of points
  osc "/viz/stardata",[1,2].choose,[1,2,3].choose,5,2
  sleep 4
end

rv=0 #variable for current rotation
live_loop :r do
  rv+=5*[-8,1].choose # choose rotation increment
  rv=rv%360
  osc "/viz/rotval",rv #change rv to 0 to disable rotation
  sleep 0.1
end

#Now setup the sounds to play which will trigger the visualiser
use_bpm 60
set_volume! 5
use_random_seed 999

with_fx :level do |v|
  control v,amp: 0 #control the volume using fx :level
  sleep 0.1
  
  in_thread do #this loop does the volume control
    control v,amp: 1,amp_slide: 10 #fade in
    sleep 140
    control v,amp: 0,amp_slide: 10 #fade out
    sleep 10
    osc "/viz/stop" #send /viz/stop OSC message to sketch
    #sketch sends back a /stop_all_jobs command to port 4557
  end
  
  #This drum loop is written by Eli see https://groups.google.com/forum/#!topic/sonic-pi/u71MnHnmkVY
  #used with his permission. I liked it, and it has good percussive output
  #to drive a visualiser
  live_loop :drums do
    this_sample = [:loop_compus, :loop_tabla, :loop_safari].ring
    start = [ 0.0 , 0.125 , 0.25 , 0.375 , 0.5 , 0.625 , 0.75 , 0.875 ].ring
    sample this_sample.look , beat_stretch: 4, start: start.look, rate: 0.5
    sleep 1
    tick
  end
end

As this program runs, you can alter the parameters eg shape(s) chosen, shift parameter etc. and rerun. Effectively live coding the visualiser. The program uses a great percussion loop written by Eli, which he said I might use. https://groups.google.com/forum/#!topic/sonic-pi/u71MnHnmkVY

There is a video of the program in operation on youtube here

and you can download the code for the sketch and Sonic Pi programs here

You can download and install Processing from https://processing.org/download/

You will also have to install the libraries Minim and oscP5 from the Sketch=>Import Library… menu.
To use, set up the loopback audio and select it as the default input device. Load and play the sketch in processing, then run the Sonic Pi program on the same computer. You can adjust the transparency of the Sonic Pi screen on the Preferences Visuals tab to make it semi transparent, or minimise Sonic Pi once it is running, if you are not going to do live coding of the control OSC messages.

Advertisements

Sonic Pi 3 drives the LEDs on pi-topPULSE module

The new pi-topPULSE module contains a 7×7 LED array, a microphone and an audio amplifier. The latter can be used by Sonic Pi as its output audio path, and Sonic PI version 3 can also be used to control the LEDs on the PULSE module using OSC messages, which can be received by a python program which decodes them, and uses the commands to control the LEDs.

I have written a full article giving a detailed explanation of how this is done, which you can read here.

There is also a link in the article to the code which is used, and to a video of the program in action on youtube.

Sonic Pi 3 Synth Driver

Following on from the PS3 project, I used some of the same code, and expanded and modified it to produce a project I entitled Sonic Pi 3 Synth Driver. This incorporates the “Long Note” synth introduced in the PS3 project, which produces a continuously sounding synth note, which can have various characteristics such as synth, pitch, cutoff, volume and reverb altered. The project drives Sonic Pi3 using OSC messages from TouchOSC running on an iPad. Full details are in this article which includes links to a video and to the code used.
TouchOSC is available on the App store, and is also available for Android.

Control Sonic Pi 3 with a PS3 wireless controller

Recently I published a video on YouTube showing Sonic Pi 3 being controlled by a PS3 wireless games controller. This post contains a link to the software required to do this, should you wish to try it out.

Two files are included. The first, ps3.py should be run on a Raspberry Pi, into which the wireless dongle of the PS3 controller is plugged. Two pieces of supporting software need to be installed first.

sudo apt-get update
sudo apt-install joystick
sudo pip3 install python-osc

The second software file is a Sonic Pi 3 script, which should be loaded into a buffer on Sonic Pi 3, which can be running either on the Raspberry Pi, or on an external computer.

NB if you want to run Sonic Pi 3 on the Raspberry Pi you need to wait for the Raspbian Stretch to be released, or upgrade a new copy of Rasbian Jessie to Stretch yourself. The released version of Sonic Pi 3 will NOT run on Raspbian Jessie
This is specified on the command line when running the ps3.py script by adding an argument –sp xxx.xxx.xxx.xxx where xxx.xxx.xxx.xxx is the IP address of the computer running Sonic Pi.
In addition, on the IO preferences in Sonic Pi you must make sure that the option to receive remote OSC messages is ticked

To run the ps3.py file, make sure it is executable by typing:
chmod 755 ps3.py
then type
./ps3.py     or        ./ps3.py –sp xxx.xxx.xxx.xxx        Putting in the appropriate IP address of your remote Sonic Pi 3 computer.
As an alternative you can type python3 ps3.py
or         python3 ps3.py –sp xxx.xxx.xxx.xxx

The software can be downloaded from here

Sonic Pi 3 says hello to Raspberry Pi GPIO

The latest version of Sonic Pi, version 3.0 is aptly named the IO version. It adds comprehensive facilities to allow Sonic Pi to communicate with the outside world, by midi or OSC messages, and it also allows live audio feeds to be accepted by Sonic Pi, to be incorporated in the program it is playing. This article explains in detail how you can interact with LEDs and buttons connected to a Raspberry Pi GPIO pins, with Sonic Pi controlling the LEDs, and the notes that Sonic Pi plays being controlled by a push-button connected to a GPIO pin.
This is just one example. I have already connected Sonic Pi to Scratch, to TouchOSC running on an iPad and to external midi keyboards and synths, as well as a Microphone input, and you can also see some of these as video on my youtube channel here Hopefully I will find time to write up some of these in these future.
In the meantime on to the article to enable Sonic Pi 3 to say hello to Raspberry Pi GPIO CLICK HERE

Boot to Sonic Pi from a USB stick (no SD card) on Pi3

Recently I ran up an image on a USB stick which can be used to boot a Pi3 (NOT Pi2 or earlier) straight into Sonic Pi 2.11, without needing an SD card. This is based on excellent documentation on the Raspberry Pi website at https://www.raspberrypi.org/documentation/hardware/raspberrypi/bootmodes/msd.md and I claim no credit for this whatsoever other than having tried it out successfully.

Note this is still an experimental procedure to a certain extent, although with the USB drive I specify below I had no problem in getting to to work with two different Pi3. Your Pi3 will still be bootable as normal from a standard SD card after you have carried out this procedure.

In order to set this up you will need the following:
1 A Pi3 (it will not work on a Pi2 as it uses bootcode built into the Pi3)****
2 A freshSD card on which to build the image which will be transferred to your USB stick. I used a 16Gb Sandisk Ultra miscroSDHC
3 A usb stick. I used a Sandisk Cruzer SDCZ50 16GB from Amazon for £4.99 (not every usb stick will work. The article give a list of some which have been tested)
4 An internet connection for your Pi3

*** It is possible to change this to boot from a Pi2 or earlier, using just one boot file on an SD card. Thereafter the USB stick takes over. See https://www.raspberrypi.org/documentation/hardware/raspberrypi/bootmodes/ for details.

Follow the details of the first part of the article to build up your SD card image Use the Raspbian image dated 2016-09-23 from raspberrypi.org/downloads  Before the second stage, where you transfer the image to your USB stick, install Sonic Pi 2.11 (just released) onto the SD card. You can get it from
http://sonic-pi.net/files/releases/v2.11.0/
download the file sonic-pi_1-2.11.0-2_armhf.deb
I downloaded this via the Chromium browser on the Pi3 to the Downloads folder
Then I installed it with:-

cd ~/Downloads
sudo dpkg -i sonic-pi_1-2.11.0-2_armhf.deb
sudo apt-get install -f

You may find it then lists some redundant packages which you can remove as suggested with

sudo apt-get autoremove

I also added dtoverlays for my IQaudio amp to config.txt using sudo nano /boot/config.txt

dtoverlay=iqaudio-dacplus,auto_mute_amp
dtoverlay=i2s-mmap

which you can do also if you have one, or else any overlays required for an alternative eg HiFiBerry card.

In order to add an auto boot into Sonic Pi you do the following.

mkdir -p ~/.config/autostart
cp /usr/share/applications/sonic-pi.desktop ~/.config/autostart

If you have an IQaudio (or alternative audio card) installed on your Pi3, you should select it as the default card in the Audio Device Settings on the Menu -> Preferences tab

Once you are happy with the SD card, you should complete the second section of the article setting up the USB stick with parted as discussed in the raspberry pi boot documentation article.

All being well, once you have finished you should be able to boot your Pi3 from the usb stick you have set up. Note it does take some time to boot, as it first checks to see if you have an SD card installed, and then switches to search for a USB card after a 5 second timeout. You will see a large rainbow coloured square on your monitor during this process.

I advise you to remove the line added to config.txt

program_usb_boot_mode=1

which was added to program the One Time Programmable memory (OTP) in your Pi3 to enable USB booting. This is an irreversible process, and you may not wish to inflict it on any other Pi3 that the card is subsequently used to boot, although the Pi3 can still boot normally with an SD card even if this has been programmed.

The original github page for the procedure is at
https://github.com/raspberrypi/documentation/blob/master/hardware/raspberrypi/bootmodes/msd.md

and there is more useful information in the parent folder (bootmodes)

This project requires some care to follow the procedures accurately, and it takes a little time to transfer the card contents to the USB stick. Although the boot time is quite long, the performance thereafter is not noticeably different from that of the SD card. Apparently you can add a resistor to one of the GPIO pins to speed up the booting by getting it to ignore the SD card, but I haven’t managed to find out documentation as to which pin is involved. You can also leave a blank SD card in the Pi3 which will also speed up the boot time, by eliminating the timeout wait.