Manual: Ribbon Tool

Submitted by David on Wed, 09/14/2016 - 01:14

The Ribbon Tool

The Ribbon Tool runs various short programs resulting in sequences of lines that generally look like ribbons, and are acceptable for embroidery. 

There are two main components to this process, Nodes and Drawing Sequence. The nodes define particular locations.  There are a variety of different nodes types, each type interacts in different ways with the other nodes. The drawing sequence defines what we are drawing using these points.



The Ribbon Tool is programmed via the string of text after it in the settings screen for the tool. This can be edited within the given interface but only in a text manner. The formatting for the code here is generally akin to how SVG Path commands work. It conforms to 8.4.9 of SVG 1.1 and XBNF Grammar, for SVG paths with different commands. --- This may sounds a bit daunting but isn't too hard to understand.

The valid command letters are: a,b,p,i,o,r,g,v,n,f,s,l,d,k.  Uppercase and lowercase letters usually denote similar but slightly different commands.

Each letter expresses a command. Any number that fits the format of a valid number is a valid number (within that context).

For example:
.5.5 is taken as 0.5 and 0.5.
5.5.5 is taken as 5.5 and 0.5.
--4 is taken as -4.
3-4-5 is taken to be 3, -4, and -5.

 All the path statements are strings of numbers and letters and anything that makes sense as a number is a number, and all the letters (except for 'e' which is used in floating exponent notation) are commands.


The nodes are the points that move around the scene. These are the objects with predefined relationships to each other depending on their types.

Important points:

  • The nodes themselves often relate to other nodes. This allows for complex behaviors and as a result complex results. Each node command that creates a node is given an index number beginning 0 (zero). Each additional node gets the next index number.
  • Some nodes cannot technically have a location, these nodes are disengaged. Any sequence that depends on a disengaged node, will not draw without all the relevant nodes are engaged.
  • Ribbons are timed actions. They update their positions from the previous iteration of the position. In the previous tick. The tick time is generally equal to 50ms.


All nodes have properties of scale and location. These are not not set by the node initialization parameters. For example the Node "v", is for Variable-Node. It can be moved around the screen and repositioned even when not using the tool. But, since all trackers have a location, this can be set for a particular node. So vl500,500 creates a variable node and sets its location to (500,500) in scene.

Location Modifier:
l (x,y)
Example "L.5.5" set this tracker's typical origin point to be half-way across the non-zoomed non-panned screen size, and half-way down. For example. vL.5.5 places a Variable Tracker at a default center of the screen location. "f0L.1,0" places a finger node (f) for the first touch position but moves it 10% of the screen width to the right.

l (x,y) same as L but locations are given in pixels rather than relative to the screen size.

Scale Modifier:
s <scale>
s <scaleX> <scaleY>

Example "a0,1s.5" - creates a Add Node that is the addition of node #0 and #1 scaled by 0.5. Which is to say (since there's 2 nodes) the average of those two tracker or the position exactly between them.

If only one parameter is given it is the scale for x and y.

"2-finger Rake" is a good example of this. "f0f1o0,1ns.2ns.4ns.6ns.8" f0 creates a finger node for the first press, f1 creates a finger node for the second press. Then the o node creates a node located relative to node #0 towards #1 (which would be coincident to node #1 at a scale of 1) and then it is scaled to .2 or 20% of the way between them. Then an 'n' node duplicates this same o-node but gives it a 40%. Then we duplicate that at 60% and then we duplicate that at 80%. The end result is 6 nodes. Four of which are evenly spaced between the finger presses.

Finger Node
f <finger>
F <finger>
Example "f0" - node is the location of finger touch 0. Touch Embroidery natively limits this to 5 locations. If you pick up your touch and return them it will not change the location of the presses. So if you have a program that does "f0f1f2" And you place three fingers on the touch display it will call these f0, f1, and f2. In the order you placed your fingers down. If you lift f1 (the second finger you touched the screen with) it will stop moving but continue to have f0 and f2 engaged. The next touch event will be given f1.

