Explanation¶

These pages are for reading away from the console. Each one picks a concept and starts with the problem it solves: the show situation where things go wrong or get tedious without it. Then comes the idea behind it, and an honest note on when you need it and when a small rig can ignore it. The MA manual mostly describes what a feature does. These pages try to explain why it exists.

Start here¶

How grandMA2 thinks is the map: the five ideas the whole console is built from, and what you can safely ignore at first.

The core, in the order you build a show¶

These are the concepts no show can avoid. Read them in order. Each one builds on the previous.

• Fixtures and patch: why you program fixtures and not DMX addresses, and how the patch lets a rig change without breaking the show.
• The programmer: where your values live before they are stored, and why Clear takes three presses.
• Selection and groups: why selection order matters, and why a group is only a shortcut.
• Presets: why cues should refer to presets instead of storing numbers, and what selective, global and universal mean.
• Cues, sequences and tracking: why a light stays red in cue 5 when you only made it red in cue 2.
• Executors and pages: the handles that play your sequences, and why changing page doesn't stop anything.
• Playback priority: who wins when several things control the same light.

Going further¶

Once the core makes sense, these pages explain the tools that make programming faster and shows more robust. They can be read in any order.

• Attributes and colour systems: which attributes matter, MixColor vs. colour wheels, and why "Red" needs tuning per fixture type. One page goes deeper: Colours aren't equally bright (balancing colour presets so a colour change isn't an intensity jump).
• Worlds, filters and masks: doing less than everything. The overview maps situations to tools, then one page per situation, from programming to playback: working on part of the rig (worlds), seeing only what matters (masks), storing only part of a look (filters), executors that only do one thing (playback and input filters). Useful even on small rigs.
• Store and update: why "save this" has several meanings, and why Update fixes values where they come from.
• Cue zero, fade paths and loops: a defined start for sequences that wrap, the shape of a fade, and repeating part of a cue list.
• Timing: cue, preset-type and individual times, move in black, and changing time during playback.
• Effects and chasers: two ways to make things loop, and when to use which.
• MAtricks: odd/even, pairs, mirrored fans and blocks without building extra groups.
• Timecode shows: recording and replaying routines across many executors, with or without external timecode, and how they compare with cue lists, macros and chasers.

And four about the console itself:

• The command line: the small language behind every key and button.
• Macros: one button for a fixed list of commands, from "into the breakdown" to toggles and command-line helpers.
• Screens, views and layouts: building screens for each task, and what the different sheets show.
• Systems and networking: how onPC gets to real lights: sessions, parameters, Art-Net and sACN.

Working practice¶

How the console is meant to be used. The manual doesn't cover this, so these pages draw on general programming practice.

• Building a show: the intended order: patch, groups, presets, cues, executors, and why that order pays off.
• Organising groups and presets: pool layouts you can read without looking, and which preset scope for what.
• The programming workflow: the select–set–check–store–clear loop, and keeping the show clean.
• Design and fine-tuning: fixing changes where they live, working in passes, adapting to a new venue, designing energy levels.
• What goes on an executor: faders for amounts, buttons for events, layers instead of looks, and page structure.
• Inspecting your programming without live output: sequence sheets, output layers, Preview, Blind and MA 3D.
• How the hardware shapes the show: console, onPC, wings and MIDI controllers, and designing for the hands you have.
• Busking vs. cue-list shows: the two worlds grandMA2 serves, what each can ignore, and how to mix them.
• A forgiving show: designing a show that a tired, distracted or not-quite-sober operator can't break.
• Choosing the tool for a look: from a look you can describe to presets, effects, chasers, cues, MAtricks and executors, with worked examples.

Only for rave¶

Busking electronic music: you don't know the tracks, but you know the shape of the music. Read Busking vs. cue-list shows first if you're unsure which world you're in.

• Busking a rave: energy levels: darkness as the canvas ("Licht lebt von Dunkelheit"), designing for breakdown, groove, build-up and drop, and programming the show as an instrument.
• Busking intensity: balance vs. hits: balancing fixture types without limiting the hits. Three pages go deeper: Hits: Flash, Swop or Kill (adding light or taking it away), Getting back to the baseline (one move after the drop) and Worked example: a small rig (4 washes, 8 bars, 4 beams as a page of executors).
• Sequences on a busking page: what each executor claims and what happens when it lets go: tracking on or off for chasers, overlapping executors, cue triggers.
• Colour concepts for busking: free picking, palette grids, colour looks, base and accent, colour in motion.
• Playing in time: beats, bars and drops: one speed master as the clock, musical speed factors, phase, and building a drop. Two pages go deeper: Getting the tempo: tap, listen, type (tap vs. BPM detection, sound and BPM cue triggers) and Rhythm patterns over 16 beats (patterns like xxxxx--x--x--x-- as chasers or effect forms, fills into the drop).
• Timecode in a DJ set: short programmed routines for the ups and downs, and why seconds drift against beats.