la caratteristica dell'improvvisazione nel Live Coding contraddice molte delle ipotesi fondamentali su cui si basano le leggi sul Copyright; la caratteristica di fissità dell'opera d'arte, nel Live Coding non è presente, essendo ogni opera parziale e diversa in ogni performance; questa contraddizione può essere utilizzata per resistere alle gabbie legali ed economiche che oggi cercano in ogni modo di imprigionare i beni culturali digitali e l'arte digitale in generale; il Live Coding può sviluppare una posizione critica e forte contro gli squilibri e le ingiustizie del regime della proprietà intellettuale e contro ogni nozione obsoleta di proprietà culturale esclusiva; integrando le emergenti pratiche artistiche con le critiche alla proprietà intellettuale, questa forma di arte e resistenza può fare molto per opporsi a queste leggi e per proporre interessanti alternative;

La maggioparte dei creativi/artisti che opera con i media digitali è sempre più preoccupata dell'impatto negativo, che la continua espansione del regime della proprietà intellettuale, ha sulle creazioni digitali; Gli artisti del Live Coding non fanno eccezione; nella loro pratica quotidiana, incontrano materiale protetto da Copyright, materiale brevettato sotto forma di codice proprietario, formati di file proprietari e software proprietario; nell'odierno panorama della rete e delle comunicazioni digitali, quasi tutto può essere condiviso, copiato, riutilizzato, non solo per essere "rubato", ma anche per essere riproposto, parodiato, migliorato; in teoria, tutto questo dovrebbe facilitare e amplificare le attività creative; eppure il clima culturale generale, fortemente influenzato dalla politica neoliberitsta (capitalismo del libero mercato) e della proprietà privata, ci spinge più che mai a rispettare un ideale concetto di proprietario "originale"; i sostenitori del regime della proprietà intellettuale e le lobby dei diritti d'autore continuano a suscitare panico morale riguardo l'assunta illegittimità di pratiche quali il riuso e il remix della cultura digitale protetta da Copyright; di conseguenza molti creativi digitali, hanno iniziato a autoconsiderarsi "pirati dei media" o a conformarsi eccessivamente a queste politiche restrittive. Per molti artisti e creativi, l'intimidazione in corso da parte delle leghe internazionali dei sostenitori della proprietà intellettuale si traduce quindi in autocensura o in un'intensa ansia di giustificare il proprio lavoro attraverso retoriche anti-proprietà intellettuale più o meno radicali.

sono fortemente d'accordo con molti studiosi legali e culturali che hanno sottolineato quanto le leggi attuali siano tragicamente inadatte alla realtà della cultura digitale quotidiana e alle sue innumerevoli pratiche creative e produttive di copia, riutilizzo e condivisione. Gli artisti interessati dalla questione, dovrebbero unirsi al forte coro di voci accademiche che già si oppone alle leggi sulla proprietà intellettuale, ed esprimersi artisticamente sui difetti e le carenze delle leggi sul Copyright. I Live Coders sono in una posizione eccellente per farlo: sebbene le opere che creano siano, in linea di principio, soggette alla regolamentazione della proprietà intellettuale, il Live Coding può resistere abbastanza facilmente a questa regolamentazione, perché la qualità dell'improvvisazione live delle creazioni Live Coding, contraddice molte delle ipotesi fondamentali, su cui si basa il regime della proprietà intellettuale. Le creazioni in tempo reale del Live Coding, si prestano bene per opporsi tatticamente, ai limiti imposti dal regime della proprietà intellettuale e per il superamento delle attuali leggi sul Copyright.

Estratti e rielaborazioni dell'articolo di Martin Zeilinger, Live Coding the Law: Improvisation, Code, and Copyright;
Il computer ci sta portanto a una situazione che è simile a quella che ha portato all'invenzione dell'armonia. Le Routine Secondarie sono come accordi. Nessuno penserebbe di tenersi un accordo per sé. Bisognerebbe donarle a chiunque le desiderasse. Ed essere contenti di eventuali alterazioni. La Sub-Routine viene alterata da un singola modifica. Stiamo facendo musica fatta dall'umanità stessa: non da solo un uomo; ~ John Cage;

"L’avventura del comporre rimane un viaggio in gran parte misterioso e viverne appieno l’esperienza implica una disponibilità verso l’ignoto, realizzando che oggi, come ieri, scrivere è affrontare un volto sconosciuto. Le tecnologie danno a questo percorso infiniti supporti tecnico cognitivi nuovi, in continua e ininterrotta evoluzione, ma l’attrezzatura intellettuale, quella che riconosci subito in un compositore, rimane un valore ineludibile, almeno per una certa concezione dell’arte. Non si misura soltanto con la padronanza di un sistema, con l’aggiornamento tecnologico, con la perfezionetecnica, e in fondo neanche con la complessità. E alle vecchie categorie estetiche, inadeguate a descrivere la contemporaneità, non può essere sostituita la sola perniciosa categoria del funziona/non funziona per giudicare un’opera, perché ciò implicherebbe l’esistenza di un’idea condivisa su come debba essere una musica per funzionare, in contrasto con la natura stessa dell’arte, semmai in linea con una concezione di mercato della produzione artistica. Un compositore passa attraverso la tecnologia modificandola, piegandola alle sue esigenze, e nei casi più alti nulla rimane come era prima" Mauro Cardi, Il computer per il compositore: slave o master?

Che differenza c'è tra fare Live Coding con un Linguaggio che con 3 righe di codice ti permette velocemente di definire la base ritmica, la linea di basso e la base melodica della composizione e fare Live Coding con un linguaggio verboso e prolisso come SuperCollider che ha bisogno quindi della difinizione di lunghe Sub-Routine e Template da cui necessariamente partire e successivamente modificare e combinare durante la Performance Live? Nessuna, il Linguaggio delle 3 righe, ha già le Sub-Routine pronte e predefinite nelle librerie; con SuperCollider te le scrivi te magari per snellire la codifica durante i Live e adeguarla alle tue esigenze compositive; Live Coding come Strumento di Esplorazione per la Composizione Musicale e Artistica Elettronica, e come Strumento Musicale Live di Esposizione dell'Idea Musicale e Artistica;






Primo esperimento di REBOP Coding e Live MashUp; a tendere l'idea è quella di aggiungere alla composizione musicale improvvisata del Live Coding, un'ulteriore dimensione artistica, tramite il Live MashUp, per arricchire concettualmente la performance e dare al Live Coder (REBOP Coder) la possibilità di esprimersi meglio artisticamente; il Live MashUp si va ad aggiungere alle Gif Animate e al Live Texting della prosa a tema sociale con cui commento le varie idee musicali; il tutto confluirà all'interno del sistema REBOP che utilizzo per la composizione musicale per snellire il linguaggio SuperCollider e per adattarlo alle mie esigenze compositive;