The uppercase F form does not disengage. 

Add Node.
'a' <#>*
Example: "a3,4" - This nodes position is the sum of position of node 3 (the 4th node) and node 4 (the 5th node). Any number of node indexes can be sequenced together.  This can be used to add the position of a single node, with the modifiers of scale and location. So "a3,4s.5" means the sum of those nodes at those indexes, scaled at half. Which is going to be exactly between those two nodes.

Back Node.
'b' <index> <amount>
'b' <index>
'B' <index> <amount>
'B' <index>
Produces a node that is the same as another node some number of ticks ago. If amount is omitted the value is set to 1.

The uppercase form, rather than directly being the exact location, it's the average of the last <amount> of different locations. This can allow you to get smoother looking interactions. 

Example: "b 3 5" - node is the same location as node 3 (4th node) was 5 ticks ago.

Example: "B 0 40" - node is the average of the last 40 ticks of node 0.

One of the included default ribbons is Reverb which is "f0b0,50" which is the finger node, and the position of the finger node  fifty ticks ago. This creates a zigzag line (See Sequences) between the two nodes the position of your finger and that position 50 ticks earlier. Note, this entire program is seven characters long, and produces an understandable and highly visual striking effect.
* Amount is limited to a max of: 100 (which given that a tick is 50 ms, is half a second). 

Gravity Node
'g' <index>*
Example "g0,1" follow with momentum node 0 and node 1.

The default program Cubic Bezier is "f0g0g1" which provides three nodes, the finger press node. A gravity node that is attracted to the finger node. And a gravity node that is attracted to the previous gravity node. Each one following the next. Providing more than one index for the node causes it to attract to the barycenter of those nodes. If you give no indexes, it simply remains at its location. If the same index is provided twice it goes to the barycenter of all the indexes with twice the weight for that index.

G <speed> <index>*
Example "G 0.5, 0" -- Tracks node 0. But, do so at half the typical inertia. 

The default nodes have both inertia limits and friction. If one reduces the friction, the nodes can maintain their momentum for longer or even forever.
Example: f0G0,0 provides a finger touch node and a gravity node that is attracted to that node but without the friction. It maintains it's current momentum forever. Even revolving around your finger press.

Radial Node:
r <speed>
r <index> <speed>

Radial node travels clockwise around a point either the node provided by the index. Or the origin point 0,0. 

The major uses for this would require the use of the modifiers for Scale and Location. The implication being you can set the radius with scale (using different major and minor scale elements creates an oval). And location 'l' which offsets the position by that location. If attached to an index node, the offset is applied relative to that index node.

The speed is at default at 1 revolution per 50 ticks. Given that a tick is 50 ms or so that should be about 2500 or 2.5 seconds. The speed factor is relative to that. So speed = 0.5 would take 5 seconds to go around. If 25 it would take about 100ms. Though, in this case, since this is only 2 ticks the node would flicker back and forth, between the two acceptable positions it has. Offsetting that a bit more like "r20.12345s500L.5.5" has only a single node, but should produce rather interesting geometric patterns.

Orientate Node:
Allows you to define the position of a node based on the angle and distance  of any other nodes in the scene.

O <reference-node> <index-angle-A-node> <index-angle-B-node> <angle-offset> <index-distance-A-node> <index-distance-B-node> <distance-offset>
This node is located away from the reference node, the equal to the difference in locations of distance-A and distance-B and an a distance offset, at an angle equal to the angle between angle-A and angle-B  and extra angle offset.

O <reference node>  <index-angle-A-node> <index-angle-B-node> <angle-offset> <index-distance-A-node> <index-distance-B-node>
This node functions the same as the full form but assumes the distance is zero.

O <reference node> <angle/distance node A> <angle/distance node B> <angle-offset> <distance-offset>
This node is located away from the reference node, the equal to the difference in locations of A and B, with an extra angle offset and an a distance offset.

