SiGN is a notation that supports any size of cube, although with slight modifications it works very well for other puzzles. It is quite simple to understand and use, and is based off the common and standardized notation for the 3x3x3. Because of this, the basic SiGN system has been discovered by several people over the years, myself included. The name is due to Lucas Garron, and stands for "Simple General Notation", which describes it pretty well. Many cube applications, including qqTimer, support or use this notation.
SiGN has a number of benefits over other notations. Since it's based off the 3x3 notation, it's easy to remember, and doesn't clash with a common notation that has been in use for some 30 years. It doesn't require any superscripts, subscripts, or weird characters, so it's easy to type out any move sequence. It's also complete enough to describe both multiple- and single-layer turns as one step, mirroring the way cubes behave in real life. One potential problem is that it is important to keep spaces between adjacent turns in SiGN, because otherwise there are situations that could be interpreted as two or more totally different things.
To start, you'll want to be familiar with the basic notation from the SpeedSolving wiki. To summarize, the six faces are each given one letter: F (front), B (back), U (up), D (down), R (right), and L (left). We write turns by taking one letter and adding a suffix which describes the angle and direction of the turn, from the perspective of someone looking at the face being turned. For the 3x3x3, you will see nothing for a 90-degree clockwise turn, ' for a 90-degree counterclockwise turn, and 2 for a 180-degree clockwise turn. Sometimes you will see 2' for a 180-degree counterclockwise turn, but since this is the same as a 180-degree clockwise turn, it is generally only used to describe how a sequence is executed. With just these letters and suffixes, we can write useful algorithms, such as R U R' U R U2 R' (the Sune). These suffixes can be added to every possible type of turn described on this page.
Using the "block turn" concept, a single move is defined by turning one or more consecutive slices (on some axis) by a certain angle in a given direction. In SiGN, turns are grouped into two types: turns of single layers, and turns of multiple layers. Single-layer turns are represented as capital letters, and multiple-layer turns are represented by lowercase letters.
Of course, there are many turns of each type. SiGN adds a number before the letter to identify what layer or layers are being turned. For single-layer turns, we add the number of the layer, starting from 1 for the shallowest layer on one side and going up as the layers go deeper. However, for convenience, we don't write the 1 when doing turns of the outermost layer only. So, on the 4x4x4 cube, the four horizontal layers can be described as U, 2U, 3U, and 4U. Keep in mind that we view a numbered layer from the same direction as its letter, which means that, even though the 4U layer on a 4x4x4 is the same as the D layer, a 4U turn is viewed from the top, so 4U' and D mean the same turn.
For multiple-layer turns, it's slightly more complicated. If the turn includes the shallowest layer (for instance, turning layers 1 through 3) we simply use the number for the deepest turn, although if the deepest turn is the second layer, we again omit the number for convenience. Thus, the turns including the shallowest layer are labeled u, 3u, 4u, and so on. If the turn does NOT include the shallowest layer, on the other hand, we include both numbers and put a - between them. A turn of layers 2 through 5 on the right side would be written 2-5r.
Although the above is technically enough to describe any move sequence on any NxNxN cube, it's not always the most convenient way to write moves. These extensions are used to make sequences smaller and more easily understood, and all of the ones in this section are common enough for most serious cubers to follow.
For rotations of the entire cube, SiGN uses the common and traditional notation from the 3x3x3 cube. By tradition, x refers to a rotation in the same direction as an R turn, y refers to one in the same direction as a U turn, and z refers to one in the same direction as an F turn. Of course, it's still possible to refer to any of these turns with the basic notation.
It's also common on the 3x3x3 to use M, E, and S to describe turns of the middle layer. In SiGN, these turns could be respectively written as 2L, 2D, and 2F. There are a few possible ways to extend these turns to SiGN notation, but my favorite is to decide that M turns all layers except those turned in R and L, and then extend that idea further: m turns all layers except those in r and l, 3m turns all layers except those in 3r and 3l, and so on. The advantage of this approach is that many algorithms written on smaller cubes (such as 3x3x3) will still work on bigger ones.
Occasionally you'll see a group of moves in parentheses. This doesn't do anything by itself (except possibly make an algorithm easier to understand or remember), but it does allow you to add ' at the end to invert the group, or a number at the end to apply the group that many times. For instance, (R U R' U')3 moves four corner pieces and no edges.
There are also two types of notations involving square brackets. Suppose that P and Q represent two sequences of moves (they don't have to be enclosed in parentheses). Then the notation [P, Q] means P Q P' Q' (this is called a commutator), and the notation [P: Q] means P Q P' (this is called a conjugate).
Less Common Extensions
People have suggested a many extensions to the standard notation. These didn't ever get wide acceptance, but they could still be useful for specialized applications. Just make sure to explain them.
When extending SiGN to more puzzles, we need to expand the available letters and suffixes. For letters, it's possible to use two or more letters to describe a turn without breaking the notation. This is useful for puzzles with more turning axes, such as edge-turning cubes, where we might want to describe a turn around the up/front edge as UF. For suffixes, we simply do the same thing we do in parenthesized groups: allow any number (possibly followed by a ' for the inverse). For instance, on a more exotic puzzle, we might want to use R2' or U5.
There is also the idea of adding a c as a prefix to mean a cube rotation. Although this isn't at all necessary on cubes (because we have x, y, and z) it comes in very handy on other puzzles (such as Megaminx) where rotations are a lot more tricky to express.
It has been suggested to use * as a prefix to describe a turn which affects half of the cube, rounded down. This is useful for making algorithms that work on a wide variety of different cubes. The PLL parity algorithm for 4x4x4, written using this style, looks like *u2 *r2 U2 *r2 R2 U2 *r2 *u2. This algorithm, as written, now works on any even cube.
Other people have suggested a few new bracket notations, too. Lucas Garron has suggested that we can use [P; Q] as a substitute for [P: Q] when necessary, and then introduce an order-of-operations precedence so that [N; O, P: Q] means the same as [N: [O, [P: Q]]]. Stachu Korick suggested [P| Q] for P Q P. Thom Barlow proposed [O| P| Q] for O P O' Q P Q' (and then I suggested [O; Q: P], and then he suggested that any two symbols would be equally good).[an error occurred while processing this directive]