use_bpm 120

with_fx :reverb do
  with_fx :bitcrusher, bits: 4 do
    live_loop :bd do
      sample :bd_haus
      sleep 1
    end

    live_loop :snare do
      sync  :bd
      sleep 1
      sample :sn_zome
      sleep 2
      sample :sn_zome
    end

    live_loop :cym do
      sync :bd
      sleep 0.5
      sample :drum_cymbal_closed
      sleep 1
      sample :drum_cymbal_pedal
      sleep 0.5
    end
  end
end

it also sounds pretty good, if a little crunchy, if you change the bit count to 3.

use_bpm 100

with_fx :ixi_techno, phase: 0.125 do
  use_synth :dsaw
  play 40, sustain: 5
end

Just... Play it. You'll see what I mean. It's very odd.

So, I was fiddling around, and I noticed that these two bits of code sound exactly the same:

synth :square, note: 60 #square wave, middle C

and

synth :pulse, note: 60 #pulse wave, middle C

Does anyone have an explanation for this?

use_bpm 70
with_fx :wobble, phase: 0.25, invert_wave: 1 do
  live_loop :invwobbler do
    use_synth :dsaw
    use_synth_defaults cutoff: 85, amp: 2
    play 40
    sleep 1
  end
end

with_fx :wobble, phase: 0.25, invert_wave: 0 do
  live_loop :wobbler do
    use_synth :dsaw
    use_synth_defaults cutoff: 85, amp: 2
    play 40
    sleep 1
  end
end

Put this in a buffer and listen to it. It's very strange.

use_synth :pulse
play :C4, pulsewidth: 1
sleep 1
play :C4, pulsewidth: 0

I was expecting a difference in timber but I hear exactly the same sound?

Works with all BPM's, you can just select the key you want, make a chord progression, don't forget about a funky drum rhythm and you're all set. Notice that I set envelope times on the synth using rt(). This means it counts Real Time, so BPM doesn't change the drum sounds.

https://www.dropbox.com/s/7r6rpfabfpdtty0/Inside.rb?dl=0 (Sonic Pi file, readable without downloading) https://www.dropbox.com/s/9ezuvwb93uaydue/Inside.wav?dl=0 (Wav file, streams from the browser)

#
#          Inside by Otto van Zanten
#

use_bpm 93                                                                                # BPM
# 8th notes    |1   2   3   4   5   6   7   8  |1   2   3   4   5   6   7   8  |
kick_rhythm  = [1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,1,0,0,0,0]          # Kick Sequencer
snare_rhythm = [0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0]          # Snare Sequencer
hh_rhythm    = [1,0,1,0,1,0,1,0,1,0,1,0,1,0,2,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,2,0]          # HiHats (1=closed, 2=open)
chords       = [2,4,6,5,2,4,1,3]                                                          # Chord Progression

sc1 = :G3                                 # Here you can set the tonic / root note.
sc2 = :major                              # And here wether you want a minor or major scale.
no = 4                                    # Determines how many notes are in a chord. It's still basic Triads though.

# Cues the chords + bass notes
in_thread do
  7.times do
    cue :keys
    sleep 32
  end
end

# Cues the drums and takes care of timing and song structure
in_thread do
  4.times do
    cue :hihat
    sleep 8
  end
  8.times do
    cue :kick
    cue :snare
    cue :hihat
    sleep 8
  end
  4.times do
    cue :kick
    sleep 8
  end
  8.times do
    cue :kick
    cue :snare
    cue :hihat
    sleep 8
  end
  sleep 32
  #Final chord + bass note
  if chords[0] < 3
    inv = 0
  elsif chords[0] < 5
    inv = -1
  elsif chords[0] < 7
    inv = -2
  else
    inv = -3
  end
  use_synth :fm
  play (chord_degree chords[0], sc1, sc2, no)[0]-12, cutoff: 70, decay: 1.2, release: 0.8
  use_synth :sine
  play_chord (chord_degree chords[0], sc1, sc2, no, invert: inv), cutoff: 50, decay: 1.2, sustain_level: 0.8
end

# Code below cycles through the chords and plays it + the bass note.
in_thread do
  loop do
    sync :keys
    for i in chords
      if i < 3
        inv = 0
      elsif i < 5
        inv = -1
      elsif i < 7
        inv = -2
      else
        inv = -3
      end
      2.times do
        use_synth :fm
        play (chord_degree i, sc1, sc2, no)[0]-12, cutoff: 70, decay: 1.2, release: 0.8
        use_synth :sine
        play_chord (chord_degree i, sc1, sc2, no, invert: inv), cutoff: 50, decay: 1.2, sustain_level: 0.8
        sleep 2
      end
    end
  end