O <reference node> <angle/distance node A> <angle/distance node B> <angle-offset>
This node is located away from the reference node, at the distance, but the angle is offset. For, example O0,1,2,90 is located away from #0 a right angle away from #1 is from #2.

O <reference node> <angle/distance node A> <angle/distance node B>
This node is located away from the given reference node the same distance and angle as node A is from node B.

O <reference node> <distance>
This node is located at a zero degree angle the given distance from the reference node. 0° is going to be in the +x direction to the right. Negative distances will be on the left.

O <reference node>
This simply has a reference node, it's coincident with the reference node.

o <index-angle-A-node> <index-angle-B-node> <angle-offset> <index-distance-A-node> <index-distance-B-node> <distance-offset>
This node is located away from the first angle node, the equal to the difference in locations of distance-A and distance-B and an a distance offset, at an angle equal to the angle between angle-A and angle-B  and extra angle offset.

o <index-angle-A-node> <index-angle-B-node> <angle-offset> <index-distance-A-node> <index-distance-B-node>
This node is is the same as the full specification, but the distance offset is assumed to be zero.

o <index-angle-A-node> <index-angle-B-node> <angle-offset> <distance-offset>
This node is located at the angle of A to B plus the angle offset. But the distance is *only* the result of the distance-offset.

o <angle/distance node A> <angle/distance node B> <angle-offset>
This node is located from A to B, at the given angle-offset. So it's the position of B rotated around A by the given angle-offset. Example: "01,2,45" this node is located at a distance equal to the distance between #1 and #2, from #1 towards #2 but at a 45° angle.

o <angle/distance node A> <angle/distance node B>
This node is located from away from node A towards node B at the same distance as node B. In the basic form this would be coincident to node B. However, because of scale modifiers that can be applied to the node, this may not be the case. If one created a node "o1,2" it would be located at same position as the index of node #2. However if one applied a scale modifier this could be expressed as "01,2s.6" this node is 60% of the way from 1 to 2.

Example: "o0,1,2,90,4,5,100" - Node is located away from node index 0, at the same angle as node index 1 is from node index 2 plus 90°, at a distance equal to the distance from tracker 4 to 5 plus 100.

So if #2 is at a 30° angle from #1 (regardless of distance), and 4 and 5 are 50 apart (regardless of angle). Then the Orientate Node is located from #0 at 120° (30° + 90°) and a distance of 150 (50 + 100). 

The lower case form  allows for easier representation of the typical use case that the Orientate Node is at some angle from a given node index, in the direction of a second node, at some distance. There are a variety of alternative shorter forms that assume values not given. These vary based on the number of valid number provided. The O command can be provided with 7 numbers, the lower-case form with six. Additional values are ignored. Fewer numbers apply different assumptions as to what the numbers are result.

Take special note of the 4 parameter lower case form: o <index-angle-A-node> <index-angle-B-node> <angle-offset> <distance-offset>. This is the only way to express something at a given angle between two nodes but with an expressly static distance. "f0b0o0,1,90,100ns-1" for example would create a finger press node, then a back node that indicates the previous location of that finger press node, then an orientate node that would be 100 pixels at a right angle in the direction of your own path. And another node on the other side of that.

The uppercase type have a reference node. It is never assumed to be reused in any of the shortened forms.  The lowercase form always assumes the reference node is the first angle node.

Angles are measured in degrees.

Path Node
'p' <x,y>*
Example: "p 0,0 500,0, 500,500, 0, 500, 0,0" - Travel around a 500 by 500 square over a period of a thousand ticks (default).
Produces a tracker whose position travels to each point in a specific order.

'P' <X,Y>*
Example: "P 0,0, 1,0, 1,1, 0,1, 0,0" - Travel around the edge of the given screen of the device where 0 is a location 0% through the given dimension and 1 is 100% through the given dimension. So "P.5.5" is the center of the screen (non-zoomed non-panned).

