(
// scratchy
play({  RHPF.ar(BrownNoise.ar([0.5,0.5], -0.49).max(0) * 20, 5000, 1)  })
)

(
// scratchy
play({  RHPF.ar(BrownNoise.ar([0.5,0.5], -0.49).max(0) * 20, 5000, 1)  })
)

{ BrownNoise.ar([0.5,0.5], -0.49).max(0) * 20 }.play;

RHPF

RHPF.ar(in, freq, q, mul, add)

A resonant high pass filter. 
in - input signal to be processed
freq - cutoff frequency.
rq - the reciprocal of Q.  bandwidth / cutoffFreq. 

{ RHPF.ar(Saw.ar(200,0.1), FSinOsc.kr(XLine.kr(0.7,300,20), 0, 3600, 4000), 0.2) }.play;

BrownNoise

BrownNoise.ar(mul, add)

Generates noise whose spectrum falls off in power by 6 dB per octave.

// compare
{ BrownNoise.ar(0.5) }.play;
{ WhiteNoise.ar(0.5) }.play;

max				maximum

BinaryOperator

max(a, b)
a max: b
a.max(b)

(
{
var z;
z = FSinOsc.ar(500);
z max: FSinOsc.ar(0.1);
}.play) // modulates and envelopes z

5 max: 10

([0.5, -0.49]).max(0);

([-0.4,0.8,-0.2], 0.49).max(0);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

Dust

(
SynthDef("help-Dust", { arg out=0;
	Out.ar(out, 
		Dust.ar(2.5, 0.5)
	)
}).play;
)

(
SynthDef("help-Dust", { arg out=0;
	Out.ar(out, 
		Dust.ar(XLine.kr(20000, 2, 10), 0.5)
	)
}).play;
)

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

(
var a, c, d, s, z, y;
// reverberated sine percussion
d = 6; // number of percolators
c = 5; // number of comb delays
a = 4; // number of allpass delays

play({
		// sine percolation sound :
//	s = Mix.ar(Array.fill(d, { Resonz.ar(Dust.ar(2/d, 50), 200 + 3000.0.rand, 0.003)}) );
	s = Dust.ar(2.5, 2.5);
	
		// reverb predelay time :
	z = DelayN.ar(s, 0.048);
	
		// 7 length modulated comb delays in parallel :
	y = Mix.ar(CombL.ar(z, 0.1, LFNoise1.kr(Array.fill(c,{0.1.rand}), 0.04, 0.05), 15)); 
	
		// chain of 4 allpass delays on each of two channels (8 total) :
	a.do({ y = AllpassN.ar(y, 0.050, [0.050.rand,0.050.rand], 1) });
	
		// add original sound to reverb and play it :
	s+(0.2*y)
}))

Resonz			resonant filter

Resonz.ar(in, freq, rq, mul, add)

A two pole resonant filter with zeroes at z = +/- 1. Based on K. Steiglitz,  "A Note on Constant-Gain 
Digital Resonators," Computer Music Journal, vol 18, no. 4, pp. 8-10, Winter 1994.
in - input signal to be processed
freq - resonant frequency in Hertz
rq - bandwidth ratio (reciprocal of Q). rq = bandwidth / centerFreq
The reciprocal of Q is used rather than Q because it saves a divide operation inside the unit generator.

{ Resonz.ar(WhiteNoise.ar(0.5), 2000, 0.1) }.play

// modulate frequency
{ Resonz.ar(WhiteNoise.ar(0.5), XLine.kr(1000,8000,10), 0.05) }.play

// modulate bandwidth
{ Resonz.ar(WhiteNoise.ar(0.5), 2000, XLine.kr(1, 0.001, 8)) }.play

// modulate bandwidth opposite direction
{ Resonz.ar(WhiteNoise.ar(0.5), 2000, XLine.kr(0.001, 1, 8)) }.play

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

10pi.rand;