il Live Coding puro, from Scratch, partendo da un editor vuoto o quasi vuoto, si colloca a un estremo dello spettro delle possibilità, mentre la Musica Generativa, si colloca all'altro estremo. Il Live Coding puro è l'idea che possiamo creare musica da zero, scrivendo codice, partendo da un editor vuoto o quasi; la Musica Generativa d'altro canto insegue l'idea che i computer possano fare musica interamente da soli, senza supervisione. Entrambi gli ideali sono impossibili da raggiungere; personalmente penso che il modo migliore di creare musica con il Live Coding durante una Performance Live, possa trovarsi in mezzo ai due estremi dello spettro delle possibilità; quando compongo in studio e uso lo strumento del Live Coding, però, parto sempre da un editor vuoto o quasi; come in questo video;

non è necessario un pubblico per fare Live Coding; penso che la migliore musica creata con il Live Coding provenga probabilmente da persone che fanno Live Coding da soli, che sviluppano un'idea in studio ad uno stato avanzato, per presentarla magari successivamente a un pubblico, per divertirsi, elaborando strategie per fare Live Coding con quell'idea ben realizzata e elaborata.

la sensazione preferita che cerco comunque è quella di esplorare nuove idee in intimità, magari anche durante un'intensa e rumorosa esibizione dal vivo. Il Live Coding from Scratch è rischioso, ma quando funziona è fantastico; questa cosa lho provata in studio tantissime volte; il sistema REBOP che sto creando, mi ha dato la possibiltà di snellire molto il linguaggio SuperCollider, tra i più verbosi e prolissi, per adattarlo anche alle mie esigenze compositive; a tendere questo sistema mi permetterà di muovermi sempre di più verso l'ideale del Live Coding from Scratch;

esiste però anche un pubblico a cui stai proponendo le tue idee musicali; il Live Coding from Scratch è divertentissimo per il Live Coder, che sta esplorando in ogni momento nuove possibilità, ma per chi ascolta/osserva può risultare noioso se diventa un processo troppo lento e ripetitivo;

Brian Eno paragona la Musica Generativa alla semina dei semi, che sono lasciati crescere da soli, e suggerisce che rinunciando al controllo dei nostri processi, li lasciamo "suonare nel vento"; contrasto fortemente questo concetto; sostengo l'umanizzazione della Musica Generativa, in cui il codice non viene lasciato solo a vagare attraverso il suo paesaggio sonoro auto-descrittivo, ma viene violato, tagliato e modellato per fare appunto Live Coding o nel caso di noi Rebopper.. REBOP Coding;






Sabato 21 dicembre 2019
presso il CSOA Forte Prenestino
Via Federico Delpino - Roma (RM)
Av.A.Na. festeggia i 25 anni, come tradizione il 21 dicembre,
LiveCoding o meglio REBOP Coding by Bz Akira Santjago;

il performer scrive e esegue il codice che viene decodificato dalla macchina e produce un risultato sonoro. La performance musicale, quindi, consiste in un dialogo continuo tra uomo e macchina, in una sorta di rapporto direttore d'orchestra <-> esecutore in cui il primo non ha mai il pieno controllo sul secondo. Il codice sorgente viene continuamente modificato e valutato dal musicista per variare i risultati musicali. Il Live Coder o meglio nel mio caso Rebopper (quindi REBOP Coding per ragioni che leggerete sotto), di conseguenza, per il fatto di essere sul palco di fronte a un pubblico, che può anche leggere ciò che sta scrivendo e/o valutando, è il vero e proprio artefice del prodotto finale e la sua è una composizione musicale improvvisata; nel mio caso il tutto è arricchito da gif animate legate al brano musicale creato in quel momento e da una prosa a tema sociale improvvisata come commento all'idea musicale;

le mie composizioni non sono semplici e minimali e le sequenze che definisco sono sicuramente più melodiche di tante altre cose che ho sentito nel mondo musicale del Live Coding; ma il problema principale è che uso un linguaggio estremamente prolisso, SuperCollider, forse il piu prolisso tra i vari linguaggi in uso nel panorama del Live Coding; in mancanza di tempo, questo mi impone di partire da template prefabbricati in studio per poi combinare le varie sequenze durante il Live; ho creato queste sequenze in ore e ore di sessioni di Live Coding e il tempo a disposizione per questa Live era pochissimo, la sessione sarebbe durata 4 ore se fossi partito da zero; nel mondo del Live Coding, c'è chi parte dall'editor vuoto e chi parte da template e algoritmi prefabbricati e poi combina e modifica le sequenze come ho fatto in questa sessione Live (link TOPLAP); con Tidal, altro linguaggio di programmazione, una canzone delle mie la scrivi con 5 linee di codice; era comunque la mia prima esperienza con il Live Coding e sto creando il sistema REBOP proprio per snellire il linguaggio; questo per rispondere al "sapientone" che mi critica nel video qui sotto; ha ragione lui, il mio non è Live Coding, uso il Live Coding come strumento di composizione; il mio è REBOP Coding, visto che aggiungo anche immagini e prosa improvvisata a tema sociale come commento all'idea musicale; e la chiudiamo qui;



non la chiudiamo qui; per essere seri, e fregandosene dei rosicamenti altrui, il mio REBOP Coding è Live Coding come si può serenamente desumere dalle tante testimonianze di Live Coder della community TOPLAP; il problema è che questi discorsi allontanano le persone dal provare il Live Coding e sopratutto dal provare a creare un proprio stile di programmazione;



Alcune testimonianze dal Forum di TOPLAP (Forum Internazionale e Ufficiale della Community di Live Coding) :

"It depends on the audience and purpose of the performance, but for Algorave-style performances I prepare code for nearly everything. I typically prepare small 5-minute compositions that I can improvise with. However, I also do completely improvised stuff in live streams and in front of live audiences if the performance demands it.

The “live” part of my performance consists of:

Improvisation of the pre-written compositions
Transitions between the pre-written compositions"

---

"I prepare almost everything in my sets currently, for a few reasons:

I write songs that kind of have to be performed in vaguely predictable sections to work
Ixi uses the arrangement of the text/whitespace in physical space to determine time, so a single typo can throw you into a different time signature (this is great great great for songwriting, but super risky for live performance).
typing while singing is quite hard. :wink:
The only version of ixi that works on my computer is super unstable so however much I pre-prepare there’s always an element of risk anyway.
Probably 90% of it is pre-typed and just evaluated live"

---

"yes, I definitely think this some holds people back from jumping into the live coding community and making the music with code that best suits their own performance style/song structure. Part of the reason I wanted to start this discussion! And to be fair, I would argue that some of my favorite and most prominent live coders today definitely have structured tracks that they return to in most of their sets, regardless of how much of them they type live!"

---

"I think I respect the way that live programmers feel happy playing live, what I do not like is when you talk about “good practices” when you play from skratch, I think this demerits the practices of other live programmers who have other processes. I feel good by composing and “typed live”, for a long time I stopped thinking that things are better because they seem to be more complex, in any way, making music, under any medium, it is always a challenge, the challenge of ordering sound on time. Would it be great to eliminate these ideas about whether it is live encoding or not? Both processes are live coding from my point of view."
MIDIClient.init;
MIDIClient.destinations;
w = MIDIOut(0, MIDIClient.destinations[46].uid).latency_(0.0001);
t = MIDIOut(0, MIDIClient.destinations[49].uid).latency_(0.0001);


