This file describes the system used by the 'J2' program to notate juggling patterns. For a solo asynchronous juggler, this just reduces to the popular 'siteswap' notation; if you are familiar with this you can skip down to the MULTIPLEXING section below. For additional information and help browse around at the JIS siteswap page. You may also want to browse a list of good patterns from a 1997 Lodi festival siteswap workshop, which contains some additional material on siteswap notation not covered here.

General Idea

A lot of freedom exists in choosing a notation to use for juggling. In particular, there are always tradeoffs between expressiveness (how many weird patterns like Mills Mess can you uniquely describe?) and compactness. This program uses a very 'compact' system, for two reasons: (1) it makes the notation more amenable to computer analysis, and (2) with less "superfluous" information in the notation it is easier for a person to look at a pattern and figure out how to do it.

The main limitation of the notation used here is that it ignores all information concerning throwing and catching positions, as well as any characteristics about the objects being juggled (number of spins on clubs, etc.). When an object is thrown, the ONLY things this notation tells you are which hand to throw to, and the amount of time until the object is caught and thrown again. You have complete freedom in choosing how these should come about: Make a standard throw, throw behind the back, bounce off the floor, do a helicopter spin on your head, or whatever, so long as the object winds up at the right place in the right amount of time. The notation's ignorance of these throwing styles means that tricks like the 3 ball cascade and Mills Mess are lumped together, but if you apply some creativity to the output of the program you can get most tricks that people do, and many that have never been done before.

Solo Asynchronous Juggling ('siteswap' notation)

The simplest case is that of a single juggler throwing alternately with both hands in a R-L-R-L kind of way (called 'asynchronous' juggling). This is what you do in the standard cascade pattern. Each throw in our notation can then be described by a single number, namely the number of throws in the future when the object is thrown again. In a 3 ball cascade each throw is a '3', for example. Note that our notation doesn't need to specify the destination hand, since odd numbers always go to the opposite hand, even numbers to the same hand (a result of constraining ourselves to a R-L-R-L throwing rhythm). Another way of thinking about it is this: When you do a throw 'n' (n is the throw number), throw just as you would if you were doing a cascade or fountain with n objects, at the same handspeed. A 3 is a short toss across, a 4 is higher and into the same hand, and so on.

The patterns that the program generates are just sequences of these numbers -- the first number describes the first throw made, the second number the second throw (opposite hand as the first), and so on. At the end of the pattern you loop back to the beginning and continue.