Variable Tracker
Example "v" - Add a variable whose location is dependent on the user moving that tracker while the ribbon is not engaged. To set the location by default the "L" or "l" modifier which should be used.

If Node
'i' <if-node> <then-node> <else-node>
Example "i1,2,3" - Node is the same location as node #2 if node #1 is engaged, else it is in the location of node #3. 
Not engaged nodes are for example a 'b' back node that doesn't have sufficient elements to exist. Or a finger tracker for a finger press index that isn't engaged.
* Produces a node at location <then-node> if <if-node> is engaged, if it is not, it's location is <else-node> location.

Example: "Expand 2nd Finger" in the default programs.

I created this node form, but never ran into any highly needed reason to have it. But, it's completely possible to create entirely different patterns depending on whether a node is engaged or not.

Node Node.
n <index>

Example 'n' - Add a node identical to the previous node, of the same type and attributes. These typically are then typically modified, with the modification commands.
The optional (usually never used) index attribute lets you duplicate a specific node rather than the previous one.


Drawing Sequences

The second part of ribbons is how we draw rather than what points can be drawn.


d <Node Index> {4}
Indicates an explicit draw sequence.
If 1 tracker is defined. This is a point.
If 2 trackers are defined. This is a line.
If 3 trackers are defined. This is a quad bezier curve.
If 4 trackers are defined. This is a cubic bezier curve.

Example: "f0g0g1g2g3d1,2,3,4" Provide a finger touch tracker that is being gravitationally tracked, that is being gravitationally tracked, that is being gravitationally tracked, that is being gravitationally tracked, that is being gravitationally tracked. They are linked together in a chain as each node is directly fed the node before it.

The d command here, tells the program to draw a cubic bezier curve (4 control points)  between 'g'-type nodes only rather than the default draw sequence. The default draw sequence is to take the first four nodes (or however many there are) and go back and forth between those points. This can be expressed as "d0,1,2,3d3,2,1,0", but is unneeded. However, if we do not want the finger press involved with the drawing, we must can tell it overtly to draw this given pattern. However, this doesn't have the reverse pattern so it simply draws a line back to the first node for the next tick. So, unlike the default this node starts on the #1 and ends on #4, which means the next tick it must draw a direct line back to #1 to draw from it again to number #4.  Each given d command performs in sequence each tick so "d1,2,3,4d4,3,2,1" draws the first sequence the first time and the second sequence the second time. Something like "d1,2d2,3,d3,4d4,3,d3,2d2,1" creates a 6 tick drawing sequence.

Sequence Draw Group
D <Sequence>*
Indicates the start of a different draw group. Meaning use the same nodes but also draw this this other grouping.

Example: "f0f1,f2D0D1D2" Track three finger touches and draw points between all of them, linking everything together when the drawing stops.

The groups are linked together in a back and forth pattern. The end of the first group is linked to the end of the second group (which is reversed) and then linked to the start of the third group. Etc.

"D0D1D2" is short hand for "Dd0Dd1Dd2".
"D0,1" is short hand for "Ddod1".
As there is only one index in this Draw Sequence these are single tick points.  For anything useful we should rather express fuller and complete draw groups.
Given our basic program "f0g0g1g2g3" Finger Press and a chain sequence of points tracking the next point. We can draw a large variety of different patterns simply by changing the draw values. If we express our draw group/sequence as:

Giving us: "f0g0g1g2g3Dd1,2d2,1Dd2,3d3,2Dd3,4d3,4" We create a rather wonderful pattern. We create three ribbons going back and forth over, each one linked to the next ribbon. Even though the relationship between the nodes is the same.

Tick Sequence
k <sequence>*

Example, "f0g0g1  d0d1d2k1,2,3" In the simple sequence of a finger press being tracked by a gravity node, being tracked by a gravity node. We draw each node individually, going from 0 in the first tick, to 1 in the second tick, to 2 in the third tick.