x.value;

d[\m2] = MIDIOut.newByName("Scarlett 2i4 USB", "Scarlett 2i4 USB MIDI 1").latency = (0.2555)

w.noteOn(0, 60, 60);
w.noteOff(0, 60, 60);
w.program(1);

(

//var melody="cs4+cs5 ,cs4 ,cs4+ds5 ,off ,cs4+es5 ,cs4 ,off ,cs4 ";
var melody="cs4+cs5                               ";
//var melody="cs5 ,cs5 ,ds5 ,off ,off ,cs4 ,off ,cs4 ";

var durno=z.value(melody);
var notes=b.value(melody);

durno.postln;
notes.postln;


r[\midinstr].value(notes-24,durno*0.5, 1);

)

(
r.put(\midinstr,{ arg bnotes=m.atAll(#[b0,b0,b0,b0,b0,b0,b1,b1,b0]).asArray,  dnotes=[1,1,1,1,1,1,0.5,0.5,1]*0.5,amp=0.7;


~midinstr=Pbind(\type,\midi,\midicmd,\noteOn,\midiout,w,\midinote,Pseq(bnotes,inf),\dur,Pseq(dnotes,inf),\amp,Pseq(((bnotes / 127) > 0).asInteger*amp,inf),\pan,0.3);
~midinstr.play;


~x=Pbind(\type, \rest, \beat, Pfuncn({ "midiinstr".postln }, 1), \dur, 1);

});

)
(
r.put(\midinstr2,{ arg bnotes=m.atAll(#[b0,b0,b0,b0,b0,b0,b1,b1,b0]).asArray,  dnotes=[1,1,1,1,1,1,0.5,0.5,1]*0.5,amp=0.7;


~midinstr2=Pbind(\type,\midi,\midicmd,\noteOn,\midiout,t,\midinote,Pseq(bnotes,inf),\dur,Pseq(dnotes,inf),\amp,Pseq(((bnotes / 127) > 0).asInteger*amp,inf),\pan,0.3);
~midinstr2.play;


~x=Pbind(\type, \rest, \beat, Pfuncn({ "midiinstr2".postln }, 1), \dur, 1);

});

)




Léon Theremin era un Hacker, un inventore sovietico, famoso per la creazione dell'omonimo Theremin, uno dei primi strumenti musicali elettronici. Nel 1919 stava lavorando, nel laboratorio del noto fisico Ioffe, con particolari dispositivi di sua ideazione atti a misurare la densità dei gas nel vuoto; ben presto si accorse che in certe condizioni si produceva un fischio che variava di frequenza avvicinando o allontanando la mano dai circuiti. Forte della sua esperienza di qualche anno prima in campo militare, con amplificatori e oscillatori che utilizzavano valvole termoioniche ed interessato dai possibili risvolti pratici del fenomeno, continuò a fare esperimenti fino ad inventare un vero e proprio strumento musicale cui diede il nome di eterofono.

r[\pianovel].value(b.value("f3+c6 ,off ,c3+c4 ,as4+ds4+fs3+c1  ,f3+f2 ,a3,f1 ,d2 "),z.value("f3+c6 ,off ,c3+c4 ,as4+ds4+fs3+c1  ,f3+f2 ,a3,f1 ,d2 ")*0.5, 1);

r[\bz_bass].value(b.value("f3 ,f2 ,f2 ,f1 ,f3 ,f3 ,f1 ,f2 "),z.value("f3 ,f2 ,f2 ,f1 ,f3 ,f3 ,f1 ,f2 ")*0.5);
    16.wait;
    r[\bz_slap].value(b.value("f1 ,f1 ,off ,f1 ,f1,f1,f1 ,f1 ,f1 "),z.value("f1 ,f1 ,off ,f1 ,f1,f1,f1 ,f1 ,f1 ")*0.5);

~bzbass[5] = \filter -> {arg sig; (3111.33*sig.distort/(1+ (2231.23*sig.abs))).distort*0.25};

r[\pianovel].value(b.value("f4+f5 ,e4+e5 ,ds4+ds5 ,d4+d5  ,cs4+cs5 ,c4+c5,b4+b5 ,as4+as5 "),z.value("f3+c6 ,e5+e4 ,c3+c4 ,as4+ds4+fs3+c1  ,f3+f2 ,a3,f1 ,d2 ")*0.5, 1);

//Space Theremin sound from:
//Mitchell Sigman (2011) Steal this Sound. Milwaukee, WI: Hal Leonard Books
//under GNU GPL 3 as per SuperCollider license

(
~spacetheremin=Pfx(
    Pmono(
        \spacetheremin,
        \amp,Prand([0.4,0.45,0.5,0.55,0.5],inf),
        \midinote,Prand([0,2,3,5,6,8,9,11]+60,inf),
        \dur,Prand([1.0,1.5,0.5,0.75,1.25,2.0,0.57],inf),
        \lagTime,Pstutter(7,Pn(Pseries(0.05,0.05,8),inf)),
        \lfoRate,Pstutter(9,Pn(Pseries(6,0.5,5),inf)),
        \cutoff,Pstutter(11,Prand([1000,1500,2000,3000],inf))
    ),
    \spacereverb
)
)





può una frase musicale trasformasi in un'opera di Fiber Art Iperbolico? i gradi di una scala, di una composizione LiveCoding REBOP, essere usati come base per la creazione di una forma di Crochet Iperbolico? Evidentemente si, grazie alla Super Artista Rita Cavallaro! REBOP Fiber Iperbolico!

(
    var a,b,c;
    a=Pseq([Pser([0,1,2,3,4,5,6,7],12),Pser([1,1,1],12)],1);
    //c=Pseq([Pser([7,7,0,0,3,3,7,7].reverse,12),Pser([7,7,7],12)],1);
    c=Pseq([Pser([7,7,0,0,3,3,7,7].reverse,12)],2);
    b=Pseq([Pseq([7,6,5],2),Pseq([7,7,7],2),Pseq([7,6,5],2),Pseq([7,7,7],2)],1);
    ~piano = Pbind(\instrument,\pianovel,\scale,Scale.major,\root,5,\octave,[3,5],\degree,Pseq([Pn(a,3),Pn(c,2),Pn(b,1)],inf),\dur,Pbjorklund2(3,8)/4,\amp,1,\rel, 0.3,\pan, -0.7);
    ~piano.play;
)


questo articolo è stato creato attraverso Cut-Up letterari e rielaborazioni creative del concetto di Cut-Up comportamentale, che in questo testo chiamerò REBOP comportamentale; REBOP : Realtime Exploration Beyond Ordinary Possibilities;

I REBOP comportamentali sono paragonabili ai Cut-Up artistici e letterari, in cui testi e materiali esistenti vengono smontati e riassemblati in modi nuovi. I dadaisti tagliavano a pezzi giornali e libri di poesia e creavano nuovi componimenti estraendo a caso i ritagli da un cappello; similmente, il Rebopper comportamentale (un artista del Cut-Up comportamentale) applica forbici e colla a un testo sociale o personale e riconfigura banali aspetti dell'esistenza in modi straordinari. Un REBOP comportamentale non è tanto una randomizzazione della vita quanto un punto di partenza per territori "inesplorati"; come tale, può richiedere un'attenta riflessione. Scegliere le modifiche più promettenti da fare è una scienza rigorosa, se non esatta.

Nella forma più elementare di REBOP comportamentale, si associa una determinata alterazione ad un aspetto della vita che finora sembrava ordinario: per esempio: decidi di mangiare a scrocco per un mese intero, oppure ti dedichi a scalare tutti gli alberi della zona, o ti impegni a mandare ogni giorno una cartolina alla tua famiglia per un anno. Queste alterazioni fanno concentrare l’attenzione su attività che si davano per scontate, acuiscono la consapevolezza, rendono più sciolta la mente e svelano nuove possibilità.

Quando ti avventuri fuori dal giro della vita quotidiana, entri temporaneamente in un mondo parallelo dove sei una persona diversa e impari cose che, se prima erano banali, adesso sono nuove di zecca.

I REBOP comportamentali non sono cose strane ed esoteriche come il loro nome potrebbe far sembrare. In tradizioni che risalgono all’alba della civiltà, guerrieri e sciamani li hanno praticati come forma di ricerca visionaria. Imitazione di animali, danze estatiche, rituali di sfinimento, deprivazione sensoriale, dolore: sono tecniche di antica tradizione per la sperimentazione psichica e sociale.

Anche nella nostra prosaica epoca si partecipa ad attività simili, in misura variabile: digiunare durante il mese del Ramadan, costruire un fortino di cuscini in salotto e rifiutarsi di uscire per tutta la sera, andare a una festa di Halloween vestito da Frank Zappa e passare tutta la notte nel personaggio; bere per un mese solo pompelmo, dormire 3 ore a notte per una settimana, decidere di non guardare film, serie-tv per un anno, non parlare con nessuno per un giorno, tutti questi sono REBOP comportamentali, per quanto alcuni inconsapevoli o poco originali. Molte persone hanno esperienze di prima mano con semplici REBOP alimentari: diventare vegani, per esempio, fa guardare al cibo in una luce nuova, cambia le abitudini sociali e spesso ha come risultato un aumento di interesse per la cucina o il giardinaggio. Non ci resta che mettere a punto una pratica intenzionale di REBOP comportamentali fini a se stessi, come strumenti di educazione, ispirazione e liberazione.

Non c’è bisogno che i REBOP comportamentali siano grandiosi; anzi, i più coinvolgenti raramente sembrano attraenti sulla carta. Dedicarsi a cose futili come attaccare discorso con uno sconosciuto ogni mattina forse non sembrerà un grande cambiamento di vita, ma gli effetti cumulativi possono essere sorprendenti. REBOP comportamentali più estremi possono creare conflitti con i propri concittadini. I REBOP comportamentali possono dare l’impressione di essere terreno elettivo di artisti, performer e altri privilegiati, ma è un errore liquidarli come tali. Preso sul serio, il REBOP comportamentale è un esercizio di espansione del sé, una pratica fondamentale per i rivoluzionari tanto quanto il mutuo soccorso o l’autodifesa.

Esempi di REBOP comportamentali :

Fate due liste: cose che vi annoiano e cose di cui avete paura. La prima dovrebbe essere facile da compilare, mentre la seconda può essere difficile ammetterla persino a se stessi. Prendete una voce a caso da ogni lista. Inventatevi un esercizio che le combini entrambe: per esempio, se avete scelto "prendere i mezzi pubblici" dalla lista noiosa e "parlare in pubblico" dalla lista paurosa, potreste sfidarvi a pronunciare un discorso sulla metropolitana ogni settimana. Tenete un diario delle vostre esperienze e delle vostre interazioni.

Scegliete un'attività che intimamente vi è sempre parsa assurda o ingiusta e che siete costretti a praticare, per pressioni culturali, convenienza o per comodità, e rifiutatevi di farla, anche se si rivela complicato. Può sensibilizzarvi a tragedie che prima erano invisibili, dopo qualche mese da vegani, entrerete in una pelletteria e vi sembrerà il negozio di un profanatore di tombe, o può mostrare ai vostri concittadini gli eccessi della società, come nel caso dell'asceta che porta con sé tutti i rifiuti che produce. Concedetevi un rapporto particolare con un luogo associandolo a un'attività specifica. Per esempio, potreste decidere che ogni volta che vi trovate in una determinata città, siete un corridore che si alza all'alba e fa jogging tutto il tempo.


Questo è solo uno dei tanti possibili Manifesti REBOP o un Non-Manifesto;

Il termine REBOP (successivamente usato nella forma BEBOP) è un'onomatopea che imita una brevissima frase di due note usata talvolta come "segnale" per terminare un brano jazz;

Il REBOP incoraggia la creatività per se stessi piuttosto che per il consumo culturale;

Il REBOP crea sempre composizioni parziali, quindi, mai complete;

il REBOP non è un fine ma un mezzo;

i veri Rebopper in genere bevono solo pompelmo (a parte nelle notti di luna piena);

La musica non può essere prigioniera dell'attrezzatura musicale. La tecnologia ha sempre offerto alla musica nuovi mezzi ampliando così le possibilità di espressione dell'artista e contribuendo all'evoluzione del linguaggio musicale;

L'Hacker o Rebopper è una persona che trae piacere dalla sfida intellettuale di scavalcare o aggirare creativamente dei limiti;

il Rebopper o Live Coder espone e improvvisando modifica il software mentre quest'ultimo genera musica e/o immagini. La manipolazione del codice è proiettata per il piacere di chi legge/ascolta/guarda/partecipa;

nel REBOP Coding dal vivo, l'esecutore può occuparsi principalmente della transizione tra frammenti di codice pre-scritti, pur generandone di nuovi dal vivo. In questo caso, la vitalità e l'improvvisazione nella pratica del REBOP Coding si concentrano sull'esplorazione di nuove combinazioni di frammenti di codice e sull' orchestrazione tempestiva della loro esecuzione.

Non è necessario che il pubblico capisca il codice per apprezzarlo, così come non è necessario sapere come suonare la chitarra per apprezzare la visione di una performance di chitarra; quello del codice è un non problema; il REBOP comunque incoraggia la presenza mentale e il consumo Realtime non passivo delle creazioni REBOP;

L'oscurantismo è pericoloso; mostra sempre il tuo schermo, rendi sempre aperto il tuo codice;

un vero Rebopper in genere non si depila mai, ed è sempre fiero di ululare alla luna durante le notti di luna piena; è un Rebopper mannaro che beve succo di pomodoro e mangia insalate di Mate Coding;

un vero Rebopper crea codice come un Hacker, piroetta vorticosamente come un Sufi e lotta come un Samurai;

il REBOP produce nuovi concetti, nuove percezioni e nuove sensazioni, che hackera da dati vecchi e/o non ancora elaborati; qualsiasi sia il codice che hackeriamo, sia esso linguaggio di programmazione, lingua poetica, matematica o musica, curve o colori, noi siamo coloro che astraggono i mondi nuovi; qualsiasi sia il modo in cui scegliamo di rappresentarci, come ricercatori o autori, artisti o biologi, chimici o musicisti, filosofi o programmatori, ognuna di queste soggettività è un frammento di una classe che diviene, a poco a poco, consapevole di sé in quanto tale.

un vero Rebopper si genuflette e si arrende all'Universo almeno 8 volte al giorno;

il REBOP ha a che fare con la giocosità, l'intelligenza e l'esplorazione. Significa esplorare i limiti di ciò che è possibile, con uno spirito di giocosa intelligenza;

i Rebopper o Hacker credono che gli insegnamenti fondamentali sui sistemi, e sul mondo, possano essere appresi smontando le cose, analizzandone il funzionamento e utilizzando la conoscenza per creare cose nuove e più interessanti;

il REBOP è contro il Narcisismo Patologico epidemico e imperante nella nostra società; uno dei mantra REBOP è No Headliner; non vogliamo Rock Star depilate e lampadate, con le extensions e il parrucchino, venerate da fan rintronati che contemplano, in stato ipnagogico, i loro idoli scorreggioni; durante un concerto, qualsiasi vostro idolo, scorreggia dalle 80 alle 180 volte in un'ora, secondo un studio scientifico pubblicato su PubMed; il REBOP promuove la collaborazione, la condivisione e la decentralizzazione;

un Rebopper o Hacker non ha nulla a che fare con i patetici Mr.Robot delle serie tv e dello Spettacolo Mainstream; non spia profili Facebook e non ha dipendenze patologiche con la droga; si droga solo di codice e musica;

sulla questione "Droga" il vero Rebopper in genere è un Frank Zappatista Radicale;

La vera arte è il gioco, e il gioco è una delle esperienze più immediate in assoluto; se sei un Mercante, vai al Mercato;

il REBOP non è uno Spettacolo, è un processo di Esplorazione Realtime; la sua funzione primaria è quella di portare il compositore e/o chi assiste e co-partecipa, in uno stato meditativo intenso;

il REBOP è un viaggio esplorativo di Codifica Live, Realtime, Just In Time Programming, verso nuove e non ordinarie possibilità, compositive e non;

il REBOP dalla Composizione Realtime, a tendere, si allargherà per pervadere e comprendere ogni momento e aspetto della vita quotidiana, in termini Situazionisti;

se è la tua prima sera all'AlgoREBOP, devi Reboppare;




il REBOP "incoraggia la creatività per se stessi piuttosto che per il consumo culturale". Non produce alcuna opera completa, quindi non esiste nulla da diciamo consumare e valutare. Il REBOP crea sempre composizioni parziali quindi mai complete; non crea opere musicali da consumare passivamente; quello che viene creato con il REBOP (che poi è solo una fotografia di una piccola parte dell'intero processo), può certamente essere condiviso open source, può essere quindi fonte di ispirazione e di studio, può essere analizzato e esplorato, ma ha già esaurito la sua funzione primaria : quella di portare il compositore in uno stato meditativo intenso; il REBOP è un processo di Esplorazione Realtime e dall'Hacking, dal LiveCoding, dal Reverse Engineering, dalla Composizione Algoritmica e dalla Sintesi del Suono, a tendere, si allargherà per pervadere e comprendere ogni momento e aspetto della vita quotidiana, in termini Situazionisti;

(
var c,e;
var bassAmp = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.6;
c=Pseq([4,0,0,4,4,0,0,0,4,0,0,0,4,4,3.5,0]*1,1);
e=Pseq([0,0,0,0,0,0,0,0,0,0,0,0,4,0,4,3.5]*1,1);
Pbindef(~bzbass2,\instrument,\bz_bass,\scale,Scale.yu,\root,5,\octave,2,
\degree,Pseq([Pn(c,3),Pn(e,3)],inf),\dur,1/2,\amp,Pseq(bassAmp,inf),\rel,
0.3,\pan,-0.3);
Pbindef(~bzbass2).play;
)
(
var c,e;
var synth2Amp = [ 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1 ]*0.2;
c=Pseq([4,0,0,4,4,0,0,0,4,0,0,0,4,4,3.5,0]*1,1);
e=Pseq([0,0,0,0,0,0,0,0,0,0,0,0,4,0,4,3.5]*1,1);
Pbindef(~synth2,\instrument,\sinfb,\scale,Scale.yu,\root,5,\octave,5,
\degree,Pseq([Pn(c,3),Pn(e,3)],inf),\dur,1/2,\amp,Pseq(synth2Amp,inf),\rel,
1.9,\pan,-0.7,\fb,1.7);
Pbindef(~synth2).play;
)

(
var c,e;
var bassAmp = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.3;
c=Pseq([4,0,0,4,4,0,0,0,4,0,0,0,4,4,3.5,0]*1,1);
Pbindef(~flute,\instrument,\flute,\scale,Scale.yu,\root,5,\octave,4,
\degree,Pseq([Pn(c,3)],inf),\dur,1/2,\amp,Pseq(bassAmp,inf),\rel,
0.3,\pan,0.7);
)

(
var c,e;
var bassAmp = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.2;
c=Pseq([4,0,4,4,4,0,4,4,4,0,4,4,4,4,3.5,0]*1,1);
e=Pseq([0,3.5,3.5,4]*1,4);
c=Pseq([0,1,3.5,3,4,5,6,7,0,1,3.5,3,4,5,6,7]*1,2);
e=Pseq([4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4]*1,1);
Pbindef(~xx,\instrument,\synth,\scale,Scale.yu,\root,5,\octave,3,
\degree,Pseq([Pn(c,3),Pn(e,3)],inf),\dur,1/4,\amp,Pseq(bassAmp,inf),\rel,
0.3,\pan,0.3);
)

(
~b=Pbind(\instrument,\bz_bass,\scale,Scale.yu,\root,5,\octave,2,\degree,Pseq([0,0,0,0,0,0,0,0,0,0,0,0,4,0,4,3.5]*1,inf),\dur,1/2,\amp,0.5);
~b.play;
)

(
//var kickAmps = [ 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 ]*0.3;
var kickAmps = [ 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]*0.3;
Pbindef(~k2, \instrument, \bplay, \buf, d["k"][0], \dur, 1/4, \amp,  Pseq(kickAmps, inf),
\rate, 1,\pan, 0.1);
Pbindef(~k2).play
)
(
var kickAmps = [ 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 ]*0.3;
~k1=Pbind( \instrument, \bplay, \buf, d["k"][1], \dur, 1/4, \amp,  Pseq(kickAmps, inf),
\rate, 1,\pan, -0.3);
~k1.play;
)

(
//var snareAmps = [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0 ]*0.2; // 16 beats
var snareAmps = [ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1 ]*0.15; // 16 beats
//var snareAmps = [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ]*0.1; // 16 beats
~sn = Pbind(\instrument,\bplay,\buf,d["s"][0],\dur,1/4,\amp,Pseq(snareAmps,inf),\pan,-0.1);
~sn.play;
)

(
//var hatAmps = [ 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 ]*0.1; // 16 beats
var hatAmps = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.1; // 16 beats
~h = Pbind(\instrument,\bplay,\buf,d["ch"][0],\dur,1/4,\amp,Pseq(hatAmps,inf),\pan,0.3);
~h.play;
)

(
//var hatAmps = [ 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 ]*0.1; // 16 beats
var hatAmps = [ 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0 ]*0.1; // 16 beats
~h2 = Pbind(\instrument,\bplay,\buf,d["ch"][3],\dur,1/4,\amp,Pseq(hatAmps,inf),\pan,-0.3);
~h2.play;
)


(
var voAmps = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.4; // 16 beats
~v = Pbind(\instrument,\bplay,\buf,d["voices"][2],\dur,120,\amp,Pseq(voAmps,inf),\pan,0.3);
~v.play;
)
(
var voAmps = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]*0.4; // 16 beats
~v1 = Pbind(\instrument,\bplay,\buf,d["voices"][4],\dur,120,\amp,Pseq(voAmps,inf),\pan,0.3);
~v1.play;
)






REBOP : Realtime Exploration Beyond Ordinary Possibilities

Il REBOP nasce dalle mie esperienze di composizione algoritmica con SuperCollider e con l'OpenGL GLSL e da alcune consapevolezze raggiunte durante i vari esperimenti; il REBOP "incoraggia la creatività per se stessi piuttosto che per il consumo culturale". Non produce alcuna opera completa, quindi non esiste nulla da diciamo consumare e valutare. Il REBOP crea sempre composizioni parziali, quindi, mai complete; non crea opere musicali e non da consumare, oltretutto nella maggiorparte dei casi come succede sempre più spesso, passivamente; quello che magari viene creato con il REBOP (che poi è solo una fotografia di una piccola parte dell'intero processo), può certamente essere condiviso Open Source, può essere quindi fonte di ispirazione e di studio, può essere analizzato e esplorato, ma ha già esaurito la sua funzione primaria : quella di portare il compositore in uno stato meditativo intenso, che è poi la funzione primaria dell'intero processo del REBOP; il REBOP è un viaggio esplorativo di Codifica Live, Realtime, Just In Time Programming, verso nuove e non ordinarie possibilità, compositive e non; il REBOP non è un fine ma un mezzo; il REBOP dalla Composizione Realtime, a tendere, si allargherà per pervadere e comprendere ogni momento e aspetto della vita quotidiana, in termini situazionisti;

Per i nostri scopi, "meditativo" non ha nulla a che fare con l'entrare in trance, elevarsi, fuggire dalla realtà, non ha nulla a che fare con l'auto-aiuto, con il superare malattie mentali o capire come gli algoritmi o la codifica "estendano" la mente. Queste potrebbero essere conseguenze secondarie estemporanee anche non desiderabili. Né il REBOP tratta di bellezza o di godimento di un'esperienza pura ed estetica. "Meditativo", in questo testo, ha a che fare con il coltivare la consapevolezza del momento presente.

Se il nostro intento è generare opere musicali durante la codifica e l'esplorazione realtime, qualsiasi idea su come confezionarle, venderle o distribuirle o su cosa fare affinchè risultino interessanti a un ipotetico pubblico anche virtuale, ci allontana inevitabilmente dal momento presente. Se, durante il REBOP, i nostri pensieri vagano assorbiti dalle preoccupazioni su come presentare e rappresentare il nostro lavoro in futuro, allora abbiamo lasciato nuovamente il momento presente.

Confrontare il lavoro che si sta creando con altri lavori precedenti, ci porta dal presente al passato. Abbiamo bisogno di capire come l'intenzione di creare opere musicali influenzi il potenziale meditativo della nostra esperienza.

I compositori sperimentali non sono in genere interessati a prescrivere un oggetto temporale definito i cui materiali, strutture e relazioni siano calcolati e disposti in anticipo, ma sono più eccitati dalla prospettiva di delineare una situazione in cui possono verificarsi suoni e melodie, un processo di generazione di suoni, uno spazio magari delimitato da certe "regole non regole" compositive.

Oltre a lasciare andare le idee sull'opera musicale durante gli eventi di codifica e esplorazione realtime, faremmo anche bene a lasciare andare le nostre idee sulla musica. Se l'obiettivo durante la codifica REBOP meditativa è lasciare andare il giudizio, allora una musica definita come "ordinata", "gradevole", "espressiva" o "bella" non ci offre nulla. La musica generata durante il REBOP può comunque essere ordinata, gradevole, espressiva, per alcuni e per il compositore stesso, ma questo non è lo scopo del REBOP, come non lo sono venderla o ottenere apprezzamenti; per la codifica REBOP esplorativa, dobbiamo spostare l'enfasi dagli oggetti musicali alle attività musicali; porre attenzione al processo REBOP e lasciare andare gli oggetti musicali, semplicemente osservarli;

Quando spostiamo il nostro pensiero dagli oggetti musicali e iniziamo a osservare attività, relazioni e eventi, riduciamo la necessità di raggiungere o ottenere, e creiamo spazio per sperimentare.
Per il Rebopper qualsiasi scoperta può essere "vera"; un Rebopper considera qualsiasi ipotesi o analisi e misura le sue conseguenze pratiche per determinare ciò che può migliorare l'esperienza.

I praticanti del Pali-language Theravada (Buddhisti) usano il canto specificamente per coltivare la consapevolezza e non descrivono i suoni che producono come "musica".

Il REBOP ci chiede di rimanere nel momento, il che richiede meno sforzo quando vediamo un processo di codifica e esplorazione realtime come un'attività che non deve produrre certe cose o conformarsi a regole immaginarie come quelle che definiscono le opere musicali.

Strettamente legato al free jazz e spesso associata a musicisti come John Zorn, Anthony Braxton e Derek Bailey, l'improvvisazione libera è nota per la sua mancanza di regole. I Rebopper  possono iniziare con l'editor vuoto o da un codice preparato in anticipo e gradualmente allontanarsene; scartano completamente le nozioni di lavoro musicale e lasciano cadere i giudizi sugli oggetti musicali per porre attenzione al processo di esplorazione e codifica REBOP;

Non dobbiamo mai giudicare un'esperienza di codifica e esplorazione realtime come un fallimento, un successo o peggio come qualcosa di neutrale. La realtà è che "solo prestare attenzione" è tanto difficile quanto semplice. Va contro il nostro condizionamento culturale il fatto che la produzione musicale non porti alcuna informazione e che non significhi nulla. Ma se codificare REBOP diventa un'esperienza meditativa che coltiva la consapevolezza, allora possiamo iniziare riconoscendo come le nostre idee sulle opere musicali, sulla musica e sull'interpretazione influenzino le nostre esperienze. Per fortuna, è difficile aggrapparsi a idee che contraddicano l'esperienza personale, quindi anche solo vivere un piccolo momento di un evento di codifica e esplorazione realtime senza giudizio può avere un impatto duraturo e positivo e portarci a consapevolezze altre.

il REBOP è un'esplorazione in tempo reale al di là delle ordinarie possibilità; quali sono le mie ordinarie possibilità come artista, musicista mashupper? con il REBOP sto esplorarando altre possibilità compositive e non attraverso la composizione algoritmica e il live coding ('on-the-fly programming','just in time programming', 'conversational programming', 'slow coding', 'realtime coding'); ma è una composizione appunto fatta per altri scopi, come appunto coltivare la consapevolezza del momento presente; il REBOP è intelligenza giocosa, è improvvisazione, spontaneità, è esplorazione, hacking; cè molto REBOP anche nello SnowCrash Project anche se apparentemente questo non risulta evidente;

Il termine REBOP (prima versione del più conosciutò BEBOP) è un'onomatopea che imita una brevissima frase di due note usata talvolta nell'ambito del jazz come "segnale" per terminare un brano;

Diverse parti del testo sono frutto della traduzione e della rielaborazione di frammenti dell'articolo "Meditative Live Coding and Musicological Hindrances" di Matthew Tift Lullabot




// This is a rework of https://www.shadertoy.com/view/lsfGzr,
// created by @paulofalcao, with sound, by Radical Ed
// License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License


#define time iTime

float makePoint(float x,float y,float fx,float fy,float sx,float sy,float t, float w){
   float xx=x+sin(t*fx)*sx*tan(fx*t)*log(fx*t);
   float yy=y+cos(t*fy)*sy*tan(fy*t)*log(fy*t);
   return 5.0*abs(sin(25.0*t/337.0))/sqrt(xx*xx+yy*yy)+log(w/4.0);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord ) {

   vec2 p=(fragCoord.xy/iResolution.x)*2.0-vec2(1.0,iResolution.y/iResolution.x);


 
   // create pixel coordinates
   vec2 uv = fragCoord.xy / iResolution.xy;

   // the sound texture is 512x2
   int tx = int(uv.x*512.0);
 

   // second row is the sound wave, one texel is one mono sample
   float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
 
   vec2 translate = vec2(cos(iTime),sin(iTime));
 
 
 
   p=p*7.0*abs(sin(iTime));
   p += translate*1.35*sin(iTime);
 
   float x=p.x;
   float y=p.y;
 
   vec3 col = vec3( 0.0, 0.0, 0.0);

    // add wave form on top
   //col += smoothstep( 0.0, 0.15, abs(wave- uv.x)/2.0 );
 
    //if (wave > 0.4) { wave = 0.4 ;}
 

   float a=
   makePoint(x + col.x,y + col.y,2.0,2.9,0.3,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.9,2.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,0.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,2.3,0.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.8,1.7,0.5,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,0.3,1.0,0.4,0.4,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.4,1.7,0.4,0.5,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.3,2.1,0.6,0.3,time, wave);
   a=a+makePoint(x + col.x,y + col.y,1.8,1.7,0.5,0.4,time, wave);
   
 
   float b=
   makePoint(x + col.x,y + col.y,1.2,1.9,0.3,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,2.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.6,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,2.6,0.4,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.4,0.5,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.7,0.4,0.4,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.8,0.5,0.4,0.5,time, wave);
   b=b+makePoint(x + col.x,y + col.y,1.4,0.9,0.6,0.3,time, wave);
   b=b+makePoint(x + col.x,y + col.y,0.7,1.3,0.5,0.4,time, wave);
 

   float c=
   makePoint(x + col.x,y + col.y,3.7,0.3,0.3,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.9,1.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.8,0.9,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.2,1.7,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.6,0.5,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.3,0.3,0.4,0.4,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.4,0.8,0.4,0.5,time, wave);
   c=c+makePoint(x + col.x,y + col.y,0.2,0.6,0.6,0.3,time, wave);
   c=c+makePoint(x + col.x,y + col.y,1.3,0.5,0.5,0.4,time, wave);
 
 
   vec3 d=vec3(a,b,c)/22.0;
 
 
   fragColor = vec4(d.x*2.0,d.x,d.x,1.0);
}


#define PERIOD 2.
#define REPETITIONS 2

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross2(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = iResolution.x / iResolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
 
    float d = length(pc - p) / 0.015*scale/(1.37+abs(sin(iTime)));
 
    return vec3(3. * vec3(0.5, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
 
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.xy;
 
    int tx = int(p.x*128.0);
    int ty = int(p.y*128.0);
 
    // per lo Spectrum Audio
    float wave = texelFetch( iChannel0, ivec2(ty,1), 0 ).x;
    vec3 spec = vec3(wave/0.5);
 
 
    // per lo Spectrum Audio
    //vec4 spec = vec4(0.1,0.1,0.1,0.1);
 
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
    //p += translate*0.35*sin(iTime);
    q += translate2*1.35*sin(iTime);
 
    float t = abs(2. * fract(iTime / PERIOD) - 1.);
 
 
    // Background pattern
 
 
 
    vec3 col = vec3(0.0);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1, spec.x/0.4 );
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.2, 0.1/0.1);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.05, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.05, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.2, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.05, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.1, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.1, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.1, 0.1/0.1);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.1, spec.x/0.4);
    //col += shadeBlob(p, 0.7, quintic_interp(t)*spec.z+0.1, 0.1/0.1);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.2, spec.y/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.2, spec.y/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.25, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.25, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.25, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.3, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.25, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.25, 0.1/0.1);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.25, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.3, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.4, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.4, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.45, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.45, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.45, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.45, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.45, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.5, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.5, spec.x/0.4);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.5, 0.1/0.1);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.5, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.5, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.6, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.6, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.65, spec.x/0.4);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.65, 0.1/0.1);
    //col += shadeBlob(p, 0.5, cosine_interp(t)*spec.z+0.65, 0.1/0.1);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.65, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.65, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.7, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.7, spec.x/0.4);
 
    col += shadeBlob(p, 0.3, smoothstep_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.4, linear_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.8, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.8, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.8, 0.1/0.1);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.85, spec.x/0.4);
    //col += shadeBlob(p, 0.6, smoothstep_interp(t)*spec.z+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.85, spec.x/0.4);
 
    //col += shadeBlob(p, 0.3, smoothstep_interp(t)*spec.x+0.8, 0.1/0.1);
    //col += shadeBlob(p, 0.4, linear_interp(t)*spec.y+0.8, 0.1/0.1);
    col += shadeBlob(p, 0.5, cosine_interp(t)*0.1+0.9, spec.x/0.4);
    col += shadeBlob(p, 0.6, smoothstep_interp(t)*0.1+0.9, spec.x/0.4);
    col += shadeBlob(p, 0.7, quintic_interp(t)*0.1+0.9, spec.x/0.4);
 
 
 
    col += 1.0 -  smoothstep( 0.0, 0.15, abs(wave - q.x) );
 
    //col = pow(col, vec3(1.3));
    //col2 = pow(col2, vec3(0.45));
 
    fragColor = vec4(col, 1.0);
}