Valid 3 ball tricks include:

                 3      =    standard cascade
                 51     =    shower (that's 5 and 1, not fifty-one)
                 42     =    two in one hand, hold with the other
                 441    =    an interesting box-like pattern
                 55500  =    a 3-high flash
The '0', '1', and '2' throws need some explanation. A '2' throw is thrown again 2 throws in the future, in other words the next throw out of the same hand. Since the hand does nothing before throwing the object again, we are free to interpret a '2' as just a hold for one count. A '1' is a fast zip across from hand to hand, as in the shower. Finally, a '0' is no throw at all; the hand is empty (the pattern 60 is 3 in one hand, the other hand empty).

Notice that if you average the throws in each of the above patterns you always get 3, the number of objects being juggled. This is one of the ways you can tell whether or not a string of throw numbers comprises a valid pattern. '76' doesn't work, but '75' is a valid 6 ball pattern (commonly known as the 6 ball half-shower). Not all strings of numbers with integer averages are valid patterns, however.

Ground State/Excited State Patterns

The siteswap patterns described in the previous section can be grouped into two categories. Any pattern that can be started directly from the middle of a cascade (or fountain, for even numbers) is called a 'ground state' pattern. One which does not have this property is termed an 'excited state' pattern. In the list of 3 ball tricks above, all of them are ground state patterns with the exception of 51, the shower. To switch from the cascade into the shower you have to go through a series of intermediate throws in order to avoid getting two balls in a hand at once. For the shower, a valid starting sequence of throws is '52' (note that this is not a valid repeatable pattern, by the average rule). Switching from the cascade to the shower and back again we could go:

          ...33333333 52 515151...5151 2 3333333...
We say that '52' is a valid starting sequence for the excited state siteswap 51, and '2' is a valid ending sequence (gets you back into cascade). The starting and ending sequences are in general not unique.


If we allow 2 or more throws to be made at the same time by a single hand, the simplest way to notate it is to group together with brackets the throw numbers of the multiplexed throws. For example, a 5 ball ground state multiplexed pattern is: 24[54]. From the middle of a cascade (no starting sequence is needed, since this is a ground state pattern), we first do a hold with our right hand, throw a shorter toss from the left hand to itself, and then simultaneously throw a 5 and 4 with the right (the hand had 2 balls in it, since it did the hold first). Then we can either switch back into the cascade, or repeat the trick with a left-handed hold, etc. (since the pattern is of odd length it switches hands each repetition). [This, by the way, is a trick that Anthony Gatto did in his act, except that he did it all while juggling over his head. He can also do 26[76] with 7 balls.]

Solo Synchronous Juggler

If both hands are throwing at the same time, the notation is very much like siteswap notation above, but with two differences: (1) group together throws made simultaneously with parenthesis, and (2) now we need to specify a destination hand for each throw, so put an 'x' after any throw that crosses over into the other hand (a throw without the 'x' is assumed to be directed to the same hand that threw it). A '2' is still a hold, but a '2x' is similar to the '1' in the siteswap notation above: a short pass from hand to hand. A '0' is still no throw, and a '0x' is not allowed. ALL throw numbers now must be even.

Examples of synchronous patterns:

            (4,4)          = 4 ball synchronous fountain
            (4x,4x)        = a common crossing version of the 4 ball fountain
            (4x,2x)        = 3 ball shower with simultaneous throws
            (4,2x)(2x,4)   = the 3 ball "box" or "see-saw" pattern
            (6,6)(6x,2x)   = a 5 ball trick
            (6x,6x)(2x,2x) = a 4 ball trick
            (4,4)(4,0)     = 3 balls in 4 ball fountain (1 missing)
You are free to choose which hand corresponds to which slot in the parenthesis, but your choice must remain consistent throughout a given pattern. Multiplexing can also be notated, exactly as above; for example the 4 ball pattern (4,2)(2x,[44x]) has a multiplexed '4' and '4x'. Lastly, the concepts of ground state/excited state patterns and starting/ending sequences are valid here as well, but now for instance the patterns (4,4) and (4x,4x) play the role that the cascade/fountain did, since these are the 4 ball synchronous patterns of length 1.

Two Person Passing

Imagine two people juggling, each person asynchronously, but synchronized with respect to each other (juggler #1 throws with her right hand at the same time juggler #2 does). This is the situation in 6 club passing, for example. Now our notation has to tell BOTH people what to do, which might sound complicated but actually isn't too bad. Divide a "throw" into 2 parts, the throwing instructions for each person. A self-throw is written just as a number, exactly as we did for siteswap notation (a 2 is a hold, a 3 is a toss to the other hand, etc.). Append a 'p' to a number to represent a passed throw. To figure out which of your partner's hands to pass to, use this rule: If without the 'p' the throw would go to your left hand, throw at your partner's left, and so on.

Some example patterns should help clarify this. (Note the version of the average rule here: Add up the numbers within each <|>, and average to get the number of objects.)

        <3p|3p><3|3>      = ordinary 6 object passing.  Notice how the
                              instructions for each person are sectioned off.
                              Each person starts throwing with his right.
        <3p|3p>           = "ultimate" passing, where all throws are passes.
        <3|3>             = two people doing 3 ball cascades (boring).
        <4p|3><2|3p>      = a left-handed double, if done once from the
                              middle of a "cascade" (in this case 
                              <3p|3p><3|3> qualifies).  This is a ground
                              state trick, so no starting sequence is needed.
                          = a multiplexed pattern, the left-handed single
                              (a good way to fake out your partner).  Do the
                              first hold with your right hand, since that is
                              when your partner is doing a '3p'.  The '2p' is
                              from your left to his left, and then you
The discussion so far is actually too restrictive. In particular, we don't need to assume that the two jugglers' right hands throw at the same time. This is explicitly not the case in two-count, 7 club passing -- there the right hand of juggler #1 throws at the same time as the left hand of juggler #2 (making the passes alternate). But we can write 7 club, two-count passing as <4p|3><3|4p>, if we now identify the first juggler as starting with her right (a pass), and the second as starting with her left (a self). The sharp reader will notice that our rule above for figuring out which hand a pass goes to is now reversed: A '4p' from your right goes to your partner's left.

It may be conceptually simpler to imagine turning one of the jugglers around 180 degrees, keeping the appearance of the pattern the same -- essentially swapping her right and left hands. The jugglers now have synchronized right hands, so our original passing rule holds and a '4p' from your right hand goes to your partner's right. But now turn your partner back around -- you will be throwing at her left hand.

At any rate, keep in mind that every passing pattern in this notation can be interpreted in two ways: One with the right hands together, one with them staggered. You might consider what the 7 club, two-count <4p|3><3|4p> would be in the former point of view.