pax_global_header 0000666 0000000 0000000 00000000064 12704164724 0014521 g ustar 00root root 0000000 0000000 52 comment=e61ad21e1ee48b0ca794e2aaff9fe72c8b427c93
sonic-pi-2.10.0~repack/ 0000775 0000000 0000000 00000000000 12704164724 0014706 5 ustar 00root root 0000000 0000000 sonic-pi-2.10.0~repack/CHANGELOG.md 0000664 0000000 0000000 00000133232 12704164724 0016523 0 ustar 00root root 0000000 0000000 # History
* [v2.10 'Cowbell'](#v2.10), 15th April, 2016
* [v2.9 'Venster'](#v2.9), 31st Dec, 2015
* [v2.8 'Karlsruhe'](#v2.8), 20th Nov, 2015
* [v2.7 'Rerezzed'](#v2.7), 10th Sept, 2015
* [v2.6 'Algorave'](#v2.6), 30th July, 2015
* [v2.5 'Craft'](#v2.5), 13th April, 2015
* [v2.4 'Defrost'](#v2.4), 11th Feb, 2015
* [v2.3 'Bitcrush'](#v2.3), 28th Jan, 2015
* [v2.2 'Slicer'](#v2.2), 18th Dec, 2014
* [v2.1 'Core'](#v2.1), 21st Nov, 2014
* [v2.0 'Phoenix'](#v2.0), 2nd Sept, 2014
## Version 2.10 - 'Cowbell'
*Friday 15th April, 2016*
[(view commits)](https://github.com/samaaron/sonic-pi/commits/v2.10.0)
_"I gotta have more cowbell!"_ - The Bruce Dickinson
The main feature in this release is the completely new sample system for
working with large folders of samples. You can now easily index into and
filter over whole folders of samples with a simple yet powerful filter
system. This system has been in development for over a year now and has
been tuned and tweaked over many performances and practice sessions. See
the documentation and examples for `sample` as well as the new tutorial
section 3.7 for details.
We also have a number of exciting new sounds to play with including some
beautifully sounding chiptune synths, fun retro FX and new drum samples
including a full tabla set and a cowbell.
Finally, even more boot issues on both OS X and Windows that have been
fixed making this the most polished and stable release to date.
Now go and get your live code on!
### Breaking Changes
* `use_sample_pack_as` and `with_sample_pack_as` have been removed.
* A synth opt value of `nil` now no longer resolves to 0.0. Instead it
masks any defaults and ensures the downstream default (for the actual
synthdef itself) is honoured. This allows you to override any existing
synth defaults specified via `use_synth_defaults` for a given synth
trigger.
* Default schedule ahead time is now 0.5s on all platforms for
consistency (except for Raspberry Pi 1 which remains at 1s).
### New Fns
* `current_random_seed` - Get the current seed value of the random generator.
* `set_cent_tuning!` - global tuning.
* `on` - similar to `if` but behaves the same as the `on:` opt for
synths and samples.
* `halves` - create a ring of successive halves.
* `doubles` - create a ring of successive doubles.
* `pick` - similar to shuffle but allows duplicates. You may also
specify how many items to pick.
* `fx_names` - create a ring of all available FX.
### Synths & FX
* New synth `:dtri` - detuned triangle waves.
* New synth `:pluck` - a lovely synthesised plucked string.
* New synth `:chiplead` - retro NES style lead synth.
* New synth `:chipbass` - retro NES style bass synth.
* New synth `:chipnoise` - retro NES style noise synth.
* New FX `:whammy` - low-tech transposition effect similar to the
Digitech Whammy guitar pedal.
* New FX `:octaver` - low-tech octave effect similar to early guitar
pedals.
* New FX `:vowel` - modifies incoming signal to match human vowel
sounds.
* New FX `:mono` - mono effect for summing stereo channels.
* `:tanh` FX is now more crunchy by default.
* `:compressor` and `:krush` FX now correctly honour the `mix:` opt.
### Samples
* Samples in FLAC format (Free Lossless Audio Codec) are now supported!
* The `sample` fn gained source and filter pre-opts. You may now specify
a number of parameters directly before the opts which describe both
folders containing samples and filters over those folders to allow you
to easily and quickly work with large sample sets. See Section 3.7 of
the tutorial for more information.
* Samplers now have `hpf:` and `lpf:` opts. Any `cutoff:` opts are
automatically switched to `lpf:` and any errors will be reported with
an `lpf:` prefix.
* The sampler synth gained a compressor enabled via the `compress:`
opt. This means you can now compress any triggered sample directly
without the need to reach for an FX.
* Samplers gained the `pre_amp:` opt which applies the amp at the
beginning of its internal signal chain. You can use this to overload
the new compressor.
* Samplers now have both high pass and low pass filter envelopes which
behave similarly to the amplitude envelope but control internal hpf
and lpf FX. These are available via new opts which mirror the standard
envelope opts but with a `hpf_` and `lpf_` prefix (such as
`hpf_attack`, `lpf_decay_level` and friends).
* Passing a directory path to `load_samples` will now load all the
samples within that directory.
* Passing a directory path to `free_samples` will now free all the
loaded samples within that directory.
* Samples are now loaded asynchronously in a separate thread. This
therefore doesn't block the current thread and cause any subsequent
synth/sample triggers to be late.
* Sample trigger logging now includes the directory of the contained
sample.
* Samples are now reloaded asynchronously after a server reboot (and
therefore no longer block execution).
* Add new `:tabla_` sample group with a range of tabla drum sounds.
* Add new `:vinyl_` sample group with a range of vinyl scratches and
hisses.
* Add new samples: `:drum_cowbell`, `:drum_roll`, `:misc_cros`,
`:misc_cineboom`, `:perc_swash`, `:perc_till`, `:loop_safari`,
`:loop_tabla`.
### GUI
* Add new preference to enforce strict synth/FX timing. When enabled
synths and samples no longer trigger if it is too late - instead they
are silent and print a warning message. This behaviour ensures samples
or synths are never triggered out of time.
* New load button which will load the contents of a file into the
current buffer.
* The vertical bars which help visualise nesting now render in a
contiguous fashion over blank lines.
* `C-k` now nukes over trailing whitespace.
* `load_sample` now has sample autocompletion.
* GUI now correctly reports if the host is a Raspberry Pi 3.
* New editor preference - Log Auto Scroll. When enabled will always
scroll log to the bottom after printing every new message.
* Whitespace at top and bottom of buffer is no longer trimmed.
* Hitting `RETURN` now auto-indents the buffer - ensuring that the
cursor is moved to the correct indentation on the following line.
* Added Chinese Simplified GUI translation.
* Log visibility now correctly matches GUI preference.
### Documentation
* New tutorial section 3.7 on Sample Pack Filters.
* New appendix sections.
* Examples for `sample` fn have been completely rewritten and extended.
### Improvements
* `scale` and `chord` can now handle being passed no tonic such as:
`(chord :minor)` which will return a ring of offsets from 0.
* `chord` learned new variants: `add2`, `add4`, `add9`, `add11`,
`add13`, `madd2`, `madd4`, `madd9`, `madd11`, `madd13`
* The ring's `.take` method can now take more elements than the original
ring by wrapping around:
`(ring 1, 2, 3).take(5) #=> (ring 1, 2, 3, 1, 2)`
* Rings may now be added or subtracted from each other e.g.
`(ring 1, 2, 3) + (ring 4) #=> (ring 1, 2, 3, 4)`
* Adding or subtracting a number from a ring will create a new ring with
the number added or subtracted from each of the original ring's
elements: `(ring 1, 2, 3) - 1 #=> (ring 0.0, 1.0, 2.0)`
* Calling `(ring 1, 2, 3).take(0)` will now return an empty ring.
* `density` now complains if it isn't passed a do/end block.
* Improve error messages for `use/with_synth` when accidentally passed opts.
### Bugfixes
* On OS X only raise an error on boot if it's clear the sound card's in
and out rates are different.
* Improve robustness of boot process on Windows.
* Rest notes are no longer printed if synth logging is disabled.
* No longer apply synth defaults to FX.
* You may now control opts that have no associated info (previously it
would raise a 'not modulatable' error).
* Fix index lookup of Vectors.
* Fix `C-i` doc lookup shortcut to work with `:tb303` synth docs.
* `C-i` now always displays docs where available (previously it was
possible for docs not to be displayed).
* Sliding between chords now works correctly
* Windows version will now boot mutiple networked machines logged in
with the same account.
## Version 2.9 - 'Venster'
*Thursday 31st December, 2015*
[(view commits)](https://github.com/samaaron/sonic-pi/commits/v2.9.0)
Hot on the heels of the previous release comes `v2.9` codenamed
`Venster` (Dutch for window). This release has a specific focus on
fixing all the known issues with Sonic Pi running on Windows. If you've
tried Sonic Pi on Windows before and had issues, make sure to try it
again with `v2.9`. If you're still having issues on Windows please do
let us know so we can fix it as soon as possible.
For all you Raspberry Pi and Mac OS X users - you're not left out. Sonic
Pi is just as stable as it was before (if not more stable) and `v2.9`
comes with a surprising amount of tweaks and features for its short 1
month development cycle. There's two new FX to play with: `tanh` and
`gverb` as well as a heavily revamped logging system which is much
clearer about printing which opts are actually being used for your
synths and samples. Finally, we now include of all the published MagPi
magazine articles in the tutorial. We also now have Hungarian and
Norwegian translations of the GUI.
Happy Live Coding!
### Breaking Changes
* Rename fn `invert_chord` to `chord_invert`
* Sampler no longer mixes `rate:` and `pitch_stretch:` opts. It's now
possible to set the `rate:` independent of the `pitch:` modification
caused by `pitch_stretch`.
### New Fns
* `block_duration` - returns the duration of the given block in seconds (not scaled with the BPM).
* `block_slept?` - returns true if the contents of the block slept or synced.
* `synth_names` - returns a list of all the available synths
* `reset_mixer!` - resets the main mixer back to its default values.
* `sample_free` - unload a sample from memory to free up memory usage.
* `sample_free_all` - unload all samples from memory.
* `use_octave` - similar to `use_transpose` but for whole octaves.
* `with_octave` - similar to `with_transpose` but for whole octaves.
* `use_merged_sample_defaults` - similar to `use_merged_synth_defaults`
but for samples
* `with_merged_sample_defaults` - similar to
`with_merged_synth_defaults` but for samples
* `use_cent_tuning` - uniformly tune all subsequent notes in cents
* `with_cent_tuning` - uniformly tune all notes in cents within the block
### Synths & FX
* New FX `tanh` - for more distortion goodness.
* New FX `gverb` - a different reverb FX to play with.
### GUI
* Synths and samples now also log defaults set by `use_synth_defaults`
and friends.
* Opts are logged in the order they were defined with local opts first
followed by inherited opts.
* BPM scaling is now accounted for in logging vals.
* Log metadata such as run number and time is now printed in a more
code-like way: as a hash of key value pairs.
* `C-k` will now kill multiple lines if lines end with `,`.
* When saving a buffer a `.txt` extension is automatically added to the
file name if none specified.
* Add Hungarian and Norwegian translations of GUI.
* Add Spanish translation of tutorial.
* Add title to main window - enables Sonic Pi to be selected in
screensharing app lists such as Google Hangouts and OBS.
* Add autocompletion for tuning systems.
### Documentation
* Add 8 complete MagPi magazine articles to the tutorial in appendix A.
* Add new example 'ambient experiment' by Darin Wilson.
* Add new example 'chord inversions' by Adrian Cheater.
* Change tutorial license to CC-BY-SA 4.0.
* Add instructions for compiling and building on Windows.
* Many, many minor tweaks and improvements.
### Improvements
* Add `sync:` opt to `live_loop` and `in_thread`. This now syncs the
live loop once on creation. Similar to the `delay:` opt. If both
`sync:` and `delay:` are specified then the delay happens before the
sync.
* The `synth` fn can now play chords with the `notes:` opt such as:
`synth :dsaw, notes: (chord :e3, :minor)`. This will return a single
controllable synth node representing all the notes similar to
`play_chord`.
* BPM scaling and other normalisation is now honoured when controlling nodes
* The `on:` opt is now honoured when playing chords.
* Samplers sound signal now bypasses filter envelope when not used.
* It is now possible to use externally defined FX synths by passing a
string as the FX name: `with_fx "my_shiny_effect"`. This needs to be
loaded manually via `load_synthdefs`.
* OS X now supports rates other than 44.1k provided they are similar for
both audio in and out.
* Run code in `~/.sonic-pi/init.rb` on launch if it exists.
* If environment variable `SONIC_PI_HOME` is set it will be used over
`~` as the root of the user's `.sonic-pi` directory (used to auto-save
files and store logs).
* Default sound card selection is now honoured on Raspberry Pi - so you
may now use your IQaudIO hat (or similar) out of the box.
### Bugfixes
* Fix number of synth validation errors.
* Fix sporadically failing boot issues on Windows
* Add auto-reboot functionality for audio server. This now detects
errors in the server (such as a killed or zombied process) and
automatically reboots it to enable Sonic Pi to continue without a full
restart. Reboots automatically reload all loaded samples and
synthdefs.
* `sample_duration` now correctly takes account of TL defaults set by
`use_sample_defaults`.
* Sampler opts `pitch_stretch`, `beat_stretch` and `rpitch` can now be
used in TL defaults.
## Version 2.8 - 'Karlsruhe'
*Friday 20th November, 2015*
[(view commits)](https://github.com/samaaron/sonic-pi/commits/v2.8.0)
This release, named after Karlsruhe, one of the home cities of live
coding, is mainly a maintenance release with a strong focus on both
performance, stability and documentation. This is therefore the fastest
and most stable release of Sonic Pi ever with a massive 10% performance
improvement on the original Raspberry Pi 1. It also ships with new
translations in Polish, Japanese and French. Many of these improvements
(such as the complete rewrite of the OSC stack) are not documented in
this release list but can instead be found in the commit logs over on
Github.
However, not to go unnoticed are a number of exciting new features. For
example we now have a new Band EQ FX, the ability to use MIDI note names
such as `:e5` as values for opts such as `cutoff:`, and new powerful
cutoff envelopes on the sampler.
### Breaking Changes
* Shortcuts for switching buffers have changed. They are now `M-{` and
`M-}` for switching left and right respectively.
* `sync` no longer inherits BPM by default. Set the `bpm_sync:` opt to
true to enable BPM inheritance.
* Random seed generation for new threads is now reset on calls to
`use_random_seed`.
### New Fns
* `octs` - returns a ring of successive octaves.
* `assert` - for raising an exception if the argument is not true.
* `assert_equal` - for raising an exception if the two arguments are not
equal.
* `bt` - converts the specified time w.r.t. the current BPM.
* `inspect` - similar to `print` but prints the inspected version of the argument.
### GUI
* New translations for Polish, Japanese and French.
* Improve efficiency of logging panel.
* `M-RET` is now a duplicate shortcut for running the code.
* Log title bar is now hidden in full-screen mode.
* Log - don't display └ or ├ if the line is blank, instead display │
* Add sample name autocompletion to more fns such as `sample_duration`.
### Documentation
* New tutorial section on ring chains (chainable functions for modifying rings)
* Tilburg 2 example slightly tweaked for Raspberry Pi 1 compatibility.
* Many minor tweaks and improvements in all areas.
### Synths & FX
* New FX - Band EQ for attenuating or boosting a specific frequency band.
* New synth - DPulse - a detuned pulse wave.
* Sampler now has a cutoff envelope which can be accessed via new opts
which mirror the standard envelope opts but with a `cutoff_` prefix
(such as `cutoff_attack`, `cutoff_decay_level` and friends).
* Sampler now correctly handles samples with different sample rates.
* Bitcrusher FX now has an internal low pass filter modifiable via a new `cutoff` opt.
* Panslicer now correctly honours min and max pan values.
* New default opt `on:` for both `sample` and `synth`. This acts like
`if` but ensures all the opt vals are evaluated (useful if wanting to
keep the consumption of random streams or ticks consistent even when
not triggering a synth.
* MIDI opts such as `cutoff:` can now accept note names such as `:c4`.
* FX learned the global `slide:` opt to match synths.
### Improvements
* Massive performance improvements.
* Teach `play_pattern_timed` to handle rings.
* `current_transpose` now returns 0 if there is no current
transposition.
* BPM scaling is now honoured when controlling synths and FX
* All `with_fx*` fns now return the result of their block.
* `spark` now handles rings correctly.
* `spark` now treats booleans as 1s and 0s so you can now spark rings of bools.
* `puts`, `print` and `mc_message` now handle multiple message arguments
### Bug Fixes
* Ensure `with_fx` doesn't swallow TL modifications such as
transposition, current synth etc.
* Ensure `with_fx` doesn't affect random seed.
* Improve reliability of boot process on Mac and Windows.
* The FX `pre_amp:` opt is no longer scaled w.r.t. the current BPM.
* Fixed GUI side of update checking system.
## Version 2.7 - 'Rerezzed'
*Thursday 10th September, 2015*
[(view commits)](https://github.com/samaaron/sonic-pi/commits/v2.7.0)
This release brings a substantial change to the random number
generator. This has the unfortunate side effect of breaking backwards
compatibility. If you have been using `rand`, `choose`, `shuffle` and
friends to create predictable patterns for your riffs, your code will
produce different results in this release. Please let me apologise and
say it's for a good cause. So what is this good cause? Well, you can
now jump backwards and forwards through the random stream giving you way
more creative control than before! The random stream is now also unified
with the random stream on the synthesis server allowing you to sync
behaviour between synths and code. Exciting times.
The sampler has also been super charged. We can now easily change the
rate via MIDI note intervals with `rpitch:` and stretch the sample whilst
preserving pitch via `pitch_stretch:` (although with variable results
`;-)`).
Finally you can now control the global mixer with `set_mixer_control!`
for those full filter sweeps over the entire sound...
Have fun and happy live coding!
### Breaking Changes
* Complete rewrite of random number system. This means if you've been
combining calls to `use_random_seed` with randomisation to create
predictable melodies/rhythms/timbral manipulations you will
unfortunately get different results in `v2.7`. This change is to
synchronise both the Ruby rand stream with the one in SuperCollider as
well as enabling the reversal of calls to rand via `rand_back`.
* `sync` now causes the BPM to be inherited from the thread calling the
matching `cue`. This may be disabled with the new `bpm_sync:` opt.
* `rrand` and `rand` now return 0 if called with 0.
* `invert_chord` now handles negative inversions in a more musically
appropriate manner..
### New Fns
* `ratio_to_pitch` which provides the inverse of `pitch_to_ratio`
* `midi_notes` - returns a ring of numbers (mapping the source
ring/array through the fn `note`).
* `rand_back` - reverse the random stream and 'undo' calls to `rand`
* `rand_skip` - skip forward through the random stream.
* `rand_reset`- reset the random stream to the last seed.
### GUI
* It is now possible to toggle the commenting of whole selections or
individual lines with the shortcut `M-/`.
* Added Icelandic translation.
### Synths & FX
* All synths learned the `decay_level` opt to allow the sustain phase to
shift between two distinct values. The default value for `decay_level`
is to mirror `sustain_level:` thus preserving current behaviour.
* `play` and `synth` have now learned the `pitch:` opt to match
`sample`. This just increments or decrements the final note.
* `sample` now correctly validates opts.
* `sample` learned the `pitch_stretch:` opt which combines `rate:`
modification (similar to `beat_stretch:` with `pitch:`. Attempts to
maintain the pitch whilst simultaneously changing the rate. The
underlying implementation is very basic and can easily destroy the
sound.
* `sample` learned the `rpitch:` opt for simple rate pitch
modulation. This modifies the rate to match the specified number of
MIDI notes relative from the current pitch. For example, a `rpitch:`
of 12 would double the rate.
* The unit of the FX `:echo`'s `decay:` opt is now beats and the value
is scaled with the BPM.
### Examples
* Most examples have been tweaked to sound good with the new random
generator.
* Tilburg has been replaced with Tilburg 2. Play it and get your
Algorave on!
### Improvements
* Auto-align code on Run.
* `live_loop` learned the `seed:` opt which will set the new thread with
the specified seed prior to initial run.
* Add check to ensure BPM is a positive value.
* `density` has now been taught to handle values between 0 and 1 which
will now stretch time for the specified block.
* Errors now no longer print out crazy print version of context object
i.e. #
Meet the Sonic Pi Core Team - a dedicated group of live coders, working
hard to bring you exciting new features, sounds and music making
possibilities.
University of Cambridge Computer Labs researcher. Performing as Sam Aaron | Poly Core | Fib Crisis
Jazz guitarist, double bassist and music graduate who
writes Ruby code for a living.
Composer of algorithms, musical and otherwise. Builder of musical contraptions. Performing as jweather.
Programmer and live coder of sound, light and poetry.
Linux whizz and friend of i18n. Helping to bring Sonic Pi to your native tongue and to your Debian desktop.
Sonic Pi Core Team
sonic-pi-2.10.0~repack/FAQ.md 0000664 0000000 0000000 00000005142 12704164724 0015641 0 ustar 00root root 0000000 0000000 # FAQ - Frequently Asked Questions
## Doesn't work? Where to look for clues:
If you have trouble with Sonic Pi, have a look at the logs. You will
find the log files in your user home directory in `~/.sonic-pi/log/`.
Most likely, you will find a helpful error message there.
## Windows: Server boot error - Can't open UDP port 4558
This problem was reported on Windows machines in Sonic Pi v. 2.7. It was reported in following issues: [#699](https://github.com/samaaron/sonic-pi/issues/699), [#702](https://github.com/samaaron/sonic-pi/issues/702), [#720](https://github.com/samaaron/sonic-pi/issues/720). Occurred on Windows 7, Windows 8.1 & Windows 10.
*Workaround solution:*
* be sure, that you have closed Sonic Pi
* open Windows Task Manager with `Ctrl + Shift + Esc`
* try to kill all processes listed below if they're still running
Ruby Interpreter (CUI)
scsynth.exe
You can also check in Task Manger that there is no application entry sonic-pi.exe
and quit it if there is.
## Linux: There is no sound with use_synth :piano
You probably didn't install the SC3 plugins
package for SuperCollider on your system. If there
is no binary package provided by your distribution, you can
[install it from source](https://github.com/samaaron/sonic-pi/blob/master/INSTALL-LINUX.md#supercollider-sc3-plugins).
## Linux: Trouble with JACK
If the GUI complains that _"The Sonic Pi server could not be started!"_
or the message _"Loading previous buffer contents. Please wait..."_
does not disappear from your buffers after startup, the most likely
reason is a problem with JACK.
The Linux version of Sonic Pi relies on the
[JACK audio connection kit](http://jackaudio.github.io/) for its audio
output and it needs to be installed with it. The `jackd` audio daemon
needs to be started in the background and if it isn't running already,
the Sonic Pi server will start it for you. If this fails, Sonic Pi never
finishes starting up and won't get ready for you.
As a workaround, try this:
* be sure that you have closed Sonic Pi
* start jackd manually using the `qjackctl` GUI
* once it started, start `sonic-pi` again
Sonic Pi contributor @rbnpi has described a [working configuration to
workaround problems starting JACK](https://github.com/samaaron/sonic-pi/issues/827#issuecomment-160928821).
On Linux distributions using PulseAudio, starting JACK may interfere
with the applications using sound that were running already, e.g.
Firefox will stop playing audio once JACK starts. There is a guide on
[how to configure JACK with PulseAudio](https://github.com/jackaudio/jackaudio.github.com/wiki/WalkThrough_User_PulseOnJack)
to avoid this.
----
sonic-pi-2.10.0~repack/HOW-TO-CONTRIBUTE.md 0000664 0000000 0000000 00000006761 12704164724 0017673 0 ustar 00root root 0000000 0000000 # Contributing
Hey, you like Sonic Pi and want to contribute in some way?
That's great, this is an open source project and you're invited to join!
## You have an idea?
If you have any idea on how to improve Sonic Pi, don't hesitate to
[open a new issue](https://github.com/samaaron/sonic-pi/issues) on
GitHub and describe what you have in mind.
You can also visit the
[developers' chat](https://gitter.im/samaaron/sonic-pi) if you want
to discuss your idea directly.
## You need an idea?
If you don't have an itch of your own to scratch, but are still looking
for something to work on, you can first go and browse the
[open issues](https://github.com/samaaron/sonic-pi/issues) on GitHub.
There's probably one among them you can help to fix.
Next to those, here's a list of ideas, frequent feature requests or
unfinished projects that we didn't have time to work on just yet and
where help is appreciated.
### Easy Projects
- Share your teaching material
You're an educator and you have made your own teaching material?
Then share it with the world! A good place to do so is the
[user group](https://groups.google.com/forum/#!forum/sonic-pi).
- Correct us
Proofreading is always helpful. If you find a typo or bad writing,
let us know and [open a new issue](https://github.com/samaaron/sonic-pi/issues)
or, even better, send a pull request on GitHub.
- [Translate Sonic Pi to your language](https://github.com/samaaron/sonic-pi/blob/master/TRANSLATION.md)
It's a wonderful way to introduce school kids in your country to
Sonic Pi and educators will appreciate it when we make it easier for
their class. The tutorial is fairly long, but the graphical user
interface is quickly translated and a good place to start.
### Medium Projects
- Get us in touch with blind or visually impaired users
We think that Sonic Pi would be a pretty awesome tool for blind or
visually impaired users wanting to learn programming. If you can
help us get in touch with one of these users or are one of them,
please let us know. We don't know if the Sonic Pi GUI is useful
and accessible enough for you, so we don't know where to improve it
for your needs. Your input is highly appreciated.
- Save/Load function for buffers
Sonic Pi can save to a file, but it still doesn't have a user-friendly
way to load existing code.
- Optimisation: Identify & fix bottlenecks that waste CPU or RAM
Several different parts work together in Sonic Pi, there's
Supercollider, controlled by a server written in Ruby and
a QT-based GUI on top of it. All this runs on a Raspberry Pi, so even
a small optimisation under the hood may be very helpful in
keeping things smooth. If you love profiling and optimising existing
code we'd love to hear from you.
### Hard Projects
- Sync multiple instances of Sonic Pi on the net
How to play Sonic Pi as an orchestra? Should there be a central
audio server that turns all the clients' code to music? Or is it
possible to synchronise each machine's audio on the net?
- Mobile devices? Porting to Android?
These days, school kids have a smartphone or tablet before they have
their own computer.
It's not possible to build Sonic Pi for iOS, since Apple does not
allow integrating a programming language into iOS apps.
Technically it should be possible for Android, however nobody has
tried that yet. Are you an Android fanboy and willing to maintain a
port?
Or maybe we should explore a client/server architecture instead, so
that we gain a path for an iOS app?
sonic-pi-2.10.0~repack/INSTALL-LINUX.md 0000664 0000000 0000000 00000007750 12704164724 0017244 0 ustar 00root root 0000000 0000000 ## Generic Linux
### Dependencies
Debian package dependency names (Jessie):
`apt-get install supercollider ruby2.1 libqscintilla2-dev ruby-dev cmake pkg-config g++ libfftw3-dev`
For Ubuntu 14.04.3 (Trusty Tahr):
`apt-get install supercollider ruby2.0 libqscintilla2-dev ruby-dev cmake pkg-config g++ libfftw3-dev`
In addition, under Ubuntu 14.04 based distributions try these:
* `libqscintilla2-l10n`
* `qt4-qmake`
* `libqt4-dev`
* `libffi-dev`
If you are using a newer version of QT, you need the according version of scintilla. For QT5 they are:
* `libqt5scintilla2-dev` instead of `libqscintilla2-dev`
* `libqt5scintilla2-l10n` instead of `libqscintilla2-l10n`
Fedora package dependency names:
* `supercollider` (via [Planet CCRMA](http://ccrma.stanford.edu/planetccrma/software/installplanettwenty.html))
* `ruby` (or use [RVM](http://rvm.io/) to manage specific versions)
* `qscintilla-devel` (will install `qscintilla` and `qt-devel`)
* `cmake`
### SuperCollider SC3 Plugins
After installing SuperCollider, you will also need to compile and
install the [SuperCollider SC3 UGen Plugins](https://github.com/supercollider/sc3-plugins)
from source, if your distribution does not provide a binary package of them.
You will need your distribution's `supercollider-dev` package for this step.
```
git clone https://github.com/supercollider/sc3-plugins.git
cd sc3-plugins
git submodule init
git submodule update
git checkout efba3baaea873f4e4d44aec3bb7468dd0938b4a6
cp -r external_libraries/nova-simd/* source/VBAPUGens
mkdir build
cd build
cmake -DSC_PATH=/usr/include/SuperCollider -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
make
sudo make install
```
### Server extensions
Compile the server extensions by `cd`ing into the directory `app/server/bin` and running the script `compile-extensions.rb`. This will take some time.
### Qt GUI
You must compile the server extensions prior to this step.
`cd` into the directory `app/gui/qt/` and run the script `rp-build-app`. This will also take some time.
### Running
Start the jack sound server daemon `jackd`. This is easily done through [qjackctl](http://qjackctl.sourceforge.net/), available as `qjackctl` in Debian.
that didn't work for me, but typing this, after randomly googling and trying various things, did:
`jackd -R -d alsa -d hw:1`
On systems like Ubuntu that run pulseaudio, use
`pasuspender -- jackd -R -d alsa`
Then run the script `sonic-pi` in the directory `app/gui/qt`.
----
## Arch Linux
### AUR Package
Arch Linux users are strongly recommended to install the [sonic-pi-git](https://aur.archlinux.org/packages/sonic-pi-git/) package from the AUR; see the wiki article on the [Arch User Repository](https://wiki.archlinux.org/index.php/Arch_User_Repository) if you are unfamiliar with how to install such a package. The PKGBUILD found in this package will:
* Clone the latest sonic-pi source from GitHub
* Apply a patch to fix a library naming issue
* Build sonic-pi from source, according to the instructions found in [Generic Linux](#generic-linux)
* Install the built software components to `/opt/sonic-pi-git`
* Install the launcher to `/usr/bin/sonic-pi`
After installing, users need to follow the instructions in the [Generic Linux](#generic-linux) section to start the `jackd` server, and then run `sonic-pi` at a command prompt.
### Building from source
Users can opt to build from source as well if they would like. Instructions and dependencies can be found within the PKGBUILD file in the AUR package previously mentioned, as well as the required patch file.
----
## Linux Mint (beta)
### PPA
Tested on Linux Mint 17.2, inspired by [this issue](https://github.com/samaaron/sonic-pi/issues/827).
First, install the binary:
```
sudo add-apt-repository ppa:sonic-pi/ppa
sudo apt-get update
sudo apt-get install sonic-pi
```
Next, install qjackctl:
`sudo apt-get install qjackctl`
Then, launch qjackctl from the command line (while suspending PulseAudio):
`pasuspender -- qjackctl`
Click the 'Start' button in qjackctl, then launch Sonic Pi :)
sonic-pi-2.10.0~repack/INSTALL-MAC.md 0000664 0000000 0000000 00000010332 12704164724 0016733 0 ustar 00root root 0000000 0000000 # Mac OS X
## Dependencies
* Download Qt 5.4+ http://qt-project.org/downloads
* Run the setup wizard and install to a known location which we'll call `/path/to/qt`
* Grab a copy of the QScintilla libs http://www.riverbankcomputing.co.uk/software/qscintilla/download and untar into a known location which we'll call `/path/to/qscintilla`
(current version is QScintilla-gpl-2.9)
* Install SuperCollider 3.6 from http://supercollider.github.io/download.html
* Download SuperCollider extensions from http://sourceforge.net/projects/sc3-plugins/files/OSX_3.6/SC3ExtPlugins-universal.dmg/download and install as per the included README.txt file
* Grab a copy of Sonic Pi's source to a known location (which we'll call `/path/to/sonic-pi/root/`)
- `cd /path/to/sonic-pi/root/`
- `git clone git://github.com/samaaron/sonic-pi.git`
## Create Symlinks for Ruby and SuperCollider's scsynth
* Provide a Ruby version for Sonic Pi to use
- The Qt app expects Ruby to exist at a certain path. We can use a symlink to provide an appropriate Ruby Version
- `cd /path/to/sonic-pi/root/`
- `mkdir -p app/server/native/osx/ruby/bin`
- link the ruby version into place:
- ``ln -s `which ruby` app/server/native/osx/ruby/bin/ruby``
* Provide a SuperCollider scsynth for Sonic Pi to use
- The Qt app expects scsynth to exist at a certain path. We can also use a symlink here.
- `cd /path/to/sonic-pi/root/`
- `cd app/server/native/osx/`
- `ln -s /Applications/SuperCollider/SuperCollider.app/Contents/Resources/scsynth .`
## Compile Ruby Server extensions
### Prerequisites
In order to compile the ruby libraries successfully, make sure you have
the following programs installed:
* [cmake](https://cmake.org)
* [pkg-config](https://www.freedesktop.org/wiki/Software/pkg-config/)
If you want to check whether you have them installed already, you can do
so by typing the following commands in your terminal:
* `cmake` - If installed, it will show the usage of the program
* `pkg-config` - If installed, it will show a message indicating that a
package name should be specified.
Installation of both the programs can be done through Homebrew or MacPorts
### Compiling
Sonic Pi uses some ruby libraries which have native extensions. We need
to compile these with the provided script:
* `cd /path/to/sonic-pi/root/`
* `cd app/server/bin`
* `../native/osx/ruby/bin/ruby compile-extensions.rb`
This will take some time. Ignore the warnings.
## Qt GUI
### Xcode 6 and lower
* Build QScintilla:
- `cd /path/to/qscintilla/Qt4Qt5`
- generate makefile: `/path/to/qt/5.4/clang_64/bin/qmake qscintilla.pro`
- `make`
* Add the following to SonicPi.pro:
```
LIBS += -L /path/to/qscintilla/Qt4Qt5/ -lqscintilla2
INCLUDEPATH += /path/to/qscintilla/Qt4Qt5/
DEPENDPATH += /path/to/qscintilla/Qt4Qt5/
```
* Modify top of mac-build-app appropriately i.e.
```
QSCINTILLA=/path/to/qscintilla/Qt4Qt5
QTBIN=/path/to/qt/5.4/clang_64/bin
```
### Xcode 7+
* Build QScintilla:
- `cd /path/to/qscintilla/Qt4Qt5`
- Add the following to `qscintilla.pro`
QMAKE_MAC_SDK = macosx10.11
- generate makefile: `/path/to/qt/5.4/clang_64/bin/qmake qscintilla.pro`
- `make`
- update the dylib inner path part 1: `install_name_tool -id "/path/to/qscintilla/Qt4Qt5/libqscintilla2.12.dylib" /path/to/qscintilla/Qt4Qt5/libqscintilla2.12.dylib`
- update the dylib inner path part 2: `install_name_tool -change "libqscintilla2.12.dylib" "/path/to/qscintilla/Qt4Qt5/libqscintilla2.12.dylib" /path/to/qscintilla/Qt4Qt5/libqscintilla2.12.dylib`
* Add the following to SonicPi.pro
```
LIBS += -L /path/to/qscintilla/Qt4Qt5/ -lqscintilla2
INCLUDEPATH += /path/to/qscintilla/Qt4Qt5/
DEPENDPATH += /path/to/qscintilla/Qt4Qt5/
```
* Add the following to SonicPi.pro
```
QMAKE_MAC_SDK = macosx10.11
```
* Modify top of mac-build-app appropriately i.e.
```
QSCINTILLA=/path/to/qscintilla/Qt4Qt5
QTBIN=/path/to/qt/5.4/clang_64/bin
```
## Building the App
Finally, we need to build the OS X App
* `cd /path/to/sonic-pi/root/`
* `cd app/gui/qt`
* `./mac-build-app`
* App should be in `build` dir which you can either launch via Finder or via the following from the `qt` dir:
* `./build/Sonic\ Pi.app/Contents/MacOS/Sonic\ Pi`
Sonic Pi should now boot successfully.
sonic-pi-2.10.0~repack/INSTALL-RASPBERRY-PI.md 0000664 0000000 0000000 00000001577 12704164724 0020225 0 ustar 00root root 0000000 0000000
## Raspberry Pi
The Raspberry Pi will happily compile all the required aspects of Sonic
Pi. However, be warned that it will take quite some time to complete.
First grab the dependencies, compile the server extensions, then the GUI then start the app.
### Dependencies
The dependencies for building and running this are:
* `supercollider`
* `ruby1.9.3`
* `libqscintilla2-8`
* `libqscintilla2-dev`
* `qt4-dev-tools`
* `cmake`
* `ruby-dev`
* `libffi-dev`
Use `sudo apt-get install` to ensure each of these are on your system.
### Server extensions
Compile the server extensions by `cd`ing into the directory `app/server/bin` and running the script `compile-extensions.rb`. This will take some time.
### Qt GUI
`cd` into the directory `app/gui/qt/` and run the script `rp-build-app`. This will also take some time.
### Running
Run the script `rp-app-bin` in the directory `app/gui/qt`.
sonic-pi-2.10.0~repack/INSTALL-WINDOWS.md 0000664 0000000 0000000 00000030632 12704164724 0017472 0 ustar 00root root 0000000 0000000 # SONIC PI DETAILED BUILD YOUR OWN INSTRUCTIONS FOR WINDOWS 10 BASED ON LATEST SP 2.9dev after e7fde3a
Last revision 29th December 2015 @ 7:32PM AWST (minor grammar improvement)
Tested on Windows 10 64bit (running under vmware fusion on a Mac) and Windows 7 64bit.
This document details the process from beginning to end to build Sonic Pi 2.9dev and I hope it will be useful to others, and encourage them to have a go themselves.
First there is quite a bit of software to install to facilitate the build, not least the source files for Sonic Pi.
First install **git** from https://msysgit.github.io/ click **download** then run `Git-2.6.3-64-bit.exe` I selected options **Use git from Windows Command Prompt**, **Checkout Windows-style**, **commit Unix-style line endings**, **Use Windows default console window**, and **Enable file system caching**
Now install the **Sonic Pi source files**. I put mine at the top level of the c: drive
Start a command window by typing **cmd** in the search field
```
cd c:/
git clone https://github.com/samaaron/sonic-pi.git
```
Now download **Visual Studio Express 2013 for Windows Desktop with Update 5** from
https://www.visualstudio.com/downloads/download-visual-studio-vs
scroll down the page and find **Visual Studio 2013**, and then **Express 2013 for Desktop**.
You can either choose **Web Installer** or **ISO** depending upon whether you want to install over the web or download a complete 3.3Gb and install from that. I did the full download, mounted the iso disk image and installed from that.
Download **Qt**. use **version 5.5.1** as version 5.4.x is NOT qualified for Windows 10
I went to http://www.qt.io/download-open-source/#section-2
And selected **Qt 5.5.1 for Windows 32-bit (VS 2013, 804 MB)**
http://download.qt.io/official_releases/qt/5.5/5.5.1/qt-opensource-windows-x86-msvc2013-5.5.1.exe
After download, I ran the installer, accepting the default settings, which installs Qt at
```C:\Qt\Qt5.5.1``` (I skipped setting up an account!)
Install **cmake** from the link http://www.cmake.org/download
Scroll down and select ```cmake-3.4.1-win32-x86.exe``` and download.
Run the installer, selecting the option **Add to the System PATH for all (or current) users**
Install **Ruby** from http://rubyinstaller.org/downloads/
I choose **Ruby 2.2.3** although the install works with 2.1.7 with minor alterations which are detailed below.
Choose the **32 bit version**
Run the installer when downloaded. Choose the default install ```c:\Ruby22``` (C:\Ruby21 if you use Ruby2.1.7)
Select **add Ruby Executables to your path** and **associate .rb and .rbw files with this installation**.
Scroll further down the page of http://rubyinstaller.org/downloads/ and select
```DevKit-mingw64-32-4.7.2-20130224-1151-sfx.exe``` and download that as well
Make sure you use the **32 bit version for Ruby 2.0 and higher**.
When downloaded, run this and set the extract location to ```c:\RubyDev```
Now you have to complete the installation as follows:
In a command window
```
cd c:\RubyDev
ruby dk.rb init
```
This will create a file ```config.yml``` inside the ```RubyDev``` folder
Check its contents by typing;
```Notepad config.yml```
You should see a line ``` - C:\Ruby22```
at the end of the file. ( - C:\Ruby21 if you use Ruby2.1.7)
Close notepad
Now type
```ruby dk.rb install```
Now you add two files from **pkgconfiglite**
Open the link
http://sourceforge.net/projects/pkgconfiglite/files
and select
**Looking for the latest version? Download pkg-config-lite-0.28-1_bin-win32.zip (47.7 kB)**
When the file has downloaded, extract and then copy the file ```pkg-config``` from the ```bin``` folder to ```c:\RubyDev\bin```
and the file ```pkg.m4``` from the ```share\aclocal``` folder to ```c:\RubyDev\share\aclocal```
That completes the setup for RubyDev
### Preparing the Ruby section
This section of the Sonic Pi install.md file should be completed next BEFORE attempting the section **Qt GUI** (unlike in the original install.md document) as the final build in this section requires one of the gems to be installed before it is run.
Copy ```c:\ruby22\*``` into ```c:\sonic-pi\apps\server\native\windows\ruby```
(amend to c:\Ruby21\* if you use Ruby2.1.7)
You will need to create the last two folders windows\ruby before doing this, which is best done from a File Explorer window. The copying is also best done using **two** File Explorer windows, one set to ```c:\Ruby22``` (or C:Ruby21 if you use Ruby2.1.7) and the other to ```c:\sonic-pi\app\server\native\windows\ruby```
You can leave out the **Doc** folder and the two **unins000** files.
Now open a cmd window and navigate to c:\sonic-pi\app\server\native\windows\ruby
From there we will install gem files required by Sonic Pi
```.\bin\gem install did_you_mean```
(allow access if you are asked). The install may take a little time. Eventually it will say two gems installed (did_you_mean and interception)
```.\bin\gem install ffi```
Another gem recently added, that is needed specifically for the windows install is ```win32-process```
```.\bin\gem install win32-process```
The fourth gem file is problematical, and needs a patch to install. It goes like this:
```.\bin\gem fetch rugged```
This will fetch the latest version which is rugged-0.23.3
```
.\bin\gem unpack rugged-0.23.3.gem
.\bin\gem spec rugged-0.23.3.gem --ruby > rugged-0.23.3\rugged.gemspec
```
Now we have to apply a patch to one of the files.
```
cd rugged-0.23.3\ext\rugged
notepad extconf.rb
```
In the notepad window select **Find** from the Edit Menu (**ctrl+F**) and search for
```Unix Makefiles\””)```
and change it to read
```Unix Makefiles\" -DCMAKE_INSTALL_PREFIX=C:/ -DWINHTTP=OFF")```
NB: this may no longer be needed with current versions of rugged
Then resave the file and quit notepad.
Go back to the cmd window
```cd ..\..\```
you should be back in the folder ```c:\sonic-pi\app\server\native\windows\ruby\rugged-0.23.3```
Now build the patched rugged
```
..\bin\gem build rugged.gemspec
..\bin\gem install rugged-0.23.3.gem
```
NB: rb-native is not being used for Windows packages, the gems can happily live where they were installed by the "local" Ruby. You MAY need to delete the vendor/rugged directory so it uses the right version.
That completes the ruby preparation work. Close the cmd and FileExplorer windows.
### Preparing the Qt GUI
From the **Start Button** select **All apps** and scroll down to **Visual Studio 2013**, and then to **Visual Studio Tools**. From the Window that opens **right click** **VS2013 x86 Native Tools Command Prompt** and **Pin it to the Taskbar**. **Double click it** there to open a window which should be titled **VS2013 x86 Native Tools Command Prompt**.
Type **path** in that window after the prompt and press the enter key.
You will see a long string of folder locations which comprise the path associated with the window, which it will automatically search. It includes links to the various elements of visual studio. However, we have to add one more item, which is the path of the Qt bin directory.
Since the Visual Studio prompt path is rebuilt each time a window is opened, I have found the convenient way to do this is to create a **batch file** which can be run each time to add the additional entry. Since I want to store this at the C:\ top level, we have to run the cmd window with administrative privileges to create it.
Close the open Visual Studio Command Prompt window, then reopen it, holding down **Shift** and **Ctrl** when you do so. Say **Yes** to the popup window, and you will then have a cmd window with admin privileges.
```
cd c:\
notepad
```
In the open notepad window type
```
PATH=%PATH%;C:\Qt\Qt5.5.1\5.5\msvc2013\bin
```
Then select **save** and save the file as ```pathupdate.bat```, at the top level of ```c:\``` Make sure you select **All Files** for the type so the extension can be set to **.bat** and NOT **.txt**
Close notepad and type ```dir``` (and press return) You should see the file ```pathupdate.bat``` listed.
Close the cmd window and double click the icon on the taskbar to reopen it with "normal" privileges.
```
cd c:\
pathupdate.bat
```
You should see the long path as before, but now with an additional entry ```C:\Qt\Qt5.5.1\5.5\msvc2013\bin``` at the end
Leave this window open.
Download **Qscintilla** from https://www.riverbankcomputing.com/software/qscintilla/download
Select the ```Qscintilla-gpl-2.9.1.zip``` file to download
When downloaded extract the ```Qscintilla-gpl-2.9.1``` folder to ```c:\```
Return to the visual studio command window.
```
cd c:\QScintilla-gpl-2.9.1\Qt4Qt5
qmake qscintilla.pro
nmake
```
(it will now be compiled)
```
nmake install
```
keep the cmd window open
copy ```Qt4Qt5\release\moc_qsciscintilla.cpp``` and ```moc_qsciscintillabase.cpp``` to
```c:\sonic-pi\app\gui\qt\platform\win``` (There may be two files there already, but overwrite them)
Best done using two FileExplorer windows as before.
Now we do the main build of Sonic-Pi gui, using the open cmd window.
```
cd c:\sonic-pi
.\app\gui\qt\win-build-app.bat
```
This should carry out the build. Don’t worry about various warnings en route.
We now add some files from visual studio which will be needed at run time.
Open two FileExplorer windows. In the first navigate to:
```Local Disk (C:)> Program Files (x86) > Microsoft Visual Studio 12.0 > VC > redist > x86 > Microsoft.VC120.CRT```
In the second to
```Local Disk (C:)> sonic-pi> app > gui > qt > release```
Copy msvcp120.dll and msvcr120.dll from the former to the latter.
In the second window navigate to **sonic-pi.exe** and **right-click** it to create a shortcut. Drag the shortcut to the desktop. Do NOT attempt to run it yet.
### The final stage deals with SuperCollider
Install SuperCollider from http://supercollider.github.io/download.html
Select the **Win32 3.6.6** installer and download it
Run the installer
Download additional SuperCollider plugins from
http://sourceforge.net/projects/sc3-plugins/files/sc3-plugins%20Windows/
Select the latest version link at the top of the page and download
```Looking for the latest version? Download sc3-plugins-3.6.0-win32.zip (10.3 MB)```
Extract them in the download folder.
NB: The current Sonic Pi 2.9 is packaged with sc3-plugins 3.7.0-beta (f978dc2), which can be compiled in an MSYS environment as follows:
* install FFTW3 binaries from ftp://ftp.fftw.org/pub/fftw/fftw-3.3.4-dll32.zip to `/home/sc/fftw3.3.4-dll32` for example
* `git clone https://github.com/supercollider/sc3-plugins.git`
* `cd sc3-plugins && git submodule init && git submodule update`
* `mkdir build && cd build`
* `cmake -DSC_PATH=/home/sc/sources/supercollider/ -DFFTW3F_LIBRARY=/home/sc/fft w-3.3.4-dll32/libfftw3f-3.dll -DFFTW3F_INCLUDE_DIR=/home/sc/fftw3.3.4-dll32 -G "Unix Makefiles" ..`
* manually add `-IC:/msys/home/sc/fftw-3.3.4-dll32/` to `build/source/CMakeFiles/PitchDetection.dir/includes_CXX.rsp` (no idea why)
* make install
* copy SCX files from `c:\program files (x86)\sc3-plugins` or wherever it installs them
We now copy files to the sonic-pi installation.
With two FileExplorer windows navigate the first to ```Local Disk (C:) >Program Files (x86) > SuperCollider```
And the second (destination) to ```Local Disk (C:)> sonic-pi > app > server > native > windows```
Copy the ```plugins``` folder from the former to the latter.
Copy all dll files **EXCEPT those starting with QT** from the former to the latter.
Copy ```scsynth.exe``` from the former to the latter.
Keep these windows open for the moment.
Open the ```sc3-plugins-3.6.0-win32``` folder in the Downloads folder and navigate to ```SC3-plugins```.
Copy all the *.scx files that folder into the ```plugins``` folder copied to destination folder in the previous step.
Close the open FileExplorer windows.
There is one final patch to install. The Ugen file associated with the Piano synth was updated in the summer, to eliminate a problem with the tuning. Unfortunately the current Ugen has NOT yet been updated for windows, and consequently we have to use a modified version of the MdaUgen. This can be downloaded from https://goo.gl/K316fw
Extract the contents and follow the instructions in the readme file. Basically you replace the file ```sonic-pi-piano.scsyndef``` in ```c:\sonic-pi\etc\synthdefs\compiled``` with the one downloaded in the patch.
(You may like to retain a copy of the original before overwriting it, or perhaps rename it to ```sonic-pi-piano.scsyndef.original```)
### Finished!
That should complete the installation of Sonic Pi.
Try running it by double clicking the Sonic Pi shortcut on the desktop.
Robin Newman, 17th December 2015
sonic-pi-2.10.0~repack/INSTALL.md 0000664 0000000 0000000 00000004265 12704164724 0016345 0 ustar 00root root 0000000 0000000 # Installing Sonic Pi from Source
If you want to use the very latest development version of Sonic Pi, then
you'll need to compile from source. Due to the complex nature of Sonic
Pi's architecture this should only be considered by those happy playing
around with the Terminal and are happy working with bleeding edge
software.
For all other users, downloading the latest pre-built app for your
platform is highly recommended: http://sonic-pi.net
There are instructions for the following platforms in their own separate
files:
* Raspberry Pi - `INSTALL-RASPBERRY-PI.md`
* Windows - `INSTALL-WINDOWS.md`
* Mac - `INSTALL-MAC.md`
* Linux - `INSTALL-LINUX.md`
----
## Optional: Sonic Pi reference books
Do you want to read the Sonic Pi tutorial as a whole, e.g. on your
mobile reader or printed out on paper?
During the Qt GUI build process, the directory `app/gui/qt/book` will
be generated, containing each section of the integrated help system
as a printable HTML reference book document.
As an optional step after the build process, you can convert these HTML
files to more convenient PDFs using the `./create-pdf` script.
On your Linux or OS X system, you will need to have installed
* [wkhtmltopdf](http://wkhtmltopdf.org)
(Note: On Ubuntu, you will need the
[wkhtmltopdf binary with a patched Qt](http://wkhtmltopdf.org/downloads.html)
from their site, as Ubuntu's own binary package does not support all
features needed for a clean PDF conversion.)
----
## Unsupported development HTML Interface
Note: This interface isn't always kept up to date with MASTER on Github.
The dependencies for this are:
* SuperCollider
* Ruby 1.9.3+
If you wish to play with the (development) HTML interface on OS X:
* Install SuperCollider manually (the Mac OS X app): http://supercollider.sourceforge.net
* Download a tar ball of the latest version of Sonic Pi: https://github.com/samaaron/sonic-pi/
* Unzip the tar ball somewhere useful
* Install JDK 1.6+ and Leiningen (to compile ClojureScript -> Javascript, not for running the app)
* Compile the `cljs` source: `cd app/gui/html`, `lein cljsbuild once`
* Start the server: `cd app/server/bin`, `ruby ws.rb`
* Open a browser and go to `http://localhost:8000`
sonic-pi-2.10.0~repack/LICENSE.md 0000664 0000000 0000000 00000015515 12704164724 0016321 0 ustar 00root root 0000000 0000000 # License
## Main Source
(contents of [app/](https://github.com/samaaron/sonic-pi/tree/master/app) and [etc/synthdefs/](https://github.com/samaaron/sonic-pi/tree/master/etc/synthdefs) directories)
The MIT License (MIT)
Copyright (c) 2013, 2014, 2015, 2016 Samuel Aaron ([http://sam.aaron.name](http://sam.aaron.name))
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
## GUI
As the Sonic Pi GUI links with the GPLv3-licensed QScintilla2,
distributors of Sonic Pi GUI binaries must comply with the terms of the
GPL
## Docs, Tutorial and Examples
(contents of [etc/doc/](https://github.com/samaaron/sonic-pi/tree/master/etc/doc) and [etc/examples](https://github.com/samaaron/sonic-pi/tree/master/etc/examples) directories)
All the examples (in
[etc/examples](https://github.com/samaaron/sonic-pi/tree/master/etc/examples))
and contents of the doc directory including the articles and the
tutorial are copyright by Sam Aaron unless a specific author is stated
with the comment `# coded by ...` in which case the copyright is
associated with that author (2015) and the content is released under the
CC BY-SA 4.0 license:
[http://creativecommons.org/licenses/by-sa/4.0/](http://creativecommons.org/licenses/by-sa/4.0/)
## Samples
(contents of [etc/samples/](https://github.com/samaaron/sonic-pi/tree/master/etc/samples))
All the bundled samples are individually licensed under a
[CC0 1.0 Universal Public Domain Dedication](http://creativecommons.org/publicdomain/zero/1.0/). They
have all been obtained from [freesound.org](http://freesound.org) and
links to their sources can be found in the file
[etc/samples/README.md](https://github.com/samaaron/sonic-pi/blob/master/etc/samples/README.md)
[http://creativecommons.org/publicdomain/zero/1.0/](http://creativecommons.org/publicdomain/zero/1.0/)
## Wavetables
(contents of [etc/wavetables/](https://github.com/samaaron/sonic-pi/tree/master/etc/wavetables)
All the bundled wavetable samples are individually licensed under a
[CC0 1.0 Universal Public Domain Dedication](http://creativecommons.org/publicdomain/zero/1.0/). They
have been obtained from the
[Adventure Kid](http://www.adventurekid.se/akrt/waveforms/adventure-kid-waveforms/)
site.
## Bundled Software
The following is a list of the software included in Sonic Pi with their
relevant licenses:
### Unlinked software
* [Ruby](http://ruby-lang.org) - [Ruby License](https://www.ruby-lang.org/en/about/license.txt)
* [SuperCollider](http://supercollider.sourceforge.net) - [GNU General Public License v3](http://www.gnu.org/copyleft/gpl.html)
### Dynamically Linked Libraries for GUI
* [Qt](http://qt-project.org) - [LGPL v2.1](https://www.gnu.org/licenses/lgpl-2.1.html)
* [QScintilla2](http://www.riverbankcomputing.com/software/qscintilla/intro) - [GPL v2](https://tldrlegal.com/license/gnu-general-public-license-v2)
### Included Ruby Libraries for Server
(contents of [app/server/vendor/](https://github.com/samaaron/sonic-pi/tree/master/app/server/vendor))
* [ActiveSupport](https://github.com/rails/rails/tree/master/activesupport) - [MIT License](http://opensource.org/licenses/MIT)
* [Atomic](http://github.com/headius/ruby-atomic) - [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
* [Blankslate](https://github.com/masover/blankslate) - [MIT License](http://opensource.org/licenses/MIT)
* [Did You Mean](https://github.com/yuki24/did_you_mean) - [MIT License](http://opensource.org/licenses/MIT)
* [FFI](https://github.com/ffi/ffi) - [BSD 3-Clause License](http://opensource.org/licenses/BSD-3-Clause)
* [Hamster](https://github.com/hamstergem/hamster) - [MIT License](http://opensource.org/licenses/MIT)
* [i81n](https://github.com/svenfuchs/i18n) - [MIT License](http://opensource.org/licenses/MIT)
* [Interception](https://github.com/ConradIrwin/interception) - [MIT License](http://opensource.org/licenses/MIT)
* [Kramdown](http://kramdown.gettalong.org) - [MIT License](http://opensource.org/licenses/MIT)
* [Multi JSON](https://github.com/intridea/multi_json) - [MIT License](http://opensource.org/licenses/MIT)
* [Parslet](http://kschiess.github.io/parslet/) - [MIT License](http://opensource.org/licenses/MIT)
* [Rouge](https://github.com/jneen/rouge) - [MIT License](http://opensource.org/licenses/MIT)
* [Rubame](https://github.com/saward/Rubame) - [MIT License](http://opensource.org/licenses/MIT)
* [Ruby Beautify](https://github.com/erniebrodeur/ruby-beautify) - [MIT License](http://opensource.org/licenses/MIT)
* [Ruby Prof](https://github.com/ruby-prof/ruby-prof) - [BSD 2-Clause License](http://opensource.org/licenses/BSD-2-Clause) - [MIT License](http://opensource.org/licenses/MIT)
* [Rugged](https://github.com/libgit2/rugged) - [MIT License](http://opensource.org/licenses/MIT)
* [Thread Safe](https://github.com/ruby-concurrency/thread_safe) - [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0.html)
* [Websocket](https://github.com/imanel/websocket-ruby) - [MIT License](http://opensource.org/licenses/MIT)
* [NArray](https://github.com/masa16/narray) - [Ruby License](https://www.ruby-lang.org/en/about/license.txt)
* [Ruby CoreAudio](https://github.com/nagachika/ruby-coreaudio) - [MIT License](http://opensource.org/licenses/MIT)
* [WaveFile](https://github.com/jstrait/wavefile/) - [MIT License](http://opensource.org/licenses/MIT)
* [Benchmark-IPS](https://github.com/evanphx/benchmark-ips) - [MIT License](http://opensource.org/licenses/MIT)
* [Mocha](http://gofreerange.com/mocha/docs/) - [MIT License](http://opensource.org/licenses/MIT)
* [MiniTest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - [Ruby License](https://www.ruby-lang.org/en/about/license.txt)
* [AST](https://github.com/whitequark/ast) - [MIT License](http://opensource.org/licenses/MIT)
* [Parser](https://github.com/whitequark/parser) - [MIT License](http://opensource.org/licenses/MIT)
* [Metaclass](https://github.com/floehopper/metaclass) - [MIT License](http://opensource.org/licenses/MIT)
sonic-pi-2.10.0~repack/README.md 0000664 0000000 0000000 00000012003 12704164724 0016161 0 ustar 00root root 0000000 0000000 ╘
─ ╛▒╛
▐╫ ▄█├
─╟╛ █▄ ╪▓▀
╓┤┤┤┤┤┤┤┤┤ ╩▌ ██ ▀▓▌
▐▒ ╬▒ ╟▓╘ ─▓█ ▓▓├
▒╫ ▒╪ ▓█ ▓▓─ ▓▓▄
╒▒─ │▒ ▓█ ▓▓ ─▓▓─
╬▒ ▄▒ ╒ ╪▓═ ╬▓╬ ▌▓▄
╥╒ ╦╥ ╕█╒ ╙▓▐ ▄▓╫
▐╩ ▒▒ ▀▀
╒╪ ▐▄
_____ __ ____ __
/ ___/____ ____ /_/____ / __ \/_/
\__ \/ __ \/ __ \/ / ___/ / /_/ / /
___/ / /_/ / / / / / /__ / ____/ /
/____/\____/_/ /_/_/\___/ /_/ /_/
## The Live Coding Synth for Everyone.
Sonic Pi is a *new kind of musical instrument*. Instead of strumming
strings or whacking things with sticks - you write code - **live**.
Sonic Pi has been designed with the aim to find a harmonious balance
between three core principles:
* **Simple** enough for the 10 year old within you
* **Joyful** enough for you to lose yourself through play
* **Powerful** enough for your own expressions
Sonic Pi is a complete open source programming environment originally
designed to explore and *teach programming concepts* within schools through
the process of creating *new sounds*.
In addition to being an engaging education resource it has evolved into
an *extremely powerful* and performance-ready *live coding instrument* suitable
for professional artists and DJs.
Whilst Education is a core focus it now sits at the intersection
between three core domains:
* **Art** - providing the means to express yourself and ask new questions of music and notation
* **Technology** - exploring questions related to liveness, time and concurrency in programming languages
* **Education** - demonstrating that open play rather than rigid structures increases motivation and engagement in the classroom
Again, finding a balance working to the best benefits of all these
domains is the objective.
* Info & Latest Releases: http://sonic-pi.net
* Source: https://github.com/samaaron/sonic-pi
* Computing Education Resources for Schools: http://www.raspberrypi.org/learning/sonic-pi-lessons/
* Music Education Toolkit for Schools: http://sonicpiliveandcoding.com
## Acknowledgements
Sonic Pi has been developed within the Computer Laboratory at the
University of Cambridge with kind support from the Raspberry Pi
Foundation and the Broadcom Foundation.
## Translations
Sonic Pi's built in tutorial has been translated into several languages thanks to the awesome work of the following contributors.
\- | Language | Status | Maintainer | Contributors |
------------ | ------------- | ---------- | ------------ | ------------ |
:fr: | French | merged | | @echevresm, @nicoder, @SergeStinckwich |
:de: | German | merged | | @hzulla, G. Martin Butz, @hztirf, @mbutz, @wwerner, @st01c |
:jp: | Japanese | merged | | @keikomachiya |
:pl: | Polish | merged | @hopbit | @hopbit, @nurkiewicz |
:it: | Italian | in progress | | @marco-giordano |
:ru: | Russian | in progress | | @RomanSaveljev, @dcromster |
:pt: | Portuguese | in progress | | @SiIky |
:sp: | Spanish | in progress | | @merongivian, @thraex41 |
:nl: | Dutch | in progress | @DuchessFounder | @DuchessFounder, @PrisDiest |
:gr: | Greek | in progress | @aspra | @aspra |
:nb: | Norwegian Bokmål | in progress | @petterreinholdtsen | @petterreinholdtsen |
Would you like to contribute a translation too? If so, please take a look at our [translation docs](https://github.com/samaaron/sonic-pi/blob/master/TRANSLATION.md) to get started. Additionally [here](https://github.com/samaaron/sonic-pi/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen+i18n) you can find translations (i18n) related issues.
## Information for developers
Sonic Pi is under active development, and welcomes new contributors:
* [How to contribute](HOW-TO-CONTRIBUTE.md)
* [Change log](CHANGELOG.md)
* [Community](COMMUNITY.md)
* [Contributors](CONTRIBUTORS.md)
* [Installation](INSTALL.md)
* [License](LICENSE.md)
* [Testing](TESTING.md)
* [Translation](TRANSLATION.md)
[](https://gitter.im/samaaron/sonic-pi?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
Sam Aaron
Xavier Riley
Jeremy Weatherford
Joseph Wilk
Performing as Repl Electric.
Hanno Zulla
[](https://travis-ci.org/samaaron/sonic-pi)
sonic-pi-2.10.0~repack/SYNTH_DESIGN.md 0000664 0000000 0000000 00000011334 12704164724 0017170 0 ustar 00root root 0000000 0000000 # Synth Design
The sounds you hear in Sonic Pi are all produced by the SuperCollider
synthesis engine. These synths and effects have to be defined beforehand
in a special kind of binary file called a `synthdef`. The built in
synthdefs are loaded up on boot so they are ready to trigger. All the
`synthdef`s that ship with Sonic Pi are designed in a Clojure based
library called [Overtone](https://overtone.github.io). You can find the
existing synth designs in the folder
```
etc/synthdefs/designs/sonic_pi/synths/
```
If you wish to contribute synths to Sonic Pi then they need to be in
this format. However, it is also very easy to write and trigger your own
synthdefs in SuperCollider language if you are already familiar with
that.
## Synth design constraints
Also if you want your synth to work with Sonic Pi's automatic stereo
sound infrastructure *you need to ensure your synth outputs a stereo
signal* to an audio bus with an index specified by a synth arg named
`out_bus`.
Additionally, your synth must self-terminate at some point - Sonic Pi
will *not* tidy up zombied synths.
## Editing the synthdefs
You'll need the following to be able to compile the synths yourself
* the latest version of Overtone (`git clone git@github.com:overtone/overtone.git`)
* leiningen (`brew install leiningen`)
* A text editor setup to work with Clojure
After cloning the Overtone repo, cd into the folder and edit the `project.clj` file to add
the Sonic Pi synthdefs folder to the locations it looks in when requiring Clojure files.
```
:native-path "native"
:min-lein-version "2.0.0"
;; this is the line to add
:source-paths ["src" "/Users/foo/sonic-pi/etc/synthdefs/designs"]
;; make sure the path points to your installation of Sonic Pi
```
### Starting a REPL
`cd` into the Overtone folder and run
```
$ lein repl
```
Make a note of the port number that nREPL starts on
```
nREPL server started on port 49223 ...
```
### Connecting the editor to the REPL and booting Overtone
If you're using `vim` and `vim-fireplace`:
* open a new terminal window
* `cd` back into the Sonic Pi folder
* Open `etc/synthdefs/designs/sonic_pi/synths/core.clj`
* type `:Connect` then hit enter
* when prompted, enter the nREPL port number from earlier
* Visual select the namespace definition and type `:` followed by `Eval` then enter
This should start booting Overtone which will take a little while. If there are no errors,
your vim is successfully hooked up to Overtone!
If you're using `emacs`
* open a new terminal window
* open `emacs` and go to the `project.clj` for Overtone
* `M-x cider-jack-in` to connect to the running nREPL
* Navigate back into the Sonic Pi folder and open `etc/synthdefs/designs/sonic_pi/synths/core.clj`
* Evaluate the namespace as you normally would for Clojure in emacs
## The synth design file
Taking the example of a basic synth lets have a look at what the bits are doing
```
(ns sonic-pi.synths.studio
(:use [overtone.live])
(:require [sonic-pi.synths.core :as core]))
(do
(without-namespace-in-synthdef
(defsynth sonic-pi-recorder
[out-buf 0 in_bus 0]
(disk-out out-buf (in in_bus 2))))
(uncomment
(core/save-synthdef sonic-pi-recorder)))
```
This is the definition used to define the record functionality in Sonic
Pi.
The `without-namespace-in-synthdef` from `sonic-pi.synths.core` needs to
wrap the `defsynth` for the synth to follow the correct naming
convention.
The `core/save-synthdef` manages the workflow for saving the compiled
synthdef file into the correct folder and also the graphviz design which
is used for documentation.
By evaluating the whole form this should cause all the files to be saved
to the correct places.
## Compiling your synths using SuperCollider
If you're just experimenting or wishing to build your own synthdefs and
already know SuperCollider, there's no need to use Overtone. Simply
define your synth and use the writeDefFile command to store the compiled
synthdef into a directory of your choice. You can then dynamically load
your synthdefs with the `load_synthdefs` fn.
(
SynthDef(\\piTest,
{|freq = 200, amp = 1, out_bus = 0 |
Out.ar(out_bus,
SinOsc.ar([freq,freq],0,0.5)* Line.kr(1, 0, 5, amp, doneAction: 2))}
).writeDefFile(\"/Users/sam/Desktop/my-synths\") ;
)
## Making the synth available in Sonic Pi
To make the synths available simply call `load_synthdefs` with the path
to the folder containing the synthdefs you've compiled and they'll be
immediately available to Sonic Pi via the `synth` fn.
However, if you want the synths to be visible to the GUI you'll need to
add the appropriate metadata to
`app/server/sonicpi/lib/sonicpi/synths/synthinfo.rb` and re-compile the
app.
Have fun!
sonic-pi-2.10.0~repack/TESTING.md 0000664 0000000 0000000 00000003763 12704164724 0016356 0 ustar 00root root 0000000 0000000 # Testing and Profiling
This is a short document to help out anyone who wants to
contribute to development of Sonic Pi. To do that you should
try to use (and add to) the test suites.
## Running the tests
Sonic Pi doesn't have a database, so the tests are quite a lot
simpler than your average web app.
```
$ cd app/server/sonicpi/test
$ rake test
```
This should run all the tests for you.
If you have an error like this:
```
Warning: you should require 'minitest/autorun' instead.
Warning: or add 'gem "minitest"' before 'require "minitest/autorun"'
```
You may find you need to run the following.
```
$ gem install test-unit
```
## Profiling
Sonic Pi is a truly multi-threaded system with communications via OSC
(open sound control) being sent between the Qt GUI, the Ruby server and
the scsynth synthesis server. As a result, profiling has proved to be tricky.
### Profiling the Ruby server
The following is a suggestion for how one might go about profiling the Ruby
elements of Sonic Pi. This assumes you are using Ruby 2.1 or greater.
1. `gem install ruby-prof`
2. (optional) Clone [this repo](https://github.com/xavriley/tinyosc), run `build.sh` followed by `./tinyosc 4557`
This is just to provide a receiver for the OSC message that are sent to the GUI
on port 4557. If you don't do this you'll see some error messages to do with connections.
3. `gem install sonic-pi-cli` - for version 2.7 dev and above you may need to install from this repo: https://github.com/xavriley/sonic-pi-cli
4. Run this command from the root dir of Sonic Pi
```
$ ruby-prof -p multi ./app/server/bin/sonic-pi-server.rb
```
5. Run this command (again from the root dir) to send some code to Sonic Pi
```
$ cat etc/examples/wizard/tilburg.rb | sonic_pi
```
6. After letting it run for a while, run `sonic_pi stop` in a fresh terminal
and then Ctrl+C the sonic-pi-server.rb process. This should create several
files in the root folder containing profiling information.
### Profiling the Qt GUI
TODO
### Profiling `scsynth`
TODO
sonic-pi-2.10.0~repack/TRANSLATION.md 0000664 0000000 0000000 00000004230 12704164724 0017025 0 ustar 00root root 0000000 0000000 # Translating Sonic Pi
At present, you can translate the tutorial and the Qt GUI, only.
Translations for the tutorial are located in
[`etc/doc/tutorial`](./etc/doc/tutorial/).
Translations for the Qt GUI are located in
[`app/gui/qt/lang/sonic-pi_ _____ __ ____ __
/ ___/____ ____ /_/____ / __ \/_/
\__ \/ __ \/ __ \/ / ___/ / /_/ / /
___/ / /_/ / / / / / /__ / ____/ /
/____/\____/_/ /_/_/\___/ /_/ /_/
music_as :code
code_as :art
v2.10
sonic-pi-2.10.0~repack/app/gui/qt/html/info.html 0000664 0000000 0000000 00000001344 12704164724 0021465 0 ustar 00root root 0000000 0000000
The Live Coding Synth for Everyone
Designed and crafted by Sam Aaron
in Cambridge, England
For the latest updates follow
@sonic_pi
music_as :code code_as :art
v2.10
This is Sonic Pi
the live coding music environment
To get started please follow the
tutorial in the help system below
(which you can always access via the Help button)
and remember...
with live coding
there are no mistakes
only opportunities
Have fun and share your code
for others to jam with