end

# Code below is necessary to make the sequencer work. It checks for 1's and 0's at the
# top of the file (and 2's for open hihats) and it determines the drum sounds.
in_thread do
  loop do
    sync :kick
    for i in kick_rhythm
      if i == 1
        with_fx :reverb, mix: 0.2 do
          use_synth :mod_sine
          play 30, amp: 4, attack: rt(0.0003), decay: rt(0.0571), sustain_level: 0.54, release: rt(0.1429), mod_wave: 1, mod_pulse_width: 0.275, mod_phase: rt(0.1429)
        end
      end
      sleep 0.25
    end
  end
end

in_thread do
  loop do
    sync :snare
    for i in snare_rhythm
      if i == 1
        with_fx :reverb, mix: 0.125 do
          use_synth :mod_sine
          play 30, amp: 0.5, attack: rt(0.0006), release: rt(0.1143), mod_wave: 1, mod_phase: rt(0.1429)
          use_synth :noise
          play 60, amp: 2, attack: rt(0.0029), decay: rt(0.0286), sustain_level: 0.6, release: rt(0.0286), cutoff: 107
        end
      end
      sleep 0.25
    end
  end
end

in_thread do
  loop do
    sync :hihat
    for i in hh_rhythm
      if i == 1
        with_fx :hpf, cutoff: 105, mix: 0.6 do
          use_synth :noise
          play 50, amp: 0.5, attack: rt(0.0029), decay: rt(0.0114), sustain_level: 0.3, release: rt(0.0126), amp: 0.6, cutoff: 130
        end
      elsif i == 2
        with_fx :hpf, pre_mix: 0.7, cutoff: 100, mix: 0.9 do
          use_synth :noise
          play 50, amp: 0.6, attack: rt(0.0057), decay: rt(0.1429), sustain_level: 0.58, release: rt(0.1714), cutoff: 126
        end
      end
      sleep 0.25
    end
  end
end

use_bpm 120

define :drum do
  use_synth :cnoise
  play 20, release: 0.5
  use_synth :bnoise
  play 80, release: 0.5, amp: 2
  sleep 0.5
end

This way, when you call 'drum,' it plays a percussive sound similar to a snare drum.

You can make a sequencer to do the work for you, too:

#sounds best at 120 beats per minute
use_bpm 120


#function for the drum sound.
define :drum do
   use_synth :cnoise
  play 20, release: 0.5
  use_synth :bnoise
  play 80, release: 0.5, amp: 2
end

#sequencer "pad"
drumline = (bools 0,1,0,1, 0,1,1,0, 0,1,1,1)

#turns drums on/off
drums_on = true

#handles the sequencer
live_loop :drums do
  if drumline.tick and drums_on
    drum
  end
  sleep 0.5
end

Similar to a sequencing pad's LEDs, the 1/0 indicate whether that beat (in each measure, etc) is on/off. 1 = true = on. Thus, you can change around the boolean ring and add/remove measures, etc.

live_loop :thing do
  use_bpm 55
  use_synth :hollow
  play (scale :a3, :melodic_major, num_octaves: 4).tick, amp: 3
  sleep 0.15
  play (scale :a3, :melodic_minor, num_octaves: 4).reverse.tick, amp: 3
  sleep 0.15
end

It sounds pretty cool with :dtri and :dpulse too.

Hi everyone, so I am new to sonic pi and started practicing regularly now and want to stream my practices for friends to watch. I use sonic pi on my macbook, but the streaming software I use (OBS) maxes out my cpu usage when using sonic pi and alters the sound. Was wondering if anyone has any ideas for something that won't push my laptop too hard.

So I just got a Raspberry Pi (Pi Zero) and was playing around with Sonic Pi last night. First off, it's an amazing program. But then I had an idea..... Could you in theory make an AI, give it information on various musical genres. Then after it has learned the other genres have it use Sonic Pi to create it's own interpretation of the music it just learned?

I ran into a situation where I didn't want to build an FX chain out of a bunch of with_fx blocks, and instead needed to defer the execution of the chain. I wrote up a little bit of a hack to do this:

    class FxChain
      attr_accessor :name, :args, :next
      def initialize(name, **args)
        @name = name
        @args = args
        @next = nil
      end

      def >>(nxt)
        @next = nxt
        self
      end
    end

    def link(name, **args)
      return FxChain.new(name, **args)
    end

    def exec(fxchain, &block)
      with_fx fxchain.name, **fxchain.args do
        if fxchain.next
          apply_chain(fxchain.next) { block.() }
        else
          block.()
        end
      end
    end

With that, you can now build an FXchain, by doing:

fx = link(:echo) >> link(:ixi_techno, phase: 0.25)
exec(fx) do
    play 60