When we apply the 'k' command we control how many ticks we apply each tick. So we add to this sequence of 1 tick the first tick, 2 ticks for the second tick (so it applies the 2nd and 3rd actual tick in the sequence), and 3 at a time for the 3rd tick (which would be the 4th, 5th, and 6th tick respectively). So draw a point at 0. Draw a line to 1 then 2. Then draw a line from 0,1 and 1,2. During the 3 available element. After this the cycle begins again.

The 'k' tick sequence is applied to the latest draw group.

No sequence k, is equal to k1 which is equal to "" as k1 is the default.

However, if no sequence is given the command forces the closure of the draw sequence prematurely. Which matters for the implementation of the default draw sequence. So rather than writing: "f0g0g1g2g3 d2,3,4,d4,3,2" (gravity track sequence which is drawing a quadratic beziers back and forth between the last three nodes) we can write "g1g2g3kg4f0" We reordered the gravity sequence to make sure the relevant g nodes were first, then closed the draw sequence. Then the default draw sequence is applied before the fourth node is added, and before the f0 finger node is added. So the sequence was closed and saved as"d0,1,2d3,2,1" which is what we wanted. 

Several of the default programs use this trick. Such as Tracking Line which is written "g1g2kf0" which has node #0 a gravity node that follows node #1. Node #1 is a gravity node that follows node #2. Calls for the close of the draw group at this point which draws a line "d0,1d1,0" then adds in the finger press node. If the draw routine were closed at the end it would draw a quadratic bezier curve from the g1 node to the f0 node.


  • Fill, "f0f1"
    • Draws line between first and second touch positions.
  • Line", "f0g0"
    • Draws line between touch position and a gravity node that tracks that touch position.
  • Quad Bezier", "f0g0g1"
    • Draws a quadratic bezier between three objects in a chain.
  • Cubic Bezier", "f0g0g1g2"
    • Draws a cubic bezier between 
  • Tracking Line", "g1g2kf0"
    • #0, gravity object follows node #1
    • #1, gravity object follows node #2
    • k, defines default draw based on those two elements.
    • #2, finger node for first touch.
  • Tracking Quad, "g1g2g3kf0"
    • #0, gravity object follows node #1
    • #1, gravity object follows node #2
    • #2, gravity object follows node #3
    • k, defines default draw based on those three elements.
    • #3, finger node for first touch.
  • Tracking Cubic, "g1g2g3g4f0"
    • #0, gravity object follows node #1
    • #1, gravity object follows node #2
    • #2, gravity object follows node #3
    • #3, gravity object follows node #4
    • k, defines default draw based on those four elements.
    • #4, finger node for first touch.
  • Tracking Loop", "f0g0g1g2d1,2,3,1"
    • #0, Finger node, first touch.
    • #1, gravity object tracking #0
    • #2, gravity object tracking #1
    • #3, gravity object tracking #2
    • draw sequence of nodes 1,2,3,1
      • This produces a cubic bezier curve with coincident anchor points.
  • Nudge 3Loop", "f0g2g3g1,0d1,2,3,1"
    • #0, Finger node, first touch.
    • #1, Gravity object tracking #2.
    • #2, Gravity object tracking #3.
    • #3, Gravity object tracking #1 AND #0
      • This makes the objects loop together and take a small amount of nudging from the position of the touch point.
    • draw sequence 1,2,3,1
  • Nudge 4Loop", "f0g2g3g4g1,0d2,3,4,2"
    • #0, Finger node, first touch.
    • #1, gravity node tracking #2
    • #2, gravity node tracking #3
    • #3, gravity node tracking #4
    • #4, gravity node tracking #1 AND #0
    • draw sequence 2,3,4,2
  • Nudge Cubic, "g1g2g3,0kf0"
    • #0, gravity node tracking #1
    • #1, gravity node tracking #2
    • #2, gravity node tracking #3 and #0
    • k, force close the default drawing sequence
      • In this case it's "d0,1,2d2,1,0"
    • #3 Finger node first touch.
  • Nudge Quad, "g1g2g3g0,4f0"
    • #0, gravity node tracking #1
    • #1, gravity node tracking #2
    • #2, gravity node tracking #3
    • #3, gravity node tracking #0 and #4
    • #4, touch node first finger press.
      • Note: d maxes out at four nodes and the default draw sequence here is "d0,1,2,3d3,2,1,0"
  • Speed Zig, "o2,3,90ns-1kf0B2,5"
    • #0, Orientate Node, node #2 pointing towards #3, turned clockwise by 90 degrees. 
      • This makes the angle between #3->#2->#0, a right angle.
    • #1, identical node to #0 but, scale at -1.
    • s-1, Scale this node by -1. This will reflect the node in the other direction.
    • k, stop the draw sequence at this point. Default draw applied with 2 nodes. "d0,1d1,0"
    • #2 Finger node, first touch location.
    • #3 Back Node, reflecting the average of the last 5 positions of node #2 (the touch position).
      • The angle between #2 and #3 will be in the direction the touch location is moving.
      • This means that #0 will orientate itself at a right angle from the direction of the touch location.
      • And that #1 will be at a right angle the other direction. 
      • This results in drawing lines perpendicular to the traveling direction.
  • Spin Ribbon, "a2,3o2,0,180kf0rs100"
    • #0, Add Node. The sum of nodes #2 and #3.
    • #1, Orientate Node. From position #2 to #0, flipped 180°
    • k, draw sequence is d0,1d1,0. Back and forth line between add node and orientate node.
    • #2 Finger Node, position of first touch.
    • #3 Radial Node, with a radius of 100 pixels.
    • s100, sets the radius to 100 pixels.
      • The radial node is moving around the origin, #0 + #2 is going to be circling around the Touch Location. 
  • Smooth Quad, "B3,5g0g1kf0"
    • #0, Back Node, the average position of node #3 over the last 5 ticks.
    • #1, Gravity Node, tracking the position of node #0.
    • #2, Gravity Node, tracking the position of node #1.
    • k, close the default draw group. Sequence is "d0,1,2d2,1,0"
    • #3, Finger Node, first touch position.
      • This is the same for the Quad, but rather than using the finger location, it uses the average of the finger location. Causing things to be much smoother.
  • 2-Finger Quad, "f0g0 2f1"
    • #0, Finger Node, first touch position.
    • #1, Gravity Node, tracking position of #0 and #2
    • #2, Finger Node, second touch position.
      • This is similar to fill but the gravity node for the control point for the quadratic bezier curve generally tries to exist between the two touches.
  • Double Tracker, "f0g0g3f1"
    • #0, Finger Node, first touch position.
    • #1, Gravity node, tracking #1.
    • #2, Gravity node, tracking #3.
    • #3, Finger Node, Second touch position.
      • Note: the order here is because the draw sequence gets d0,1,2,3d3,2,1,0 and the desire is to have the two touch locations the anchor points.
  • Calligraphy, "f0a0,2al50,50d0,1d1,0"
    • #0, Finger Node, first touch position.
    • #1, Add Node, #0 + #2.
    • #2, Add Node. no indexes. This will be at 0,0 and do nothing.
    • l50,50 Now, that Add Node will be 50,50
    • d0,1d1,0, Draw sequence. Draw between 0,1 and 1,0.
      • This will draw lines between the touch location and a location found to be +50,+50 from the touch location.
      • This is poorly written. literally "f0nl50,50" is the same thing. Creates touch node, a second touch node and moves that node over by 50,50. Since there are only two nodes, it would sequence properly.
  • Smooth Calligraphy", "B2 5l-50,-50a0l100,100kf0"
    • #0, Back Node, average of node #2, over the last five ticks. Offset by -50,-50.
    • l-50,-50 moves this node up and left by 50, and 50.
    • #1 , Add Node, coincident with node #0. But, then moved down and right by 100,100.
      • The add node code creates a node in the given position. If one used a "n" command here it would work but, but equally store the last 5 entries of node #2.
      • The l command would overwrite the l command of the second Back Node, needing to be shifted by 50,50 rather than 100,100.
    • k, draw lines between just those two nodes.
    • #2, Finger Node, first touch position.
  • Bendy Calligraphy", "B5,5B2,10kO5,3,4vvl100,100f0"
    • #0, Back Node, average of last five positions of node #5
    • #1, Back Node, Average of last ten positions of node #2
    • k, just draw lines between those two nodes.
    • #2, Orientate Node, using the reference node of node #5, position self the same distance and angle as the distance and angle of node #3 to node #4.
      • This will make the position of relative to the touch node, but equal relative positions of #3 and #4
    • #3, Variable node. You can move this node around, and change its position.
    • #4, Variable node. You can move this node around, and change its position. But, it defaults at 100,100.
    • l50,50, make node #4 default to position 100,100.
    • #5, Finger Node, first touch location.
      • This program taken together takes different averages of the touch position and a position relative to the adjustable nodes. But on average 100,100 down and to the right.
      • This has the effect of making the calligraphy effect bend with the speed rather than being locked at a static position, much like a real pen might.
  • Flail Ribbon", "G.3,1b2,10r4,-1s100,100l50,0G3,0f0"
    • #0, Gravity node, with speed. Set friction at 30% of typical.
    • #1, Back node. exact position of node #2, ten ticks earlier.
    • #2, Radial node, relative to node #4. At a speed of -1, making it travel counter-clockwise rather than clockwise. 
    • s100,100 scale the radial node by 100x and 100y, giving it a radius of 100 (this is the same as s100).
    • l50,0, move the radial node to the right by 50.
    • #3, Gravity node, slowing down 300% more than default. Tracking to node #0
    • #4, Finger node, first touch point.
  • Mirror", "f0a0L.5.5s-1"
  • Cycy", "a1,2L.5.5kr3.14159265s300rs100"
  • Cycloid", "r5s100f0a0,1d2"
  • Parallel Rake", "f0B0,10o1,0,90,100s.3ns.6ns-.3ns-.6D2,3,1,4,5"
  • Smooth Rake", "f0B0,10o1,0,90s.1ns.2ns.3ns-.1ns-.2ns-.3D2,3,4,1,5,6,7"
  • Speed Rake", "f0B0,10o1,0,90s.3ns.6ns-.3ns-.6D2,3,1,4,5"
  • 2-finger Rake", "f0f1o0,1,0s0ns.2ns.4ns.6ns.8ns1D2,3,4,5,6,7"
  • Star", "o5,6,0,100o5,6,72,100o5,6,144,100o5,6,216,100o5,6,288,100f0vL.5.5d0d2d4d1d3k5"
  • Triangle", "o3,4,120,100o3,4,-120,100o3,4,0,100f0b3,5d0d1d2k3"
  • Crescent", "o3,4,120,100o3,4,0,100o3,4,-120,100kf0B3,5"
  • Reverb", "f0b0,20"
  • Rereverb", "f0b0,20b1,20"
  • Track Reverb", "f0g0g1b0,10"
  • Trifill", "f0g2g3g1,0d1,2d2,3d3,1k3"
  • Expand 2nd Finger", "i2,3,3l-50,-50i2,4,4l50,50kf1f0l-50,-50f0l50,50"


As always, I'm open to new ideas. Do you want a random node that exists at a random location within a given range each tick? Think of some new way to arrange a patterned sequence of lines, that cannot be expressed as things are currently implemented?  Have some desire to see quintic bezier curves or n-controlled pointed curves? Think some format sequence should be valid when it's not? Do you have a really cool programmed ribbon and want it included in the next version? -- You can email me or share it in the Facebook group.