(
Routine({
loop({
	play({
		Pan2.ar(Klang.ar(`[ Array.rand(12, 200.0, 2000.0), nil, nil ], 1, 0), 1.0.rand) 
			* EnvGen.kr(Env.sine(4), 1, 0.02, doneAction: 2);
	});
	2.wait;
})
}).play;
)

////////////////////////////////////////////////////////////////////

(
{
	var trig, seq;
	trig = Impulse.kr(12);
	seq = Drand([
		Dseq([4,0,0,1,2,1,0,1]),
		Dseq([4,0,2,0,1,0,1,1]),
		Dseq([4,0,0,2,0,0,1,1]),
		Dseq([4,0,1,2,0,1,2,0]),
		Dseq([4,1,1,1,2,2,3,3]),
		Dseq([4,1,0,1,0,1,0,1])
	], inf);
	trig = Demand.kr(trig, 0, seq * 0.4) * trig;
	{LPF.ar(WhiteNoise.ar, 5000)}.dup * Decay.kr(trig, 0.5);
}.play;
)

////////////////////////////////////////////////////////////////////

UGens Help

(incomplete)

[Tour_of_UGens]

	UGen

Analysis

	Amplitude
	Compander
	Pitch
	Slope
	ZeroCrossing

Control

	DegreeToKey
	Slew
	MouseX
	MouseY
	MouseButton
	Demand
	
In/Out

	AudioIn
	In
	InTrig
	InFeedback
	Out
	ReplaceOut
	XOut
	OffsetOut
	LocalIn
	LocalOut
	SharedIn
	SharedOut

Oscillators
	
	Blip
	Formant
	FSinOsc
	Gendy1
	Gendy2
	Gendy3
	Impulse
	Klang
	LFCub
	LFPar
	LFPulse
	LFSaw
	Osc
	OscN
	Pulse
	Saw
	SinOsc
	SyncSaw
	VarSaw
	VOsc
	VOsc3

Delays

	AllpassC
	AllpassL
	AllpassN
	CombC
	CombL
	CombN
	Delay1
	Delay2
	DelayC
	DelayL
	DelayN
	PingPong
	PitchShift
	
Multiple Channels
	
	Mix
	MultiOutUGen
	OutputProxy
	
	BiPanB2
	DecodeB2
	LinPan2
	LinXFade2
	Pan2
	Pan4
	PanAz
	PanB
	PanB2
	Rotate2
	XFade2
	
Physical Models

	Ball
	Spring
	TBall
	
Filters
	
	BPF
	BPZ2
	BRF
	Formlet
	FOS
	HPF
	HPZ1
	HPZ2
	Integrator
	Klank
	Lag
	Lag2
	Lag3
	LeakDC
	Limiter
	LinExp
	LinLin
	LPF
	LPZ1
	LPZ2
	Median
	Normalizer
	OnePole
	OneZero
	Resonz
	RHPF
	Ringz
	RLPF
	SOS
	TwoPole
	TwoZero
	
Noise
	
	LFNoise1
	LFNoise2 
	LFNoise0 
	LFClipNoise      
	
	NoahNoise        
	WhiteNoise
	GrayNoise 
	Hasher
	MantissaMask
	PinkerNoise
	PinkNoise
	ClipNoise        
	Dust             
	Dust2            
	Latoocarfian     
	Rossler
	Crackle      
	         
Triggers

 	MostChange       
 	PulseCount
	Stepper
	Gate
	CoinGate             
	Peak             
	PulseDivider
	LastValue
	Latch
	Trig
	Trig1
	SendTrig
	Sweep
	Timer
	Phasor
	
Frequency Domain

	FFT
	Convolution
	PV_ConformalMap

Buffer Manipulation

	BufRd
	BufWr
	DiskIn
	DiskOut
	Index
	WrapIndex
	PlayBuf
	RecordBuf
	PingPong
	TGrains
	
Binary Operators

	BinaryOpUGen (overview)
	+
	-
	*
	/
	**
	absdif
	amclip
	atan2
	clip2
	difsqr
	excess
	fold2
	hypot
	hypotApx
	max
	min
	ring1
	ring2
	ring3
	ring4
	round
	scaleneg
	sqrdif
	sqrsum
	sumsqr
	thresh
	trunc
	wrap2

InfoUGens

	BufChannels
	BufDur
	BufFrames
	BufRateScale
	BufSampleRate
	NumRunningSynths
	SampleDur
	SampleRate

Synth-Controlling-UGens

	see overview: [Synth-Controlling-UGens]
	
	Control
	DetectSilence
	EnvGen
	Line
	XLine
	Linen
	Free
	FreeSelf
	Pause
	PauseSelf

Random Values

	Rand
	ExpRand          
	LinRand  
	NRand
	IRand 
	TIRand
	TRand
	TExpRand
	RandSeed
	RandID
	
Array Usage

	Select 
	TWindex

	        
	
 to be continued  ....