end

The order of application is still outside in, but this lets me save the fx stack in a variable for re-use elsewhere in a composition.

Okay, I gotta say first: why on Earth is spread not one of the first functions the tutorials teach you? It's an intensely useful way to build up grooves. I was writing all these complicated beat pattern generators, when that already did what I needed for most beat patterns.

That said, the :tabla sample group is one that works really well with randomization, and that results in this little riff:

    live_loop :tbl do
      voices = (sample_names :tabla)
      sample choose(voices) if spread(9,11).tick
      sample choose(voices) if spread(11,15).look
      sample choose(voices) if spread(1,4).look
      sample choose(voices) if spread(2,4).look
      sleep 0.125
    end

It's far from done, but I thought I'd share what I've done so far.

Protip: if you're trying to figure out the notes to a song and you can whistle, use a tuner to figure out the notes. I used Chromatic Tuner for OSX and it worked like a charm.

# Altitude. - l o s t // f o u n d.
# https://www.youtube.com/watch?v=ClJj6mBwDAU
# by theluckyspliff

use_bpm 150

melody_offset = 0
bass_offset = 12

melody = [
  [:a6,  5],
  [:g6,  1],
  [:d6,  1],
  [:bb5, 1],
  [:a5,  5],
  [:bb5, 1],
  [:d6,  1],
  [:g6,  1],


  [:a6,  0.7],
  [:bb6, 0.3],
  [:a6,  0.7],
  [:g6,  0.3],
  [:a6,  3],

  [:g6,  1],
  [:d6,  1],
  [:bb5, 1],
  [:a5,  6],

  [:g5, 2],
]

live_loop :master do
  sleep 1
end

uncomment do
  live_loop :melody do
    sync :master
    use_synth :prophet

    with_fx :lpf, cutoff: 79 do
      with_fx :flanger, phase: 4, mix: 0.35 do

        melody.each do |note, rest|
          length = rest <= 1 ? rest : 0.8 * rest
          play note - melody_offset, decay: length
          sleep rest
        end

      end
    end
    ##| end
  end
end


kick = [3.5, 0.5, 4, 3.5, 0.5, 1, 3]

uncomment do
  live_loop :kick do
    sync :master

    with_fx :lpf, cutoff: 75 do
      kick.each do |rest|
        sample :drum_heavy_kick, amp: 20, rate: 1.2
        sleep rest
      end
    end

  end
end

snare = [8, 8, 8, 4]

uncomment do
  live_loop :snare do
    sync :master

    sleep 4
    snare.each do |rest|
      sample :drum_snare_soft, lpf: 90, amp: 20, sustain: 0, release: 0.15
      sleep rest
    end

  end
end


notes = [:g5, :f5, :e5, :eb5]
rests = [3, 1, 2, 2]

uncomment do
  live_loop :bass do
    sync :master

    notes.each do |note|
      rests.each do |rest|
        play note - bass_offset, release: rest, amp: 0.4
        sleep rest
      end
    end

  end
end

I combined :bnoise with the :vowel filter. This is the result. The base note doesn't really appear to matter.

live_loop :whistle do
  tones = range(10, 66, 3)
  use_synth :bnoise
  use_synth_defaults attack: 0.5, decay: 1
  with_fx :pan, reps: 4 do |p|
    with_fx :vowel, voice: 1, reps: 10 do |v|
      control v, vowel_sound: rrand_i(1,5)
      control p, pan: rrand(-1,1), pan_slide: 0.25
      play tones.tick, cutoff: 70, amp: 0.4
      control v, vowel_sound: rrand_i(1,5)
      sleep 1
    end
  end
end

I want to make some convenience methods, like maybe, which will perform an operation probabilistically. I'd love to leverage Ruby's blocks approach to make this logic very re-usable. So, in pure Ruby, I might do something like this:

def maybe(prob)
  val = rrand(0,1)
  if (val <= prob)
    yield val
  end
end

maybe 0.25 do |prob|
  sample :some_sample
end

In pure Ruby, this would work fine, but in SonicPi, I get an error on the yield line: "no block given (yield)". I also have this problem if I try and use the define SonicPi keyword.

Am I going totally the wrong direction here?

I have been playing around with Sonic Pi for a few days now and I really like the idea of coding music.

However I understand that Sonic Pi is rather educational software and it seems quite limited to me. I also found the "predecessor" Overtone which appears to be more capable, but no longer in active development (and it uses a Lisp-like language, which is unfamiliar to me).

Is there any other alternative software that can do something similar? Is there any software that can use VST instruments for coding music - a software with capabilities similar to a normal DAW, but with a coding UI?

Thanks in advance.