| 
qlist | 
 | 
jit.buffer~ | 
 | 
jit.matrixset | 
 | 
adsr~ | 
 | 
buffer~, info~, sfplay~, sfrecord~
 | 
 | 
spell | 
 | 
sprintf | 
 | 
spell | 
 | 
relativepath | 
| 
				of an integer or floating-point number
			 | 
abs | 
| 
				of all samples in a signal
			 | 
abs~ | 
| 
				of all samples in a matrix
			 | 
jit.op | 
 | 
setclock | 
 | 
setclock | 
 | 
pattrhub | 
 | 
adoutput~ | 
| 
				for integer and floating-point numbers
			 | 
accum | 
| 
				for signals
			 | 
+=~ | 
 | 
midiin, midiout, rtin
 | 
| 
				two matrices
			 | 
jit.op, jit.expr
 | 
| 
				two numbers
			 | 
+, accum, expr
 | 
| 
				two signals
			 | 
+~ | 
| 
				arguments to the begining of a message
			 | 
prepend | 
| 
				arguments to the end of a message
			 | 
append | 
| 
				a series of numbers
			 | 
accum, expr, table
 | 
 | 
+~, cycle~, ioscbank~, oscbank~
 | 
 | 
counter, funbuff, offer, table
 | 
 | 
jit.brcosa | 
 | 
polyin, polyout
 | 
 | 
touchin, touchout
 | 
| 
				display a text message
			 | 
dialog, lcd, umenu, message, pcontrol, print
 | 
| 
				flash when an event occurs
			 | 
button, led, ubutton
 | 
 | 
dspstate~, onepole~
 | 
 | 
ctlin, ctlout
 | 
 | 
poly | 
 | 
allpass~ | 
| 
				amplitude control
			 | 
*~, /~, gain~, normalize~, omx.4band~, omx.5band~, omx.comp~, omx.peaklim~
 | 
| 
				amplitude indicator
			 | 
average~, avg~, levelmeter~, meter~, spectroscope~
 | 
| 
				amplitude modulation
			 | 
*~ | 
| 
				conversion from decibels
			 | 
dbtoa | 
| 
				conversion from decibels (for signals)
			 | 
dbtoa~ | 
| 
				convesion to decibels
			 | 
atodb | 
| 
				convesion to decibels (for signals)
			 | 
atodb~ | 
 | 
adc~, ezadc~
 | 
 | 
fft~, pfft~, scope~, spectroscope~
 | 
| 
      	compute signal minimum and maximum values
       | 
minmax~ | 
| 
      	detect signal change and direction
       | 
change~ | 
| 
      	detect when input goes above a set value
       | 
thresh~ | 
| 
      	detect zero to non-zero signal transitions
       | 
edge~ | 
| 
      	display a signal in real time
       | 
scope~ | 
| 
      	FFT analysis of a signal
       | 
cartopol~, fft~, fftin~, fftout~, pfft~
 | 
| 
      	output the maximum of two signals
       | 
maximum~ | 
| 
      	output the minimum of two signals
       | 
minimum~ | 
| 
      	report intervals of zero to non-zero transitions
       | 
spike~ | 
| 
      	report sample values from a signal
       | 
snapshot~ | 
| 
      	report the peak amplitude of a signal
       | 
peakamp~ | 
| 
      	signal counter
       | 
count~ | 
| 
      	store a signal to view as text
       | 
capture~ | 
| 
      	sync MSP with MIDI, click, or tap tempo
       | 
sync~ | 
| 
      	zero-crossing counter/transient detector
       | 
zerox~ | 
| 
				convert a scan line to a Max list
			 | 
jit.iter | 
| 
				find the location of a specified color/data
			 | 
jit.findbounds | 
| 
				histogram of matrix components
			 | 
jit.histogram | 
| 
				output the min, mean, and max for each plane
			 | 
jit.3m | 
| 
				read a matrix as an audio signal
			 | 
jit.peek~ | 
 | 
expr, &&
 | 
 | 
lcd | 
 | 
serial, vdp
 | 
 | 
imovie, movie, playbar
 | 
 | 
rect~, saw~, tri~
 | 
 | 
append, prepend
 | 
 | 
<<, >>, &, |, expr, jit.op, vexpr
 | 
 | 
jit.str.op | 
 | 
jit.p.vishnu | 
 | 
jit.tiffany | 
 | 
see Arithmetic operators | 
| 
			for integers and floating-point numbers
			 | 
expr, +, -, !-, *, /, !/, %, acos, acosh, asin, asinh, atan, atan2, atanh, cosh, sin, sinh, sqrt, tan, tanh, vexpr
 | 
| 
			for matrices
			 | 
jit.expr, jit.op
 | 
 | 
+~, -~, !-~, *~, /~, !/~, %~, acos~, acosh~, asin~, asinh~, atan~, atanh~, atan2~, cos~, cosh~, cosx~, sinh~, sinx~, tanh~, tanx~
 | 
 | 
coll, umenu
 | 
 | 
funbuff, histo, offer, table
 | 
 | 
atoi | 
| 
				for a file or folder
			 | 
opendialog | 
| 
				the user to enter information
			 | 
dialog, message
 | 
 | 
selector~, switch
 | 
 | 
inlet, outlet
 | 
 | 
cycle, iter, message, spray, unpack, zl
 | 
 | 
adstatus | 
| 
      	access audio driver output channels
       | 
adoutput~ | 
| 
      	audio output
       | 
dac~ | 
| 
      	control devices using ReWire
       | 
rewire~ | 
| 
      	icon-based 2 channel audio output
       | 
ezdac~ | 
| 
      	icon-based 2 channel audio input
       | 
ezadc~ | 
| 
      	output audio from computer's input source
       | 