Clicca sul link qui sotto e metti le mani davanti alla webcam :

https://www.shadertoy.com/view/WtjGDz

// This is a rework of https://www.shadertoy.com/view/lssGDj,
// created by movAX13h, with sound, by Radical Ed

float character(int n, vec2 p)
{
p = floor(p*vec2(4.0, -4.0) + 2.5);
    if (clamp(p.x, 0.0, 4.0) == p.x)
{
        if (clamp(p.y, 0.0, 4.0) == p.y)
{
        int a = int(round(p.x) + 5.0 * round(p.y));
if (((n >> a) & 1) == 1) return 1.0;
}
    }
return 0.0;
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
 
    {
     
     // create pixel coordinates
vec2 uv = fragCoord.xy / iResolution.xy;

    // the sound texture is 512x2
    int tx = int(uv.x*512.0);
 

    // second row is the sound wave, one texel is one mono sample
    float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
vec2 pix = fragCoord.xy;
vec3 col = texture(iChannel0, floor(pix/8.0)*8.0/iResolution.xy).rgb;

float gray = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;

int n =  4096;                // .
if (gray > 0.2) n = 65600;    // :
if (gray > 0.3) n = 332772;   // *
if (gray > 0.4) n = 15255086; // o
if (gray > 0.5) n = 23385164; // &
if (gray > 0.6) n = 15252014; // 8
if (gray > 0.7) n = 13199452; // @
if (gray > 0.8) n = 11512810; // #

vec2 p = mod(pix/4.0, 2.0) - vec2(1.0);
 
if (iMouse.z > 0.5) col = gray*vec3(character(n, p));
else col = col*character(n, p);

fragColor = vec4(col+ 1.0 -  smoothstep( 0.0, 0.15, abs(wave - uv.y) ), 1.0);
}




#define PERIOD 2.
#define REPETITIONS 2

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross2(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = iResolution.x / iResolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
   
    float d = length(pc - p) / 0.015*scale/0.3;
   
    return vec3(3. * vec3(0.2, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
   
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
   
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 p = fragCoord.xy / iResolution.yy;
    vec2 q = fragCoord.xy / iResolution.yy;
   
    int tx = int(p.x*128.0);
   
    // per lo Spectrum Audio
    float wave = texelFetch( iChannel0, ivec2(tx,1), 0 ).x;
    vec3 spec = vec3(wave);
   
    vec2 translate = vec2(cos(iTime),sin(iTime));
    vec2 translate2 = vec2(sin(iTime),cos(iTime));
    p += translate*0.35*sin(iTime);
    q += translate2*1.35*sin(iTime);
   
    float t = abs(2. * fract(iTime / PERIOD) - 1.);
    //int sel = int(6. * fract(time / (float(REPETITIONS) * PERIOD) / 6.));
    int sel = 5;
   
    // Background pattern
   
    vec3 col = vec3(0.0 + 0.000 * mod(floor(p.x * 10.0) + floor(p.y * 10.0), 2.0));
    vec3 col2 = vec3(0.0 + 0.000 * mod(floor(q.y * 5.0) + floor(q.x * 5.0), 2.0));
    //vec3 col = vec3(0.0,0.0,0.0,0.0));
   
   
    col += shadeBlob(p, 0.1, smoothstep_interp(t)*spec.x+0.5, wave/3.0);
    col2 += shadeBlob(q, 0.3+spec.z, linear_interp(t)*spec.y+0.5, wave/3.0);
    col += shadeBlob(p, 0.5+spec.x, cosine_interp(t)*spec.z+0.7, wave/3.0);
    col2 += shadeBlob(q, 0.7, smoothstep_interp(t)*spec.z+0.1, wave/3.0);
    col += shadeBlob(p, 0.9-spec.y, quintic_interp(t)*spec.z+0.3, wave/3.0);
   
   
    col = pow(col, vec3(0.45));
    col2 = pow(col2, vec3(0.45));
   
    fragColor = vec4(col+col2, 1.0);
}





#define PERIOD 2.
#define REPETITIONS 2

uniform float time;
uniform vec2 resolution;
uniform vec2 mouse;
uniform vec3 spectrum;

const float PI = 3.1415926535;


float box(in vec2 _st, in vec2 _size){
    _size = vec2(0.5) - _size*0.5;
    vec2 uv = smoothstep(_size,
                        _size+vec2(0.001),
                        _st);
    uv *= smoothstep(_size,
                    _size+vec2(0.001),
                    vec2(1.0)-_st);
    return uv.x*uv.y;
}

float cross(in vec2 _st, float _size){
    return  box(_st, vec2(_size,_size/4.)) +
            box(_st, vec2(_size/4.,_size));
}

vec3 shadeBlob(vec2 p, float index, float value, float scale)
{
    float screenRatio = resolution.x / resolution.y;
    vec2 pc = vec2(0.1 + (screenRatio - 0.2) * value, index);
 
    float d = length(pc - p) / 0.015*scale/0.3;
 
    return vec3(3. * vec3(0.2, 0.5, 0.7) / (max(d * d, 1.)));
}

float step_interp(float x) {
    return step(0.5, x);
}

float linear_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c;
}

float cosine_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return 0.5 * (1. - cos(PI * c));
}

float smoothstep_interp(float x) {
//    return smoothstep(0., 1., x);

    float c = clamp(x, 0., 1.);
 
    return c * c * (3. - 2. * c);
}

float quintic_interp(float x) {
    float c = clamp(x, 0., 1.);
 
    return c * c * c * ((6. * c - 15.) * c + 10.);
}

void main(void)
{
    vec2 p = gl_FragCoord.xy / resolution.yy;
    vec2 q = gl_FragCoord.xy / resolution.yy;
 
    vec3 spec = .1+spectrum;
 
    vec2 translate = vec2(cos(time),sin(time));
    vec2 translate2 = vec2(sin(time),cos(time));
    p += translate*0.35*sin(time);
    q += translate2*1.35*sin(time);
 
    float t = abs(2. * fract(time / PERIOD) - 1.);
 
 
    vec3 col = vec3(0.0 + 0.000 * mod(floor(p.x * 10.0) + floor(p.y * 10.0), 2.0));
    vec3 col2 = vec3(0.0 + 0.000 * mod(floor(q.y * 5.0) + floor(q.x * 5.0), 2.0));
 
 
    col += shadeBlob(p, 0.1, smoothstep_interp(t)*spec.x+0.5, spec.x/0.1);
    col2 += shadeBlob(q, 0.3+spec.z, linear_interp(t)*spec.y+0.5, spec.z);
    col += shadeBlob(p, 0.5+spec.x, cosine_interp(t)*spec.z+0.7, spec.z/0.3);
    col2 += shadeBlob(q, 0.7, smoothstep_interp(t)*spec.z+0.1, spec.x/0.6);
    col += shadeBlob(p, 0.9-spec.y, quintic_interp(t)*spec.z+0.3, spec.z/0.9);

 
    col = pow(col, vec3(0.45));
    col2 = pow(col2, vec3(0.45));
 
    gl_FragColor = vec4(col+col2, 1.0);
}