About the juggling animator

Playing with the master juggler


The controls in the juggler settings panel on the master juggler are hopefully self-explanatory.

Pattern entry

The easiest way to enter a pattern is to double-click on a thumbnail juggler applet embedded in the text; however, this only lets you play with the prepackaged patterns. The following block is the complete description of what the juggler will accept as a pattern.
The basic unit in a pattern string is the multiplex throw, which is either just an individual throw or a collection of invididual throws collected between brackets [].

An individual throw is a number, followed by a (possibly empty) list of throw modifiers a-z. If the pattern string has no embedded spaces, the numbers are read in as digits 0-9 and letters A-Z (interpreted as 10-35). If a space appears anywhere in the pattern, consecutive digits are read as a single number.

There are two kinds of patterns: synchronous and asynchronous. An asynchronous pattern is simply a list of multiplex throws; a synchronous pattern is a list of pairs of multiplex throws, where each individual throw is an even number.

The pattern parser searches the pattern for parentheses and commas; if it finds even one, it decides the pattern is synchronous, and will then only complain if it has an odd number of multiplex throws, or if any of the individual throws are odd.

If there are no parentheses or commas, the pattern parser will only complain if it finds characters other than {space, 0-9, A-Z, a-z}, if the multiplexing brackets [] are badly matched, or if the throw modifier "x" is used (since it's only supposed to be in asynchronous patterns).


  • The pattern "A1612" and "10 1 6 1 2" are interpreted as the same asynchronous pattern.
  • The string "(6,3)" is not a well-formed pattern, because it wants to be synchronous, but has an odd throw.
  • It's not good form to write "(4,6,4)(6,4,6)", but the pattern parser will interpret it as "(4,6)(4,6)(4,6)" and not raise a ruckus.
  • These are to specify a series of throws to be performed over and over. So if you really want to see fifteen balls juggled in a cascade, but despair because the string "15" is interpreted as one:five since it has no embedded spaces, you can be tricky and get the desired effect with "15 15".

    Throw modifiers

  • b - bounce this throw on the ground
  • r - reverse
  • t - throw (for 2's, which are otherwise held)
  • x - make this a crossing throw, rather than back to the same hand
  • Note that not every well-formed pattern is actually jugglable! This is explained in the section on Working Backwards from numbers to juggilng.

    Details of the program

    Each juggler is just one thread, as is each space-time diagram. They can be linked to one another on a page by giving each a "family name" parameter; the juggler then finds the diagram via its getAppletInfo().

    The thumbnail jugglers talk to the main Juggler through static variables, which is necessary for them to find one another across pages.

    All the calculation is done in the jugglers, which then call methods in the space-time diagrams. Making them separate applets is essentially only useful for placing them on a page.

    Now you're ready for the theory!

    Space-time diagrams

    Return to "Juggling By The Numbers" Main Page