adc~ | 
`    | 
      	record signals to soundfiles on disk
       | 
sfrecord~ | 
| 
      	report information about a sound file
       | 
sfinfo~ | 
| 
      	soundfile playback
       | 
sfplay~ | 
| 
      	store a list of sound file cues
       | 
sflist~ | 
| 
				convert number of samples to millisecond values
			 | 
sampstoms~ | 
| 
				convert millisecond values to a number of samples
			 | 
mstosamps~ | 
| 
				disable signal objects in a patcher
			 | 
mute~ | 
| 
				elminate noise in a muted subpatcher
			 | 
pass~ | 
| 
				manage polyphony
			 | 
poly~ | 
| 
				report time since audio was turned on
			 | 
dsptime~ | 
| 
				report info about current DSP settings
			 | 
dspstate~ | 
| 
				report audio processing information
			 | 
adstatus | 
| 
				a running stream of numbers
			 | 
mean | 
| 
				values of cells in a matrix
			 | 
jit.3m | 
| 
				four points in a matrix
			 | 
jit.avg4 | 
| 
				signal amplitude
			 | 
avg~ | 
 | 
bgcolor | 
 | 
panel | 
 | 
active | 
 | 
groove~, play~
 | 
 | 
rand~ | 
 | 
biquad~, filtercoeff~, filtergraph~, reson~
 | 
| 
				count bang messages
			 | 
counter | 
| 
				message traffic control
			 | 
onebang | 
| 
				report elapsed time between two bang messages
			 | 
timer | 
| 
				send a bang on closing a patch
			 | 
closebang | 
| 
				send a bang on loading a patch
			 | 
loadbang | 
| 
				send a bang to several outlets
			 | 
bangbang | 
| 
				send a bang when a message is received or the mouse is clicked
			 | 
button, ubutton
 | 
| 
				send a number of bangs as fast as possible
			 | 
uzi | 
| 
				send a single bang to different places in immediate succession
			 | 
bangbang, trigger
 | 
| 
				send bangs repeatedly at a certain rate
			 | 
metro | 
 | 
number | 
| 
				for integers
			 | 
<<, >>
 | 
| 
				for matrices
			 | 
jit.op | 
| 
				for signals
			 | 
bitshift~ | 
 | 
expr | 
| 
				for integers and floating point numbers
			 | 
bitand, bitor, expr, &, |
 | 
| 
				for matrices
			 | 
jit.op, jit.expr
 | 
| 
				for signals
			 | 
bitand~, bitor~, bitxor~, bitnot~
 | 
| 
				for integers and floating-point numbers
			 | 
if, <, <=, ==, !=, >=, >, &&, ||
 | 
| 
				for matrices
			 | 
jit.op | 
| 
				for signals
			 | 
<~, <=~, ==~, !=~, >=~, >~
 | 
| 
				into a series of numbers
			 | 
iter, zl
 | 
| 
				into individual items
			 | 
cycle, message, spray, unpack
 | 
 | 
funbuff, function, line, line~
 | 
 | 
ctlin, ctlout
 | 
 | 
universal | 
 | 
jit.qt.broadcast | 
 | 
drunk | 
 | 
jit.bsort | 
 | 
see Sampling and audio buffers | 
 | 
buffir~ | 
 | 
waveform~ | 
| 
				a standalone patcher
			 | 
standalone | 
| 
				sends 0 or 1
			 | 
led, toggle
 | 
| 
				sends bang
			 | 
button, ubutton
 | 
| 
				picture based button
			 | 
pictctrl | 
 | 
gate~, matrix~, mute~, pass~, poly~, selector~
 | 
 | 
expr, if
 | 
| 
				a histogram for matrices
			 | 
jit.histogram | 
| 
				bounding dimensions for a range of values in a matrix
			 | 
jit.findbounds | 
| 
				the determinant of a matrix
			 | 
jit.la.determinant | 
| 
				the inverse of a matrix
			 | 
jit.la.inverse | 
| 
				a mathematical expression
			 | 
see Arithmetic operators | 
| 
				the product across the main diagonal of a matrix
			 | 
jit.la.diagproduct | 
| 
				the square root of a number
			 | 
sqrt | 
| 
				the sum across the main diagonal of a matrix
			 | 
jit.la.trace | 
| 
				the transpose of a matrix
			 | 
jit.transpose | 
| 
				x to the power of y
			 | 
pow | 
| 
				x to the power of y (for signals)
			 | 
pow~ | 
 | 
capture, print, table, text
 | 
| 
				for numbers
			 | 
cartopol | 
| 
				for signals
			 | 
cartopol~ | 
 | 
cascade~ | 
| 
				spatial
			 | 
jit.scanslide | 
| 
				temporal
			 | 
jit.slide | 
 | 
drunk, expr, random, urn
 | 
 | 
bgcolor | 
 | 
spell | 
 | 
radiogroup | 
 | 
jit.keyscreen | 
 | 
cycle~, tapout~
 | 
 | 
clip~, dac~, normalize~
 | 
 | 
clocker, cpuclock, timer
 | 
 | 
setclock | 
 | 
midiin, midiout, rtin
 | 
 | 
pcontrol, thispatcher
 | 
 | 
closebang | 
 | 
jit.coerce | 
| 
				and edit messages
			 | 
coll | 
| 
				numbers
			 | 
bag | 
 | 
coll, umenu
 | 
 | 
jit.altern | 
 | 
colorpicker | 
 | 
swatch | 
 | 
panel | 
 | 
teeth~ | 
 | 
comb~ | 
 | 
urn | 
| 
				numbers and symbols into a list
			 | 
pack, pak
 | 
| 
				numbers that arrive closely into a list
			 | 
thresh | 
 | 
menubar | 
 | 
comment | 
| 
				a live MIDI performance to a recorded one
			 | 
follow | 
| 
				two integers or floating-point numbers
			 | 
see Boolean operators, change, multislider, number
 | 
| 
				two lists
			 | 
zl | 
| 
				two matricess
			 | 
see Boolean operators, jit.change, jit.fpsgui, jit.pwindow
 | 
| 
				two signals
			 | 
see Boolean operators, change~, meter~, scope~, snapshot~
 | 
| 
				compressor/gate
			 | 
omx.comp~ | 
| 
				4-band compressor
			 | 
omx.4band~ | 
| 
				5-band compressor
			 | 
omx.5band~ | 
| 
				a mathematical expression
			 | 
expr, +, -, *, /, %
 | 
| 
				the minimum and maximum values of a signal
			 | 
minmax~ | 
| 
				phase deviation between successive FFT frames
			 | 
framedelta~ | 
| 
				"running phase" of successive phase deviation frames
			 | 
frameaccum~ | 
| 
				x to the power of y
			 | 
pow | 
 | 
key, keyup, modifiers, numkey
 | 
| 
				two lists
			 | 
pack, pak, zl
 | 
| 
				two matrices
			 | 
jit.concat | 
| 
				two messages
			 | 
append, prepend, zl
 | 
 | 
prepend, append
 | 
| 
				if
			 | 
if, match, select, split
 | 
| 
				boolean
			 | 
see Boolean operators | 
 | 
conformpath | 
 | 
inlet, outlet
 | 
| 
				to a subpatcher
			 | 
inlet, outlet
 | 
| 
				to a named object in patcher
			 | 
pvar | 
 | 
sig~ | 
 | 
drunk | 
 | 
midiformat, sxformat
 | 
 | 
prepend, append, pack, pak
 | 
 | 
midiin, midiout, rtin
 | 
 | 
ctlin, ctlout
 | 
| 
				a matrix of switches
			 | 
matrixctrl | 
| 
				audio driver settings
			 | 
adstatus | 
| 
				the clock speed of Max timing objects
			 | 
setclock | 
| 
				an external (non-MIDI) device
			 | 
serial, vdp
 | 
| 
				a function
			 | 
curve~, function, line~
 | 
| 
				a patcher window automatically
			 | 
thispatcher | 
| 
				a picture in a graphic window
			 | 
pictctrl | 
| 
				poly~ voice allocation and muting
			 | 
thispoly~ | 
| 
				a QuickTime movie
			 | 
jit.qt.movie, playbar
 | 
| 
				a ReWire host's transport
			 | 
hostcontrol~ | 
| 
				timing of max objects
			 | 
setclock | 
| 
				traffic for bang messages
			 | 
onebang | 
| 
				a videodisk player through serial port
			 | 
vdp | 
 | 
pictctrl | 
| 
				an absolute to a relative path
			 | 
relativepath | 
| 
				ASCII to integers
			 | 
atoi | 
| 
				ASCII to text
			 | 
sprintf | 
| 
				between colorspaces
			 | 
jit.colorspace, see Convert colorspaces
 | 
| 
				Cartesian to polar coordinates
			 | 
cartopol | 
| 
				Cartesian to polar coordinates for signals
			 | 
cartopol~ | 
| 
				deciBel value to linear amplitude
			 | 
dbtoa | 
| 
				deciBel value to linear amplitude at signal rate
			 | 
dbtoa~ | 
| 
				a filename into an absolute path
			 | 
absolutepath | 
| 
				frequency to MIDI note numbers
			 | 
ftom | 
| 
				frequency to MIDI note numbers at signal rate
			 | 
ftom~ | 
| 
				image to halftone image
			 | 
jit.roy | 
| 
				input characters to ASCII
			 | 
spell | 
| 
				an input range to an output range
			 | 
scale | 
| 
				integers to ASCII
			 | 
itoa | 
| 
				linear amplitude to a deciBel value
			 | 
atodb | 
| 
				linear amplitude to a deciBel value at signal rate
			 | 
atodb~ | 
| 
				a matrix into an upper triangular matrix
			 | 
jit.la.uppertri | 
| 
				Max messages to low priority at scheduler time
			 | 
jit.qball | 
| 
				Max messages to symbols
			 | 
tosymbol | 
| 
				Max symbol to Jitter string matrix
			 | 
jit.str.fromsymbol | 
| 
				MIDI note number to frequency
			 | 
mtof | 
| 
				MIDI note number to frequency at signal rate
			 | 
mtof~ | 
| 
				milliseconds to samples
			 | 
mstosamps~ | 
| 
				a number, list, or symbol to a bang
			 | 
button, bangbang, trigger
 | 
| 
				pathname to filename
			 | 
strippath | 
| 
				polar coordinates to Cartesian
			 | 
poltocar | 
| 
				polar coordinates to Cartesian at signal rate
			 | 
poltocar~ | 
| 
				symbol(s) into messages and numbers
			 | 
fromsymbol | 
| 
				numbers between decimal, hexadecimal, and binary forms
			 | 
number | 
| 
				samples to milliseconds
			 | 
sampstoms~ | 
| 
				text to ASCII numbers
			 | 
spell | 
| 
				Max window errors into messages
			 | 
error | 
| 
				ARGB to AYUV
			 | 
jit.argb2ayuv | 
| 
				ARGB to GRGB
			 | 
jit.argb2grgb | 
| 
				ARGB to UYVY
			 | 
jit.argb2uyvy | 
| 
				AYUV to ARGB
			 | 
jit.ayuv2argb | 
| 
				AYUV to UYVY
			 | 
jit.ayuv2uyvy | 
| 
				AYUV to monochrome (luminance)
			 | 
jit.ayuv2luma | 
| 
				GRGB to ARGB
			 | 
jit.grgb2argb | 
| 
				HSL to RGB
			 | 
jit.hsl2rgb | 
| 
				RGB to monochrome (luminance)
			 | 
jit.rgb2luma | 
| 
				UYVY to ARGB
			 | 
jit.uyvy2argb | 
| 
				UYVY to AYUV
			 | 
jit.uyvy2ayuv | 
| 
				UYVY to monochrome (luminance)
			 | 
jit.uyvy2luma | 
| 
				monochrome (luminance) to AYUV
			 | 
jit.luma2ayuv | 
| 
				monochrome (luminance) to UYVY
			 | 
jit.luma2uyvy | 
| 
				messages to audio
			 | 
curve~, line~, peek~, sig~
 | 
| 
				messages to matrices
			 | 
jit.cellblock, jit.fill, jit.matrix, jit.str.fromsymbol
 | 
| 
				audio to matrices
			 | 
jit.buffer~, jit.catch~, jit.poke~
 | 
| 
				audio to messages
			 | 
capture~, peakamp~, peek~, snapshot~
 | 
| 
				matrices to audio
			 | 
jit.buffer~, jit.peek~, jit.release~
 | 
| 
				matrices to messages
			 | 
jit.iter, jit.matrix, jit.spill, jit.str.tosymbol
 | 
 | 
jit.convolve | 
 | 
jit.conway | 
 | 
jit.desktop | 
 | 
see Arithmetic operators | 
 | 
counter | 
 | 
histo | 
 | 
uzi | 
| 
				received bangs and output the count
			 | 
counter | 
| 
				the occurrences of numbers
			 | 
histo | 
| 
				an audio impulse
			 | 
click~ | 
| 
				a coloured background area
			 | 
panel | 
| 
				a custom menu bar
			 | 
menubar | 
				a drop region for files
			 | 
dropfile | 
| 
				a file dialog
			 | 
opendialog | 
| 
				a GL accelerated volume vizualization
			 | 
jit.gl.volume | 
| 
				a pop-up menu with names of MIDI devices
			 | 
midiinfo | 
| 
				a multi-track sequencer
			 | 
mtr | 
| 
				multiple sliders with graphic display
			 | 
multislider | 
| 
				a subpatch within a patch
			 | 
patcher | 
| 
				a visible subpatcher inside a box
			 | 
bpatcher | 
 | 
jit.xfade | 
 | 
jit.hatch | 
 | 
cross~ | 
 | 
accum, expr, table
 | 
 | 
jit.scissors | 
 | 
bucket | 
 | 
jit.cycle | 
 | 
+~, -~, number~, sig~
 | 
 | 
buddy | 
| 
				for numbers
			 | 
slide | 
| 
				for matrices
			 | 
jit.slide | 
| 
				for signals
			 | 
onepole~, slide~
 | 
| 
				information about the state of a Max patch
			 | 
preset, pattrstorage
 | 
| 
				messages
			 | 
coll, text, jit.cellblock, zl, umenu
 | 
| 
				MIDI data
			 | 
mtr, seq
 | 
| 
				number pairs
			 | 
bag, coll, funbuff, offer, table, zl
 | 
| 
				numbers
			 | 
int, float, pvar, value
 | 
| 
				audio
			 | 
buffer~, sfplay~, sfrecord~
 | 
| 
				matrices
			 | 
jit.matrix, jit.matrixset, jit.qt.movie, jit.qt.record, jit.textfile, jit.fprint
 | 
 | 
coll, umenu
 | 
 | 
date | 
| 
				from amplitude
			 | 
atodb | 
| 
				to amplitude
			 | 
dbtoa | 
 | 
incdec | 
 | 
deferlow | 
| 
				a region for dragging and dropping a file
			 | 
dropfile | 
| 
				a switchable part of a signal network
			 | 
begin~ | 
| 
				a bang
			 | 
delay | 
| 
				audio
			 | 
allpass~, comb~, delay~, tapin~, tapout~, teeth~
 | 
| 
				audio delay line specified in samples
			 | 
delay~ | 
| 
				event timing
			 | 
borax, clocker, date, timer
 | 
| 
				the execution of a message
			 | 
deferlow | 
| 
				note-off messages
			 | 
sustain | 
| 
				one or more numbers for specific time
			 | 
pipe, thresh
 | 
| 
				numbers or a list
			 | 
pipe | 
 | 
borax, timer
 | 
 | 
jit.demultiplex | 
 | 
defer | 
| 
				numbers above zero
			 | 
> | 
| 
				the active patcher window
			 | 
active | 
| 
				chords
			 | 
quickthresh | 
| 
				when input exceeds a certain number
			 | 
past | 
| 
				key presses
			 | 
key | 
| 
				key releases
			 | 
keyup | 
| 
				largest numbers in a list
			 | 
maximum | 
| 
				the logical separation of messages
			 | 
next | 
| 
				logical signal transitions
			 | 
edge~ | 
| 
				signals above a set level
			 | 
thresh~ | 
| 
				smallest numbers in a list
			 | 
minimum | 
| 
				the smallest of a series of numbers
			 | 
trough | 
| 
				zero crossings
			 | 
zerox~ | 
| 
				zero/non-zero transitions
			 | 
togedge | 
 | 
serial, vdp
 | 
 | 
midiinfo | 
 | 
dial | 
| 
				between matrices
			 | 
jit.change, jit.op
 | 
| 
				between numbers
			 | 
expr, -, zl
 | 
| 
				between samples
			 | 
change~, delta~
 | 
| 
				between signals
			 | 
-~, scope~
 | 
 | 
dac~, ezdac~
 | 
| 
				using DirectX (Windows only)
			 | 
jit.dx.grab | 
| 
				using QuickTime
			 | 
jit.qt.grab | 
 | 
sfplay~ | 
 | 
mute~ | 
 | 
gate~, mute~, pass~, poly~, selector~
 | 
 | 
speedlim | 
 | 
jit.plume | 
| 
				data in a window
			 | 
jit.window | 
| 
				display/change a range of numbers
			 | 
rslider | 
| 
				a flash on event
			 | 
button, led, ubutton
 | 
| 
				matrix attributes
			 | 
jit.fpsgui | 
| 
				numbers in decimal, hexadecimal, or binary form
			 | 
number | 
| 
				numerical data graphically
			 | 
dial, kslider, multislider, number, slider, table
 | 
| 
				on/off status in colour
			 | 
led | 
| 
				a picture from a graphics file
			 | 
fpic | 
| 
				signal values
			 | 
capture~, meter~, number~, scope~, snapshot~
 | 
| 
				a text message
			 | 
dialog, lcd, umenu, message, pcontrol, print
 | 
| 
				zero/non-zero status of a number
			 | 
led, number, toggle
 | 
 | 
kink~ | 
| 
				numbers to sequential outlets
			 | 
cycle | 
| 
				to a numbered outlet
			 | 
spray | 
| 
				two matrices
			 | 
jit.expr, jit.op
 | 
| 
				two numbers
			 | 
/, expr
 | 
| 
				two numbers (inlets reversed)
			 | 
!/ | 
| 
				two numbers and output the remainder
			 | 
% | 
| 
				two signals
			 | 
/~ | 
| 
				two signals (inlets reversed)
			 | 
!/~ | 
| 
				two signals and output the remainder
			 | 
%~ | 
 | 
avg~, degrade~, downsamp~, number~, poly~, sah~, snapshot~
 | 
 | 
dropfile | 
| 
				graphics in a patcher window
			 | 
lcd | 
| 
				coloured background area
			 | 
panel | 
| 
				shapes with the mouse
			 | 
lcd, jit.lcd, mousestate
 | 
| 
				report length of MIDI notes
			 | 
borax | 
| 
				specify duration for transmitted MIDI notes
			 | 
flush, makenote, midiflush, pipe
 | 
| 
				time between events
			 | 
timer | 
 | 
<~, >~, train~
 | 
 | 
record~, peek~, poke~
 | 
 | 
pass~ | 
 | 
change | 
 | 
bpatcher | 
 | 
jit.brass | 
 | 
pcontrol | 
 | 
append | 
 | 
number, numkey
 | 
 | 
dialog, message
 | 
| 
				editors
			 | 
function | 
| 
				follower
			 | 
peakamp~, meter~
 | 
| 
				follower, vector-based
			 | 
vectral~ | 
| 
				generator
			 | 
adsr~, curve~, function, line~, techno~
 | 
 | 
allpass~, biquad~, comb~, filtercoeff~, filtergraph~, lores~, reson~
 | 
| 
				display error text in a patcher window
			 | 
dialog, lcd, umenu, message, pcontrol
 | 
| 
				 print errors in the Max window
			 | 
print | 
| 
				a procedural basis function graph
			 | 
jit.bfg, jit.gencoord
 | 
| 
				input according to Perl-style expressions
			 | 
regexp | 
| 
				a mathematical expression
			 | 
expr, jit.expr, see Arithmetic operators
 | 
| 
				math expression for a list of inputs
			 | 
vexpr | 
 | 
borax | 
 | 
bline | 
 | 
expr | 
 | 
jstrigger | 
 | 
js, jsui
 | 
 | 
curve~, gain~, linedrive, pow~, techno~
 | 
 | 
gain~ | 
 | 
seq | 
 | 
autopattr | 
 | 
expr, +, -, *, /, %
 | 
 | 
setclock | 
 | 
xbendin, xbendin2, xbendout, xbendout2
 | 
 | 
listfunnel | 
 | 
buffir~ | 
 | 
multislider, rslider, slider
 | 
 | 
jit.qfaker | 
| 
				for matrices
			 | 
jit.fft | 
| 
				for signals
			 | 
fft~ | 
 | 
quickthresh | 
 | 
fffb~ | 
 | 
allpass~, biquad~, comb~, lores~, reson~, tapin~, tapout~
 | 
| 
				with convolution stage
			 | 
jit.wake | 
| 
				with gain stage
			 | 
jit.glop | 
 | 
menubar | 
| 
				get file modification date
			 | 
filedate | 
| 
				import and export MIDI files
			 | 
seq | 
| 
				list the files in a specific folder
			 | 
folder | 
| 
				open any type of file
			 | 
filein | 
 | 
jit.fill | 
 | 
setclock | 
| 
				allpass filter
			 | 
allpass~ | 
| 
				bandpass filter
			 | 
reson~ | 
| 
				biquadratic (multimode) filter
			 | 
biquad~, cascade~
 | 
| 
				buffer-based FIR convolution filter
			 | 
buffir~ | 
| 
				comb filter
			 | 
comb~, teeth~
 | 
| 
				crossover filter
			 | 
cross~ | 
| 
				fast fixed filter bank
			 | 
fffb~ | 
| 
				lowpass filter
			 | 
lores~, onepole~
 | 
| 
				state variable filter
			 | 
svf~ | 
| 
				note-on messages
			 | 
stripnote | 
 | 
speedlim | 
 | 
slide~ | 
| 
				out repetitions of a number
			 | 
change | 
| 
				numbers to a certain range
			 | 
clip | 
| 
				an input number logarithmically
			 | 
slide | 
| 
				the elapsed time
			 | 
clocker | 
| 
				which of two numbers is less than the other
			 | 
< | 
| 
				Find which of two numbers is less than or equal to the other
			 | 
<= | 
| 
				which of two numbers is greater than the other
			 | 
< | 
| 
				which of two numbers is greater than or equal to the other
			 | 
<= | 
| 
				Bitwise intersection of two numbers
			 | 
& | 
| 
				Bitwise union of two numbers
			 | 
| | 
| 
				the absolute value of a number
			 | 
abs | 
| 
				the greatest number in a list
			 | 
maximum | 
| 
				the smallest number in a list
			 | 
minimum | 
| 
				the running average in a stream of numbers
			 | 
mean | 
| 
				the peak number
			 | 
peak | 
 | 
jit.avc | 
 | 
conformpath | 
 | 
cycle~, tapout~
 | 
 | 
button | 
 | 
jit.graph | 
 | 
float, number
 | 
 | 
folder | 
 | 
follow | 
 | 
thispatcher | 
 | 
active | 
| 
				a message of numbers and words
			 | 
sprintf | 
| 
				Prepare MIDI messages for transmission or recording
			 | 
midiformat, sxformat
 | 
| 
				Numbers as a text file
			 | 
text | 
 | 
forward | 
 | 
fft~, ifft~, pfft~
 | 
 | 
xbendin, xbendout, xbendin2
 | 
 | 
jit.freeframe | 
| 
				frequency shifter for pfft~
			 | 
fbinshift~ | 
| 
				pitch shifter for pfft~
			 | 
gizmo~ | 
 | 
+~, cycle~, phasor~
 | 
 | 
freqshift~, fbinshift~
 | 
 | 
ftom | 
 | 
histo | 
 | 
strippath | 
| 
				for integers and floating-point numbers
			 | 
funbuff, function, line
 | 
| 
				for signals
			 | 
adsr~, curve~, function, line~, peek~, poke~, techno~
 | 
| 
				numbers, messages, or matrices
			 | 
gate, ggate, switch, gswitch, router
 | 
| 
				signals
			 | 
gate~, matrix~, selector~
 | 
 | 
bag, coll
 | 
| 
				a plain old bang
			 | 
button | 
| 
				on loading a patch
			 | 
loadbang | 
| 
				on close of patch
			 | 
closebang | 
| 
				to numerous outlets
			 | 
bangbang | 
| 
				at regular intervals
			 | 
metro | 
| 
				a certain number of times, as fast as possible
			 | 
uzi | 
| 
				for messages received or mouse clicks
			 | 
button, ubutton
 | 
| 
				to all loadbang objects
			 | 
thispatcher | 
| 
				Chebyshev gradients
			 | 
jit.gradient | 
| 
				 draw in a Jitter window (using OpenGL)
			 | 
jit.gl.sketch | 
| 
				 draw in a Jitter window (using QuickDraw)
			 | 
jit.lcd | 
| 
				 GL geometry from existing data
			 | 
jit.gl.mesh | 
| 
				 GL-based surface extraction
			 | 
jit.gl.isosurf | 
| 
				 NURBS surfaces
			 | 
jit.gl.nurbs | 
| 
				 Particle systems
			 | 
jit.p.bounds, jit.p.shiva, jit.p.vishnu
 | 
| 
				 Platonic solids
			 | 
jit.gl.plato | 
| 
				 simple geometric shapes as a connected grid
			 | 
jit.gl.gridshape | 
| 
				Pseudo-random numbers
			 | 
drunk, expr, random, urn
 | 
| 
				a zero or one randomly
			 | 
decide | 
| 
				random numbers
			 | 
random | 
| 
				random numbers without duplicates
			 | 
urn | 
| 
				random numbers in a moving range
			 | 
drunk | 
| 
				numbers from onscreen keyboard slider
			 | 
kslider | 
| 
				numbers in a ramp from one value to another
			 | 
line | 
| 
				exponentially scaled numbers
			 | 
linedrive | 
| 
				in a weighted series
			 | 
prob | 
| 
				or change a range of numbers
			 | 
rslider | 
| 
				using an on-screen slider
			 | 
slider | 
| 
				data in MIDI format
			 | 
midiformat | 
| 
				MIDI notes with off messages
			 | 
makenote | 
| 
				MIDI note-offs for hanging note-ons
			 | 
midiflush | 
 | 
dial, imovie, kslider, lcd, mousestate, multislider, number, rslider, slider, table
 | 
| 
				a multi-segment line, event-driven
			 | 
bline | 
| 
				an ADSR envelope
			 | 
function | 
| 
				the absolute value of a number
			 | 
abs | 
| 
				arguments from parent patcher
			 | 
patcherargs | 
| 
				the ASCII number for each character in a string
			 | 
spell | 
| 
				the current file search path
			 | 
filepath | 
| 
				the current system info
			 | 
gestalt | 
| 
				the current time/date
			 | 
date | 
| 
				discrete values from data stream
			 | 
speedlim | 
| 
				the filename from a pathname
			 | 
strippath | 
| 
				input MIDI pitch bend values
			 | 
bendin | 
| 
				MIDI note on/off info
			 | 
borax | 
| 
				MIDI control values
			 | 
ctlin | 
| 
				the modification date of a file
			 | 
filedate | 
| 
				the monitor screen size
			 | 
screensize | 
| 
				the pixel value at display coordinates
			 | 
suckah | 
| 
				the square root of a number
			 | 
sqrt | 
 | 
float, forward, grab, int, message, receive, send, value
 | 
 | 
receive~, send~
 | 
 | 
pv, value
 | 
 | 
jit.glue | 
 | 
zplane~ | 
 | 
multislider, table
 | 
| 
				breakpoint function editor
			 | 
function | 
| 
				display of an audio buffer's contents
			 | 
waveform~ | 
| 
				filter editor
			 | 
filtergraph~ | 
| 
				score of MIDI note events
			 | 
detonate | 
 | 
see Draw | 
 | 
see Boolean operators | 
 | 
past | 
 | 
borax, flush, makenote, midiflush
 | 
 | 
ftom, mtof
 | 
 | 
number | 
 | 
decode | 
 | 
hint | 
 | 
histo | 
| 
				one or more numbers
			 | 
float, funbuff, int, number, offer, pv, table, value
 | 
| 
				note-off messages
			 | 
sustain | 
| 
				the smallest in a series of numbers
			 | 
trough | 
| 
				ReWire devices
			 | 
rewire~ | 
| 
				VST plug-ins
			 | 
vst~ | 
 | 
plugphasor~ | 
 | 
hi | 
 | 
see Arithmetic operators | 
 | 
allpass~, biquad~, comb~, lores~, reson~, svf~
 | 
 | 
jit.ameba | 
 | 
if | 
 | 
gate, ggate, gswitch, mousefilter, select, switch
 | 
 | 
jit.lumakey | 
 | 
seq | 
 | 
click~ | 
 | 
jit.pwindow | 
 | 
midiparse, xbendin, xnotein, bendin, ctlin, notein, pgmin, polyin, rtin, sysexin, touchin
 | 
 | 
incdec | 
 | 
listfunnel | 
 | 
funnel, prepend
 | 
 | 
funbuff, offer, table
 | 
 | 
if, led, number, togedge, toggle, ==, !=
 | 
 | 
button, led, ubutton
 | 
 | 
gestalt | 
 | 
loadbang, preset
 | 
| 
				for a patcher loaded by pfft~ (FFT)
			 | 
fftin~ | 
| 
				for a patcher loaded by pfft~
			 | 
in | 
| 
				for a patcher loaded by pfft~ (signal)
			 | 
in~ | 
| 
				for a subpatcher
			 | 
bpatcher, inlet, patcher
 | 
 | 
midiin | 
 | 
adc~, ezadc~
 | 
 | 
tapin~ | 
 | 
jit.charmap | 
 | 
funbuff, int, number, offer, pv, table, value
 | 
| 
				from ascii
			 | 
atoi | 
| 
				storage
			 | 
int | 
 | 
borax, clocker, date, timer
 | 
 | 
grab | 
 | 
line | 
 | 
ioscbank~ | 
| 
				raw MIDI data
			 | 
midiparse | 
| 
				numbers typed on keyboard
			 | 
numkey | 
 | 
jit.sprinkle | 
 | 
ifft~ | 
 | 
ubutton | 
 | 
*~, -~
 | 
 | 
ubutton | 
| 
				close
			 | 
thispatcher | 
| 
				load
			 | 
pcontrol | 
 | 
see Boolean operators | 
 | 
cycle, iter, message, spray, unpack
 | 
 | 
jit.iter | 
| 
				in JItter
			 | 
mxj | 
| 
				in Max
			 | 
mxj | 
| 
				in MSP
			 | 
mxj~ | 
| 
				event execution in sequence
			 | 
jstrigger | 
| 
				in Max
			 | 
mxj | 
| 
				run a script
			 | 
js, jstrigger
 | 
| 
				user interface for OpenGL
			 | 
jsui | 
| 
				numbers and symbols into a list
			 | 
pack, pak
 | 
| 
				numbers that arrive closely into a list
			 | 
thresh | 
 | 
kslider | 
 | 
key, keyup, numkey
 | 
 | 
key | 
 | 
jit.chromakey | 
 | 
keyup | 
 | 
pictctrl | 
 | 
comment, umenu
 | 
 | 
serial, vdp
 | 
 | 
bucket | 
 | 
jit.obref | 
 | 
see Boolean operators | 
 | 
expr, minimum, number, trough, <, <=
 | 
| 
				control
			 | 
*~, /~, gain~, normalize~
 | 
| 
				indicator
			 | 
levelmeter~ | 
| 
				metering
			 | 
meter~, number~
 | 
| 
				changes in signal amplitude
			 | 
deltaclip~ | 
| 
				matrix data to the range [min,max]
			 | 
jit.clip | 
| 
				numbers to a certain range
			 | 
clip | 
| 
				particles to a region of space
			 | 
jit.p.bounds | 
| 
				the rates at which messages are sent
			 | 
speedlim | 
| 
				signal amplitude
			 | 
clip~ | 
 | 
clip~, lookup~
 | 
 | 
jit.linden | 
| 
				determinant of a matrix
			 | 
jit.la.determinant | 
| 
				inversion of a matrix
			 | 
jit.la.inverse | 
| 
				product across the diagonal
			 | 
jit.la.diagproduct | 
| 
				make a triangular matrix
			 | 
jit.la.uppertri | 
| 
				sum across the diagonal
			 | 
jit.la.trace | 
| 
				true matrix multiplications
			 | 
jit.la.mult | 
| 
				for numbers
			 | 
line | 
| 
				for signals
			 | 
line~ | 
 | 
zigzag~ | 
| 
				all-purpose list processing
			 | 
zl | 
| 
				break up items in a list into individual messages
			 | 
cycle, iter, message, spray, unpack
 | 
| 
				combine separate items into a list
			 | 
append, pack, prepend, thresh
 | 
| 
				detect a specific ordered set within a list of numbers
			 | 
match | 
| 
				evaluate a mathematical expression multiple times using lists of numbers as input
			 | 
vexpr | 
| 
				graphically display and send out a list of number values
			 | 
multislider | 
| 
				list the files in a specific folder
			 | 
folder | 
| 
				files in a folder
			 | 
folder | 
| 
				list indexed messages in a pop-up menu
			 | 
umenu | 
| 
				system fonts
			 | 
fontlist | 
 | 
coll, umenu
 | 
 | 
pcontrol | 
| 
				for any message, known only to a single patcher and its subpatches
			 | 
pv | 
| 
				for storing a number value
			 | 
float, number, pv
 | 
| 
				logarithmic curve function
			 | 
curve~, gain~, linedrive, log~, pow~, sqrt~, techno~
 | 
| 
				of a signal
			 | 
log~ | 
| 
				solve for the logarithm of a number
			 | 
expr | 
| 
				and
			 | 
&&, expr
 | 
 | 
<~, ==~, >~, edge~
 | 
| 
				for a series of numbers, output as list
			 | 
match | 
 | 
buffer~, cycle~, function, index~, lookup~, peek~, wave~
 | 
 | 
info~ | 
 | 
2d.wave~, groove~, info~, wave~
 | 
 | 
counter | 
 | 
counter, metro, uzi
 | 
 | 
lores~, noise~, pink~, rand~, svf~
 | 
| 
				an array of arbitrary messages
			 | 
coll, umenu
 | 
| 
				a mathematical expression
			 | 
expr | 
| 
				a weighted series of numbers
			 | 
prob | 
| 
				a checkbox user interface
			 | 
radiogroup | 
| 
				a custom menu bar
			 | 
menubar | 
| 
				a histogram of received number pairs
			 | 
anal | 
| 
				a histogram of received numbers
			 | 
histo | 
| 
				Max window errors into messages
			 | 
error | 
| 
				MIDI noteoff messages for held notes
			 | 
flush | 
| 
				MIDI notes with off messages
			 | 
makenote | 
| 
				a multiplane matrix out of single plane matrices
			 | 
jit.pack | 
| 
				multiple single plane matrices out of a multiplane matrix
			 | 
jit.unpack | 
| 
				a patcher standalone
			 | 
standalone | 
| 
				a playbar for a QuickTime movie
			 | 
playbar | 
| 
				a popup text hint
			 | 
hint | 
| 
				a subpatch within a patch
			 | 
patcher | 
 | 
jit.shade | 
| 
				an input range of matrix values to an output range
			 | 
jit.map | 
| 
				an input range of numbers to an output range
			 | 
scale, zmap
 | 
 | 
funnel | 
 | 
prob | 
 | 
expr, &, |
 | 
| 
				the first item in a message, route the message accordingly
			 | 
route | 
| 
				an incoming message to arguments, send a bang out a specific outlet if there is a match
			 | 
select | 
| 
				incoming messages and bang if detected
			 | 
select | 
| 
				and route incoming message
			 | 
route | 
 | 
expr, +, -, *, /, %
 | 
| 
				get information about a matrix
			 | 
jit.matrixinfo | 
| 
				storage bin for matrices
			 | 
jit.matrixset | 
| 
				matrix header munging
			 | 
jit.coerce | 
| 
				remap matrix dimensions
			 | 
jit.dimmap | 
| 
				remove redundant dimensions
			 | 
jit.thin | 
| 
				reference a subregion of a matrix
			 | 
jit.submatrix | 
| 
				store a matrix
			 | 
jit.matrix | 
 | 
matrixctrl | 
 | 
router | 
| 
				converted to signals
			 | 
curve~, line~, peek~, poke~, sig~
 | 
| 
				derived from signals
			 | 
avg~, edge~, meter~, number~, peek~, snapshot~
 | 
 | 
filepath | 
 | 
rslider, split
 | 
| 
				find the greater of two numbers
			 | 
expr, maximum, number, peak, >, >=
 | 
| 
				find the maximum value of a group of numbers
			 | 
maximum, table
 | 
| 
				time in cpu cycles
			 | 
cpuclock | 
| 
				elapsed time between two bangs
			 | 
timer | 
 | 
menubar | 
 | 
umenu | 
| 
				input for a patcher loaded by poly~ or pfft~
			 | 
in | 
| 
				input for a subpatcher
			 | 
inlet | 
| 
				output for a patcher loaded by poly~ or pfft~
			 | 
out | 
| 
				output for a subpatcher
			 | 
outlet | 
 | 
substitute | 
| 
				construct
			 | 
append, message, pack, prepend
 | 
| 
				construct MIDI messages for transmission or recording
			 | 
midiformat, sxformat
 | 
| 
				send and display
			 | 
umenu, message
 | 
| 
				send remotely without patch cords
			 | 
float, forward, grab, int, message, pv, receive, send, value
 | 
| 
				send with the menu bar
			 | 
menubar | 
| 
				type in and send in a locked patcher
			 | 
dialog, message
 | 
 | 
jit.eclipse | 
 | 
clocker, metro, setclock, tempo
 | 
| 
				construct MIDI messages
			 | 
midiformat, sxformat, midiout
 | 
| 
				control from MSP
			 | 
avg~, ftom, function, number~, snapshot~
 | 
| 
				control of MSP
			 | 
curve~, line~, mtof, sig~
 | 
| 
				data, receive unaltered
			 | 
midiin | 
| 
				data, transmit byte by byte
			 | 
midiout | 
| 
				display numbers as MIDI note names
			 | 
number | 
| 
				enable or disable MIDI objects in a patcher automatically
			 | 
pcontrol | 
| 
				generate MIDI notes from frequency
			 | 
ftom | 
| 
				get a list of currently available devices and ports
			 | 
midiinfo | 
| 
				make noteoff messages for held notes
			 | 
flush | 
| 
				interpret raw MIDI data
			 | 
midiparse | 
| 
				parse MIDI messages
			 | 
midiparse, xbendin, xnotein
 | 
| 
				prepare data in MIDI format
			 | 
midiformat | 
| 
				generate MIDI control change messages
			 | 
ctlin, ctlout
 | 
| 
				Generate MIDI notes with off messages
			 | 
makenote | 
| 
				Generate note-offs for hanging note-ons
			 | 
midiflush | 
| 
				Generate data in MIDI format
			 | 
midiformat | 
| 
				real-time MIDI system messages
			 | 
midiin, midiout, rtin
 | 
| 
				Receive afterpressure, polyphonic
			 | 
polyin | 
| 
				Receive incoming pitchbend data
			 | 
bendin, midiin, xbendin, xbendin2
 | 
| 
				Delay note off messages
			 | 
sustain | 
| 
				Export MIDI file
			 | 
seq | 
| 
				Prepare MIDI sysex messages
			 | 
sxformat | 
| 
				Receive aftertouch values
			 | 
touchin | 
| 
				receive and transmit sample dump
			 | 
midiin, midiout, sysexin
 | 
 | 
mstosamps~, sampstoms~
 | 
 | 
rslider, split
 | 
 | 
expr, minimum, number, trough, <, <=
 | 
 | 
minimum, table
 | 
 | 
expr, -
 | 
 | 
*~, matrix~
 | 
 | 
jit.xfade, see Video mixing and compositing
 | 
 | 
serial | 
 | 
filedate | 
| 
      	apply a nonlinear transfer function to a signal
       | 
overdrive~ | 
| 
      	arithmetic operations
       | 
see Arithmetic operators | 
| 
      	constrain a signal between two values
       | 
clip~ | 
| 
      	create differences between successive samples
       | 
delta~ | 
| 
      	degrade the signal
       | 
degrade~ | 
| 
      	downsample a signal
       | 
downsamp~ | 
| 
      	fold or wrap a signal within a given range
       | 
pong~ | 
| 
      	limit the change between samples in signal
       | 
deltaclip~ | 
| 
      	round signal to nearest integer value
       | 
round~ | 
| 
      	scale a signal based on its maximum amplitude
       | 
normalize~ | 
| 
      	smooth out an incoming signal via a ramp
       | 
rampsmooth~ | 
| 
      	shift frequency in the time-domain
       | 
freqshift~ | 
| 
      	time-scale the output of a phasor~
       | 
rate~ | 
| 
      	truncate fractional part of signal values
       | 
trunc~ | 
 | 
ctlin, ctlout
 | 
 | 
expr, %
 | 
 | 
screensize | 
 | 
touchin, touchout
 | 
| 
      	detect mouse events
       | 
imovie, lcd, mousefilter, mousestate
 | 
| 
      	generate numbers with the mouse
       | 
dial, imovie, kslider, lcd, mousestate, multislider, number, rslider, slider, table
 | 
| 
      	pass numbers through only when the mouse button is up
       | 
mousefilter | 
| 
      	report mouse location
       | 
imovie, lcd, mousestate
 | 
| 
      	report status of mouse button
       | 
mousestate | 
 | 
imovie, movie, playbar
 | 
 | 
lcd, imovie, movie, vdp
 | 
 | 
average~ | 
 | 
zl | 
 | 
bline | 
 | 
mtr | 
 | 
jit.multiplex | 
| 
      	and add a set of values in a matrix
       | 
jit.scalebias | 
| 
      	and/or add a series of numbers
       | 
accum, expr, table
 | 
| 
      	the planar vector by a matrix
       | 
jit.traffic | 
| 
      	two numbers
       | 
accum, expr, *
 | 
| 
      	two matrices
       | 
jit.op | 
| 
      	two signals
       | 
*~ | 
 | 
comment, umenu
 | 
 | 
abs, expr
 | 
 | 
jit.fluoride | 
 | 
&, /, |, <<, >>
 | 
 | 
gate~ | 
| 
      	audio noise generator
       | 
noise~, pink~, rand~
 | 
| 
      	filtered noise generator (numbers)
       | 
drunk | 
| 
      	white noise generator (matrices)
       | 
jit.noise, random
 | 
| 
      	white noise generator (numbers)
       | 
expr, random
 | 
 | 
oscbank~ | 
| 
      	notify when input changes from zero/non-zero
       | 
change, togedge
 | 
| 
      	test if a number or expression is a non-zero value
       | 
change, if, led, select, split, togedge, toggle, ==, !=, &&, ||
 | 
| 
      	a signal
       | 
*~, /~, normalize~
 | 
| 
      	a matrix
       | 
jit.normalize | 
 | 
see Boolean operators | 
| 
      	bitwise ones complement operation
       | 
expr | 
| 
      	convert a non-zero number to 0 and vice versa
       | 
expr, ==
 | 
| 
      	duration, delta time, etc. derived from MIDI note messages
       | 
borax | 
| 
      	receive incoming MIDI data
       | 
midiin, notein, xnotein
 | 
| 
      	transmit MIDI data
       | 
midiout, noteout, xnoteout
 | 
 | 
comment, hint
 | 
| 
      	detect and format note-off messages messages with release velocity
       | 
xnotein, xnoteout
 | 
| 
      	hold note-off messages until a specific event occurs
       | 
sustain | 
| 
      	supply note-off messages for held or stuck MIDI note-ons
       | 
bag, borax, flush, makenote, midiflush
 | 
| 
      	surpress note-off messages
       | 
gate, stripnote
 | 
 | 
filewatch | 
 | 
active | 
 | 
button, led, message, print, ubutton
 | 
| 
      	automatically generate number sequences
       | 
counter, line, clocker, tempo
 | 
| 
      	convert numbers between decimal, hexadecimal, and binary
       | 
number | 
| 
      	examine selected bits of a number’s binary representation (nybble)
       | 
&, |, <<, >>
 | 
| 
      	generate numbers with the mouse
       | 
dial, imovie, kslider, lcd, mousestate, multislider, number, rslider, slider, table
 | 
| 
      	sample a signal and display a number value
       | 
capture~, number~, snapshot~
 | 
| 
      	store numbers
       | 
float, funbuff, int, number, offer, pv, table, value
 | 
 | 
ctlin, ctlout
 | 
 | 
bpatcher, patcher
 | 
| 
      	keep track of how many bang messages have occurred
       | 
counter | 
| 
      	keep track of how many times a number has occurred
       | 
histo | 
 | 
number | 
| 
      	4-band compressor
       | 
omx.4band~ | 
| 
      	5-band compressor
       | 
omx.5band~ | 
| 
      	compressor
       | 
omx.comp~ | 
| 
      	peak limiter
       | 
omx.peaklim~ | 
| 
      	in a patch
       | 
decode, toggle
 | 
| 
      	for audio
       | 
adc~, dac~, dspstate~, ezadc~, ezdac~
 | 
 | 
jit.change | 
| 
      	bitmap text for OpenGL
       | 
jit.gl.text2d | 
| 
      	floating-point data visualization
       | 
jit.gl.graph | 
| 
      	lcd object analog for OpenGL
       | 
jit.gl.sketch | 
| 
      	mouse control of position and rotation
       | 
jit.gl.handle | 
| 
      	nurbs surface object
       | 
jit.gl.nurbs | 
| 
      	OpenGL rendering object
       | 
jit.gl.render | 
| 
      	Platonic solids
       | 
jit.gl.plato | 
| 
      	read and render OBJ models
       | 
jit.gl.model | 
| 
      	simple mesh shapes
       | 
jit.gl.gridshape | 
| 
      	user interface for javascript
       | 
jsui | 
| 
      	vector text for OpenGL
       | 
jit.gl.text3d | 
| 
				a binary file
			 | 
filein | 
| 
				a dialog box for text entry
			 | 
dialog | 
| 
				a dialog to ask for a file or folder
			 | 
opendialog | 
| 
				a dialog to ask for a filename for saving
			 | 
savedialog | 
| 
				patcher files automatically
			 | 
folder, pcontrol
 | 
 | 
gestalt | 
 | 
jit.fastblur | 
 | 
expr | 
 | 
expr, ||
 | 
| 
				detect an ordered set of numbers
			 | 
match | 
| 
				reorder number messages
			 | 
fswap, message, swap
 | 
| 
				send a number, bang, list, or symbol to different places in a specific order
			 | 
trigger | 
| 
				antialiased oscillator
			 | 
rect~, saw~, tri~
 | 
| 
				buffer-based wavetable oscillator
			 | 
2d.wave~, wave~
 | 
| 
				cosine function for use with 0.-1.0 phasor~ output
			 | 
cos~ | 
| 
				multichannel sample buffer
			 | 
buffer~ | 
| 
				oscillator bank
			 | 
ioscbank~, oscbank~
 | 
| 
				sawtooth ramp generator
			 | 
phasor~ | 
| 
				sine wave table-lookup oscillator or function generator
			 | 
cycle~ | 
| 
				trapezoidal wavetable
			 | 
trapezoid~ | 
| 
				triangle/ramp wavetable
			 | 
triangle~ | 
 | 
scope~ | 
| 
				from a delay line
			 | 
tapout~ | 
| 
				for a patcher loaded by pfft~
			 | 
fftout~ | 
| 
				for a patcher loaded by poly~ (message)
			 | 
out | 
| 
				for a patcher loaded by poly~ (signal)
			 | 
out~ | 
| 
				for a subpatch object
			 | 
bpatcher, outlet, patcher
 | 
 | 
spray, unpack
 | 
 | 
midiout | 
 | 
pak | 
 | 
dac~, ezdac~
 | 
| 
				from a specific inlet
			 | 
switch | 
| 
				by using a screen slider
			 | 
slider | 
| 
				in a ramp from one value to another
			 | 
line | 
| 
				the smallest number in a list
			 | 
minimum | 
| 
				the largest number in a list
			 | 
maximum | 
| 
				peak numbers
			 | 
peak | 
| 
				from a notation display on screen
			 | 
nslider | 
| 
				any number
			 | 
number | 
| 
				at a metronomic tempo
			 | 
tempo | 
 | 
screensize | 
| 
				to DirectX FireWire output (Windows only)
			 | 
jit.dx.videoout | 
| 
				to QuickTime video output component
			 | 
jit.qt.videoout | 
 | 
pack, pak
 | 
 | 
panel | 
 | 
borax, ctlout, flush, makenote, midiflush
 | 
 | 
ctlin, ctlout
 | 
 | 
ctlout, midiout, sxformat
 | 
 | 
midiparse, xbendin, xnotein, bendin, ctlin, notein, pgmin, polyin, rtin, sysexin, touchin
 | 
| 
				a number from outlet to outlet
			 | 
bucket | 
| 
				numbers only when mouse button is up
			 | 
mousefilter | 
 | 
pgmin, pgmout
 | 
 | 
inlet, outlet
 | 
 | 
pattr | 
 | 
bpatcher | 
 | 
omx.peaklim~ | 
 | 
meter~ | 
 | 
peak | 
 | 
grab | 
 | 
jit.gl.slab | 
 | 
urn | 
 | 
kink~, phasor~
 | 
 | 
hilbert~ | 
 | 
phaseshift~ | 
 | 
colorpicker | 
| 
				controller
			 | 
pictctrl | 
| 
				display a graphics file in a patcher window
			 | 
fpic | 
| 
				slider
			 | 
pictslider | 
 | 
pink~ | 
| 
				receive MIDI pitchbend messages
			 | 
bendin, midiin, xbendin, xbendin2
 | 
| 
				transmit MIDI pitchbend messages
			 | 
bendout, midiout, xbendout, xbendout2
 | 
 | 
gizmo~ | 
 | 
mtof | 
 | 
bendin, midiin, xbendin, xbendin2
 | 
 | 
bendout, midiout, xbendout, xbendout2
 | 
 | 
jit.qt.movie, imovie, movie, playbar
 | 
 | 
dac~, ezdac~
 | 
| 
				from a buffer
			 | 
play~, 2d.wave~, groove~
 | 
| 
				from disc
			 | 
sfplay~ | 
 | 
jit.qt.movie | 
 | 
follow, mtr, seq
 | 
 | 
2d.wave~, buffer~, groove~, index~, play~, sfplay~, techno~, wave~
 | 
 | 
vst~ | 
 | 
counter, funbuff, offer, table
 | 
| 
				for numbers
			 | 
poltocar | 
| 
				for signals
			 | 
poltocar~ | 
 | 
borax, poly
 | 
 | 
polyin | 
| 
				control voice allocation and muting
			 | 
thispoly~ | 
| 
				input in a patcher loaded by poly~
			 | 
in | 
| 
				signal input in a patcher loaded by poly~
			 | 
in~ | 
| 
				output in a patcher loaded by poly~
			 | 
out | 
| 
				signal output in a patcher loaded by poly~
			 | 
out~ | 
| 
				polyphony and DSP manager for patchers
			 | 
poly~ | 
 | 
umenu | 
 | 
hint | 
 | 
bendin, bendout, ctlin, ctlout
 | 
 | 
midiinfo | 
 | 
play~ | 
 | 
abs, expr
 | 
| 
				a bang
			 | 
delay | 
| 
				a number or list
			 | 
pipe, thresh
 | 
| 
				note-off messages until a specific event occurs
			 | 
sustain | 
 | 
dial | 
 | 
expr | 
 | 
cpuclock | 
| 
				data in MIDI format
			 | 
midiformat | 
| 
				MIDI sysex messages
			 | 
sxformat | 
 | 
append, prepend
 | 
 | 
pattrstorage, preset
 | 
 | 
onecopy | 
 | 
jit.print | 
 | 
print | 
 | 
drunk, prob, random, table, urn
 | 
 | 
jit.streak | 
 | 
histo | 
 | 
accum, expr, *
 | 
 | 
pgmin, pgmout
 | 
 | 
slider | 
 | 
train~ | 
 | 
<~, >~, clip~, train~
 | 
 | 
bpatcher | 
| 
				message control
			 | 
qlim | 
| 
				message passing control
			 | 
qlim | 
| 
				metronome
			 | 
qmetro | 
 | 
lcd | 
| 
				QuickDraw wrapper for matrices
			 | 
jit.lcd | 
| 
				effects for Jitter matrices
			 | 
jit.qt.effect | 
| 
				playback
			 | 
jit.qt.movie | 
| 
				Quicktime effects wrapper
			 | 
jit.qt.effect | 
| 
				record to a QuickTime movie file
			 | 
jit.qt.record | 
| 
				route QuickTime audio to MSP
			 | 
spigot~ | 
| 
				send to a video output device
			 | 
jit.qt.videoout | 
| 
				video input (DirectX, Windows only)
			 | 
jit.dx.grab | 
| 
				video input
			 | 
jit.qt.grab | 
 | 
imovie, movie, playbar
 | 
 | 
swatch | 
 | 
radiogroup | 
 | 
line | 
 | 
curve~, line~
 | 
 | 
drunk | 
| 
				generate pseudo-random numbers
			 | 
decide, drunk, expr, random, urn
 | 
| 
				generate a zero or one
			 | 
decide | 
| 
				generate numbers
			 | 
random | 
| 
				generate signal values
			 | 
noise~, pink~, rand~
 | 
| 
				generate single instances of number
			 | 
urn | 
| 
				generate numbers in a moving range
			 | 
drunk | 
 | 
rslider, split
 | 
 | 
speedlim | 
 | 
thresh | 
 | 
setclock | 
 | 
tempo | 
 | 
midiin, midiout, sysexin
 | 
 | 
filein | 
 | 
rewire~ | 
 | 
filein | 
 | 
jit.gl.model | 
 | 
jit.textfile | 
 | 
jit.fprint | 
 | 
peek~ | 
 | 
filein | 
 | 
jit.peek~ | 
 | 
jit.openexr | 
 | 
cpuclock | 
 | 
follow, mtr, seq
 | 
| 
				aftertouch messages
			 | 
touchin | 
| 
				control values
			 | 
ctlin | 
| 
				pitch bend values
			 | 
bendin | 
| 
				raw data
			 | 
midiin | 
| 
				note messages
			 | 
notein | 
| 
				program change values
			 | 
pgmin | 
| 
				polyphonic afterpressure messages
			 | 
polyin | 
| 
				pitchbend data
			 | 
bendin, xbendin, xbendin2
 | 
| 
				report length of MIDI notes
			 | 
borax | 
| 
				realtime MIDI system messages
			 | 
midiin, rtin
 | 
| 
				sysex messages
			 | 
sysexin | 
 | 
receive | 
 | 
jit.net.recv | 
| 
				without a patch cord
			 | 
receive | 
| 
				from outside a patcher
			 | 
inlet | 
| 
				over a UDP network
			 | 
udpreceive | 
 | 
bendin, ctlin, notein, pgmin, polyin, rtin, sysexin, touchin
 | 
 | 
bucket | 
| 
				an audio file to disk
			 | 
sfrecord~ | 
| 
				audio into a buffer
			 | 
record~ | 
| 
				a QuickTime movie
			 | 
jit.qt.record | 
| 
				a QuickTime movie with MSP audio
			 | 
jit.vcr | 
| 
				sequences of MIDI data or numbers
			 | 
follow, mtr, seq
 | 
| 
				audio samples
			 | 
adc~, ezadc~, poke~, record~, sfrecord~
 | 
 | 
gate, ggate, grab, route, split, spray, unpack
 | 
 | 
jit.submatrix | 
 | 
xnotein, xnoteout
 | 
| 
				for numbers
			 | 
expr, %
 | 
| 
				for signals
			 | 
%~ | 
 | 
jit.dimmap | 
 | 
float, forward, grab, int, message, pv, receive, send, value
 | 
 | 
jit.thin | 
 | 
jit.gl.render, jit.gl.imageunit
 | 
 | 
jit.rubix | 
 | 
uzi | 
 | 
clocker, metro, tempo
 | 
 | 
cycle~, phasor~, techno~, train~
 | 
 | 
counter | 
 | 
change | 
 | 
bitsafe~ | 
| 
				audio driver settings
			 | 
adstatus | 
| 
				audio file information
			 | 
sfinfo~ | 
| 
				current DSP settings
			 | 
dspstate~ | 
| 
				current info on file search path
			 | 
filepath | 
| 
				current note on/off info
			 | 
borax | 
| 
				the current time/date
			 | 
date | 
| 
				the elapsed time
			 | 
clocker | 
| 
				the elapsed time between two events
			 | 
timer | 
| 
				host synchronization information
			 | 
plugsync~ | 
| 
				information about a patcher loaded by pfft~
			 | 
fftinfo~ | 
| 
				information about a sample
			 | 
info~ | 
| 
				intervals of zero to non-zero transitions
			 | 
spike~ | 
| 
				keyboard key presses
			 | 
key | 
| 
				keyboard key releases
			 | 
keyup | 
| 
				length of MIDI notes
			 | 
borax | 
| 
				the maximum amplitude of a signal
			 | 
peakamp~ | 
| 
				milliseconds of audio processed
			 | 
dsptime~ | 
| 
				the min/mean/max values of a matrix
			 | 
jit.3m | 
| 
				the modification date of a file
			 | 
filedate | 
| 
				modifier key presses on keyboard
			 | 
modifiers | 
| 
				signal direction
			 | 
change~ | 
| 
				suspension or resumption of application
			 | 
suspend | 
| 
				state of the mouse
			 | 
mousestate | 
| 
				search path information
			 | 
filepath | 
| 
				the type, planecount, and dimensions of a matrix
			 | 
jit.matrixinfo | 
| 
				when an application is suspended and resumed
			 | 
suspend | 
| 
				when input exceeds a certain number
			 | 
past | 
| 
				zero/non-zero transitions
			 | 
togedge | 
 | 
jit.repos | 
 | 
bangbang, trigger
 | 
 | 
jit.scanwrap | 
 | 
jit.resamp | 
 | 
see Filters | 
 | 
clip | 
 | 
allpass~, comb~, tapin~, tapout~
 | 
 | 
jit.reverse | 
 | 
fswap, message, swap
 | 
| 
				get synchronization signal from a ReWire host
			 | 
hostphasor~ | 
| 
				get transport control info from a ReWire host
			 | 
hostsync~ | 
| 
				the order of two floating-point numbers
			 | 
fswap | 
| 
				the sequential order of two integers
			 | 
swap | 
 | 
groove~, play~
 | 
 | 
*~ | 
 | 
setclock | 
 | 
jit.robcross | 
 | 
bucket, cycle
 | 
 | 
jit.hue | 
| 
				a number from outlet to outlet
			 | 
bucket | 
| 
				a stream of data to individual outlets
			 | 
cycle | 
 | 
jit.gl.videoplane, jit.mxform2d, jit.rota
 | 
 | 
round~ | 
| 
				incoming message to specific outlet
			 | 
route | 
| 
				matrix-compatible messages
			 | 
router | 
| 
				messages to a specific destination
			 | 
gate, ggate, route, split, spray, unpack
 | 
| 
				QuickTime audio into MSP
			 | 
spigot~ | 
| 
				a signal to one of several outlets
			 | 
gate~ | 
| 
      define the beginning of a signal processing network
       | 
begin~ | 
| 
				receive a signal from one or more send~ objects
       | 
receive~ | 
| 
      	send a signal without a patch cord
       | 
send~ | 
| 
      	signal switching/mixing matrix
       | 
matrix~ | 
| 
				switch input to different output signals
       | 
gate~ | 
| 
      	switch output among several input signals
       | 
selector~ | 
 | 
js, jstrigger
 | 
 | 
setclock | 
 | 
sah~ | 
 | 
count~, index~
 | 
 | 
index~ | 
 | 
2d.wave~, buffer~, groove~, index~, play~, sfplay~, techno~, wave~
 | 
 | 
midiin, midiout, sysexin
 | 
| 
				2d phase-driven oscillator
			 | 
2d.wave~ | 
| 
				copy a signal into a buffer
			 | 
record~ | 
| 
				grab and play a snippet of recent audio input
			 | 
stutter~ | 
| 
				index-based sample reading
			 | 
index~ | 
| 
				loop and sample pitch information from a buffer
			 | 
info~ | 
| 
				multichannel sample buffer
			 | 
buffer~ | 
| 
				phase-driven oscillator using a buffer as a wavetable
			 | 
wave~ | 
| 
				read and write buffer values
			 | 
peek~ | 
| 
				sample playback based on position in a buffer
			 | 
play~ | 
| 
				use a buffer for nonlinear distortion of a signal
			 | 
lookup~ | 
| 
				variable-rate looping sample playback
			 | 
groove~ | 
| 
				write into a buffer using signal sample indices
			 | 
poke~ | 
 | 
adc~, buffer~, count~, dac~, dspstate~, mstosamps~, sampstoms~
 | 
 | 
thispatcher | 
| 
				and recall presets of pattr data
			 | 
pattrstorage | 
| 
				MIDI file
			 | 
seq | 
| 
				dialog for files
			 | 
savedialog | 
 | 
phasor~ | 
 | 
phasor~ | 
 | 
normalize~ | 
 | 
jit.rota | 
| 
				numbers sequentially
			 | 
linedrive | 
| 
				an input range to an output range
			 | 
scale | 
 | 
pipe, thresh
 | 
 | 
delay | 
 | 
follow | 
 | 
screensize | 
 | 
umenu | 
 | 
filepath | 
 | 
peakamp~ | 
| 
				a colour using a dialog box
			 | 
colorpicker | 
| 
				background colour
			 | 
bgcolor | 
| 
				serial data over port
			 | 
serial | 
| 
				a specific input, pass the rest on
			 | 
select | 
 | 
route | 
| 
				a plain old bang
			 | 
button, ubutton
 | 
| 
				on loading of patch
			 | 
loadbang | 
| 
				on close of patch
			 | 
closebang | 
| 
				to numerous outlets
			 | 
bangbang | 
| 
				at regular intervals
			 | 
metro | 
| 
				to all loadbang objects
			 | 
thispatcher | 
| 
				to multiple places
			 | 
bangbang, trigger
 | 
| 
				to many places, in order
			 | 
trigger | 
| 
				a particular number of bangs
			 | 
uzi | 
 | 
jit.net.send | 
| 
				to all instances of the same class in a patcher
			 | 
universal | 
| 
				any old message
			 | 
message | 
| 
				to receive objects in any other window
			 | 
float, forward, grab, int, message, send
 | 
| 
				to various receive objects
			 | 
forward | 
| 
				on patch loading
			 | 
loadmess | 
| 
				out of a patcher
			 | 
outlet | 
| 
				to a named object in patcher hierarchy
			 | 
pattrforward | 
| 
				a collection of messages remotely as cues
			 | 
qlist | 
| 
				without patch cords
			 | 
send, s
 | 
| 
				to a patcher
			 | 
thispatcher | 
| 
				note messages
			 | 
noteout | 
| 
				note-offs for hanging note-ons
			 | 
midiflush | 
| 
				pitch bend
			 | 
bendout, midiout, xbendout, xbendout2
 | 
| 
				control values
			 | 
ctlout | 
| 
				raw MIDI data
			 | 
midiout | 
| 
				program change values
			 | 
pgmout | 
| 
				afterpressure, polyphonic
			 | 
polyout | 
| 
				aftertouch
			 | 
touchout | 
| 
				sequentially, as quickly as possible
			 | 
uzi | 
| 
				according to a count
			 | 
counter | 
| 
				at a metronomic tempo
			 | 
tempo | 
| 
				a stream of data to individual outlets
			 | 
cycle | 
| 
				an input out a specific outlet
			 | 
gate | 
| 
				messages over a UDP connection
			 | 
udpsend | 
 | 
cycle, iter, spray, unpack
 | 
 | 
match | 
 | 
counter, line, clocker, tempo
 | 
 | 
follow, mtr, seq
 | 
 | 
serial, spell
 | 
 | 
cycle, iter, message, spray, unpack
 | 
 | 
thresh | 
 | 
bondo | 
 | 
bgcolor | 
 | 
loadbang, preset
 | 
 | 
jit.displays | 
 | 
urn | 
 | 
bag | 
| 
				background colour
			 | 
bgcolor | 
 | 
pv | 
 | 
<<, >>
 | 
 | 
bucket, cycle
 | 
| 
				a picture from a graphics file
			 | 
fpic | 
| 
				on/off status in colour
			 | 
led | 
| 
				compute signal min and max values
			 | 
minmax~ | 
| 
				detect signal change and direction
			 | 
change~ | 
| 
				detect when input goes above a set value
			 | 
thresh~ | 
| 
				detect zero to non-zero signal transitions
			 | 
edge~ | 
| 
				output the maximum of two signals
			 | 
maximum~ | 
| 
				output the minimum of two signals
			 | 
minimum~ | 
| 
				report intervals of zero to non-zero transitions
			 | 
spike~ | 
| 
				report sample values from a signal
			 | 
snapshot~ | 
| 
				report the peak amplitude of a signal
			 | 
peakamp~ | 
| 
				signal counter
			 | 
count~ | 
| 
				store a signal to view as text
			 | 
capture~ | 
| 
				sync MSP with MIDI, click, or tap tempo
			 | 
sync~ | 
| 
				zero-crossing counter/transient detector
			 | 
zerox~ | 
 | 
avg~ | 
 | 
stutter~ | 
 | 
pong~ | 
 | 
number~ | 
 | 
spectroscope~ | 
| 
				event sequencer
			 | 
seq~ | 
| 
				sequencer
			 | 
techno~ | 
| 
				step sequencer
			 | 
techno~ | 
 | 
filtercoeff~ | 
| 
				define the beginning of a signal processing network
			 | 
begin~ | 
| 
				receive a signal from one or more send~ objects
			 | 
receive~ | 
| 
				send a signal without a patch cord
			 | 
send~ | 
| 
				signal switching / mixing matrix
			 | 
matrix~ | 
| 
				switch input to different output signals
			 | 
gate~ | 
| 
				switch output among several input signals
			 | 
selector~ | 
 | 
uzi | 
 | 
						see Oscillators
					 | 
 | 
see Arithmetic operators | 
 | 
onepole~ | 
 | 
kslider, multislider, pictslider, rslider, slider
 | 
 | 
rampsmooth~ | 
 | 
preset | 
 | 
jit.sobel | 
 | 
overdrive~ | 
| 
				a mathematical expression
			 | 
expr, +, -, *, /, %
 | 
| 
				C language expression
			 | 
expr, if
 | 
 | 
spectroscope~ | 
 | 
midiin, midiout, sysexin
 | 
 | 
imovie, movie, playbar
 | 
 | 
funbuff, offer
 | 
 | 
jit.mxform2d | 
 | 
split | 
 | 
cartopol~, fftin~, fftinfo~, fftout~, frameaccum~, framedelta~, pfft~, phasewrap~, poltocar~, vectral~
 | 
 | 
pfft~ | 
 | 
spectroscope~ | 
 | 
fft~, ifft~, pfft~
 | 
 | 
thresh | 
 | 
speedlim | 
 | 
jit.split | 
 | 
cycle | 
 | 
lcd | 
| 
				of a number
			 | 
sqrt | 
| 
				of a signal
			 | 
sqrt~ | 
 | 
button, loadbang, ubutton
 | 
 | 
loadbang | 
 | 
2d.wave~, groove~, index~, play~, wave~
 | 
 | 
midiin, midiout, rtin
 | 
 | 
svf~ | 
 | 
poly | 
 | 
drunk, prob, random, table, urn
 | 
 | 
gate, ggate, gswitch, speedlim, switch
 | 
 | 
midiin, midiout, rtin
 | 
| 
				an array of arbitrary messages
			 | 
coll, umenu
 | 
| 
				audio file cues
			 | 
sflist~ | 
| 
				audio samples
			 | 
buffer~ | 
| 
				a collection of numbers
			 | 
bag | 
| 
				and edit a collection of messsages
			 | 
bag | 
| 
				a fixed-size set of integers and output all whenever one element is modified
			 | 
bondo | 
| 
				a graphically editable array of numbers
			 | 
table | 
| 
				one or more integers or floating-point numbers
			 | 
float, funbuff, int, number, offer, pv, table, value
 | 
| 
				an integer or floating-point number, add and multiply it
			 | 
accum | 
| 
				a fixed-size set of integers and output all whenever one element is modified
			 | 
bondo | 
| 
				store/recall matrices
			 | 
jit.matrix, jit.matrixset
 | 
| 
				numbers to view or edit
			 | 
capture | 
| 
				pairs of numbers together
			 | 
funbuff | 
| 
				pairs of numbers (store, recall, automatically delete)
			 | 
offer | 
| 
				store/recall preset values of all UI objects
			 | 
pattrstorage, preset
 | 
| 
				store/recall recently received values
			 | 
bucket, table, text
 | 
| 
				a signal to view as text
			 | 
capture~ | 
| 
				a series of numbers in order in an editable window
			 | 
capture, table, text
 | 
| 
				an unordered set of numbers
			 | 
bag | 
| 
				and view 2D data
			 | 
jit.cellblock | 
 | 
sprintf | 
| 
				fill a matrix with a list
			 | 
jit.fill | 
| 
				L-systems string expansion
			 | 
jit.linden | 
| 
				matrix-symbol conversion
			 | 
jit.str.tosymbol | 
| 
				perform string ops (strcat, etc.)
			 | 
jit.str.op | 
| 
				symbol-matrix conversion
			 | 
jit.str.fromsymbol | 
| 
				unroll a matrix to a list
			 | 
jit.spill | 
 | 
borax, flush, makenote, midiflush
 | 
 | 
mute~, receive~, send~
 | 
 | 
bpatcher | 
 | 
bpatcher, patcher
 | 
 | 
inlet, outlet
 | 
 | 
substitute | 
| 
				message symbol
			 | 
substitute | 
| 
				two matrices
			 | 
jit.op, jit.expr
 | 
| 
				two numbers
			 | 
-, expr
 | 
| 
				two numbers (inlets reversed)
			 | 
!- | 
| 
				two signals
			 | 
-~ | 
| 
				two signals (inlets reversed)
			 | 
!-~ | 
 | 
allpass~, biquad~, comb~, lores~, noise~, pink~, rand~, rect~, reson~, saw~, tri~
 | 
 | 
+, accum, expr, table
 | 
 | 
stripnote | 
 | 
gate, ggate, gswitch, mousefilter, select, switch
 | 
 | 
sustain | 
 | 
ctlin, ctlout, sustain
 | 
| 
				the order of two floating-point numbers
			 | 
fswap | 
| 
				the sequential order of two integers
			 | 
swap | 
 | 
led, togedge, toggle, ubutton
 | 
 | 
toggle | 
 | 
matrixctrl | 
 | 
gate, ggate, gswitch, switch, toggle
 | 
 | 
gate~, mute~, pass~, selector~
 | 
 | 
fromsymbol | 
 | 
sync~ | 
 | 
setclock | 
 | 
buddy | 
| 
				a group of messages
			 | 
bondo | 
| 
				arriving data, and output together
			 | 
buddy | 
 | 
midiin, midiout, rtin
 | 
 | 
midiout, sxformat
 | 
 | 
midiin, sysexin
 | 
 | 
buffer~, cycle~, function, index~, lookup~, peek~, wave~
 | 
 | 
funnel | 
 | 
borax, funnel, poly
 | 
 | 
see Arithmetic operators | 
 | 
setclock | 
 | 
tempo | 
 | 
change, if, match, select, ==, !=
 | 
 | 
change, if, led, match, select, split, togedge, toggle, ==, !=, &&, ||
 | 
 | 
maximum, number, peak, >, >=
 | 
 | 
minimum, number, trough, <, <=
 | 
 | 
capture~ | 
 | 
seq | 
 | 
text | 
 | 
dialog, message
 | 
 | 
spell | 
 | 
dialog, lcd, umenu, message, pcontrol, sprintf
 | 
 | 
comment, fpic, message
 | 
 | 
sprintf | 
 | 
print | 
 | 
jit.matrix | 
 | 
cross~ | 
 | 
past | 
 | 
pgmout | 
 | 
setclock | 
 | 
clocker, date, timer
 | 
 | 
cpuclock | 
 | 
date | 
 | 
freqshift~ | 
 | 
freqshift~ | 
 | 
rate~ | 
 | 
accum, expr, *
 | 
 | 
led, togedge, toggle, ubutton
 | 
| 
				SPDT switch
			 | 
ggate, gswitch
 | 
| 
				Between zero and one
			 | 
toggle | 
 | 
mtr | 
 | 
onebang | 
 | 
cycle~, lookup~
 | 
 | 
fromsymbol | 
 | 
jit.release~ | 
 | 
jit.catch~ | 
 | 
zerox~ | 
 | 
prob | 
| 
				afterpressure, polyphonic
			 | 
polyout | 
| 
				aftertouch
			 | 
touchout | 
| 
				control values
			 | 
ctlout | 
| 
				pitch bend values
			 | 
bendout | 
| 
				raw MIDI data
			 | 
midiout | 
| 
				program change values
			 | 
pgmout | 
| 
				transmit MIDI data byte by byte
			 | 
midiout | 
 | 
bendout, ctlout, noteout, pgmout, polyout, touchout
 | 
 | 
send~ | 
| 
				computer keyboard events
			 | 
key, keyup, numkey
 | 
| 
				mouse events
			 | 
imovie, lcd, mousestate
 | 
| 
				occurrences of a specific ordered set of numbers
			 | 
match | 
| 
				occurrences of specific numbers
			 | 
follow, match, route, select, ==
 | 
| 
				occurrences of specific symbols
			 | 
route, select
 | 
| 
				trap/redirect the output of an object
			 | 
grab | 
 | 
trapezoid~ | 
 | 
triangle~ | 
| 
				a process by sending the bang message
			 | 
button, loadbang, ubutton
 | 
| 
				events automatically when a patch is loaded
			 | 
loadbang | 
| 
				events based on notes played by the user
			 | 
follow, match, route, select, ==
 | 
| 
				a Max message with an audio signal
			 | 
edge~, thresh~
 | 
 | 
expr | 
| 
				for numbers
			 | 
acos, acosh, asin, asinh, atan, atanh, atan2, cos, cosh, sinh, tanh
 | 
| 
				for matrices
			 | 
jit.op | 
| 
				for signals
			 | 
acos~, acosh~, asin~, asinh~, atan~, atanh~, atan2~, cos~, cosh~, cosx~, sinh~, sinx~, tanh~, tanx~
 | 
 | 
jit.la.mult | 
 | 
if, led, match, select, split, togedge, toggle, ==, !=, <, >, <=, >=
 | 
 | 
trunc~ | 
| 
				Max window errors into messages
			 | 
error | 
| 
				off held notes
			 | 
flush | 
 | 
jit.turtle | 
 | 
jit.cellblock | 
 | 
2d.wave~ | 
 | 
biquad~ | 
 | 
number, numkey
 | 
 | 
dialog, message
 | 
 | 
jit.spill | 
 | 
jit.str.regexp | 
 | 
jit.gl.handle | 
 | 
jit.alphablend | 
 | 
regexp | 
 | 
dialog, message
 | 
 | 
key, keyup, modifiers, mousestate, hi
 | 
 | 
dial | 
 | 
jit.scanoffset | 
 | 
jit.gl.multiple | 
| 
				for storing a floating-point number (with a fractional part)
			 | 
float, number, pv, value
 | 
| 
				for storing an integer
			 | 
int, number, pv, value
 | 
| 
				for storing a floating-point number (with a fractional part)
			 | 
pv, value
 | 
| 
				variable that is private to a single patcher and its subpatches
			 | 
pv | 
 | 
pong~ | 
 | 
wave~ | 
 | 
groove~ | 
 | 
groove~, play~
 | 
 | 
vexpr | 
 | 
adc~, dac~, dspstate~
 | 
 | 
vectral~ | 
 | 
adsr~, curve~, gain~, line~, sig~
 | 
 | 
midiparse, notein
 | 
 | 
xnotein, xnoteout
 | 
 | 
setclock | 
| 
				display window
			 | 
jit.window | 
| 
				embedded display window
			 | 
jit.pwindow | 
| 
				information about a video
			 | 
jit.fpsgui | 
 | 
serial, vdp
 | 
 | 
jit.ameba, jit.avg4, jit.brass, jit.brcosa, jit.bsort, jit.charmap, jit.clip, jit.convolve, jit.conway, jit.demultiplex, jit.eclipse, jit.fastblur, jit.fluoride, jit.glop, jit.hatch, jit.hue, jit.keyscreen, jit.lumakey, jit.multiplex, jit.mxform2d, jit.op, jit.plume, jit.plur, jit.repos, jit.resamp, jit.robcross, jit.rota, jit.roy, jit.rubix, jit.scalebias, jit.scanoffset, jit.scanslide, jit.scanwrap, jit.slide, jit.sobel, jit.sprinkle, jit.streak, jit.tiffany, jit.traffic, jit.transpose, jit.wake
 | 
 | 
jit.alphablend, jit.brcosa, jit.gl.videoplane, jit.hue, jit.lcd, jit.matrix, jit.mxform2d, jit.op, jit.rota, jit.scalebias
 | 
 | 
buffer~, capture~, number~, scope~, snapshot~
 | 
 | 
float, forward, grab, int, message, pv, receive, send, value
 | 
 | 
levelmeter~ | 
 | 
meter~ | 
 | 
borax, poly
 | 
 | 
poly | 
 | 
ctlin, ctlout
 | 
 | 
playbar | 
 | 
pipe, speedlim, thresh
 | 
 | 
delay | 
 | 
buddy | 
 | 
filewatch | 
 | 
lookup~ | 
 | 
2d.wave~, buffer~, cycle~, wave~
 | 
 | 
trapezoid~, triangle~
 | 
| 
				using DirectX (Windows only)
			 | 
jit.dx.grab | 
| 
				using QuickTime
			 | 
jit.qt.grab | 
 | 
drunk, expr, random, table, urn
 | 
| 
				for audio
			 | 
noise~ | 
| 
				for matrices
			 | 
jit.noise | 
 | 
closebang | 
 | 
active | 
 | 
bpatcher | 
 | 
pcontrol | 
 | 
pcontrol, thispatcher
 | 
 | 
index~, cycle~, gate~, lookup~, techno~, wave~
 | 
 | 
float, forward, grab, inlet, int, message, outlet, receive, send, value
 | 
 | 
phasewrap~ | 
 | 
comment | 
 | 
jit.poke~ | 
 | 
jit.gl.text2d | 
 | 
poke~ | 
 | 
jit.gl.text3d | 
 | 
expr | 
 | 
jit.plot | 
 | 
change, togedge
 | 
 | 
zerox~ | 
 | 
change, if, led, select, split, togedge, toggle, ==, !=, &&, ||
 | 
 | 
jit.gl.videoplane, jit.matrix, jit.rota
 |