How it works

This page aims to give an overview of some of the theory of overshot weaving, and how this site uses it to generate patterns. This explanation assumes a 4-shaft loom for simplicity, but similar principles apply to more complex looms.

Overshot threadings

The characteristic feature of an overshot pattern is that the threading sequence alternates between even and odd shafts, allowing tabby (plain weave) to be woven by alternately raising shafts 1 & 3 and 2 & 4. Here is an example of an overshot threading sequence:

1  2  3  2  3  4  1  2  1  4

One way to record the information in an overshot threading sequence is just to write down this list of numbers. However, this method has some disadvantages for the purposes of generating patterns with a computer.

The sequence must alternate evens and odds, so we can't just choose any numbers we want in any order.
Information about the weave structure (e.g. lengths of floats) is hard to tell (at least at first glance).
It is not a unique way to get a particular weaving pattern. For example, if we add 1 to all the numbers (thinking of 4+1 as looping back around to 1), we get a new threading sequence:
```
2  3  4  3  4  1  2  3  2  1
```
And if we change the treadling or tie-up in a similar way, we can use this new sequence to weave exactly the same cloth.

Fortunately, there are other, more useful ways to think about overshot threadings.

Pairs

Look at all the pairs of consecutive threads in our threading sequence:

1  2  3  2  3  4  1  2  1  4
 \/ \/ \/ \/ \/ \/ \/ \/ \/
 12 23 23 23 34 14 12 12 14

Because of the even / odd rule, there are four options for each pair: 12, 23, 34 and 14. Depending on which shafts are raised, each type of pair can produce a small patch of solid pattern (if both shafts of the pair are lowered and the pattern thread floats above the ground cloth), solid background cloth (if both shafts of the pair are raised and the pattern thread hides below the ground), or a half tone (if one of the shafts is raised and the other lowered, and the pattern thread weaves in and out).

This viewpoint gives us a different way of recording an overshot threading: write down all the pairs of threads.

12 23 23 23 34 14 12 12 14

However, this method has some disadvantages as well.

If we're inventing a sequence, we still can't choose whatever pairs we want in any order. Any two consecutive pairs have a thread in common, so, for example, we can't have a 12 pair immediately followed by a 34 pair. The restrictions are a little more complicated than that, though — for example, this sequence is invalid, even though all consecutive pairs have a thread in common:
```
12 23 12
```
Since the first two pairs are 12 and 23, the threading sequence has to start 1, 2, 3. Then the next pair must use a 3, so it can't be 12.
It's still a little hard to see information about floats, and this method still doesn't give a unique encoding of a given weave structure.

Block sizes

This brings us to perhaps the most useful way to think about overshot threadings: block sizes. If the same type of pair appears multiple times in a row, those pairs form a block. To determine the list of block sizes, start with a threading sequence, and read off the pairs. Then, count how many of the same pairs appear in a row.

1  2  3  2  3  4  1  2  1  4
 \/ \/ \/ \/ \/ \/ \/ \/ \/
 12|23 23 23|34|14|12 12|14
 1 |   3    |1 |1 |  2  |1

The resulting list of numbers is the block size encoding.

1, 3, 1, 1, 2, 1

Turning a list of block sizes back into a threading sequence is a little tricky, but can be done. Here's how to turn this list of block sizes back into a threading sequence.

First, we get a free choice for the first two threads in the sequence (provided they satisfy the even / odd rule) — this overshot generator site always uses 1, 2. This choice determines what the first type of pair is — it's a 12 pair.

1  2
 \/
 12

Since the last thread used in the sequence so far is a 2, the next thread has to be odd, so it's either 1 or 3. One of these choices, 1, would mean the next pair is the same as the previous one (12), and the other choice, 3, would mean the next pair is different (23). Since our example list of block sizes starts with 1, and we've already had one 12 pair, the next pair must be different, so the next thread is 3, and we get a 23 pair.

1  2  3
 \/ \/
 12|23
 1 |

After this 3 thread, the next thread must be even, so it's either 2 or 4. Choosing 2 means we get a second 23 pair, and choosing 4 means the next pair is 34. Since the next block size in the list is 3, and we've only had one 23 pair so far, we must take another 23 pair next, so the next thread is a 2.

1  2  3  2 ...
 \/ \/ \/
 12|23 23  ...
 1 |

And we keep going like this. At each step, depending on the previous choice of thread, there are always two options for the next thread: one option gives us a new type of pair, and one continues with the previous type. So, we can check whether we've used the previous type of pair enough times yet, according to the block sizes list, and make the choice accordingly.

Here are some advantages of the block size encoding method:

The block sizes can be any numbers we want, in any order. (This means they're easy to randomly generate!)
The sizes of the blocks reveal useful information about the weave structure: for example, a block size of N produces floats of length N+1. So, if you don't want to have any floats longer than length 5, say, you can just pick block sizes between 1 and 4.
A given list of block sizes doesn't uniquely determine the threading sequence, since you can choose the first two threads however you want and get different threading sequences. However, these different sequences will produce the same weave structure (depending on the choice of treadling and tie-up).

There is still one drawback of the block size method. The corresponding threading sequences are fine in isolation, but you might not be able to repeat the sequence to get a repeating pattern (since the first and last threads might be both odd, or both even). To avoid this issue, this overshot generator doesn't repeat the sequence, but instead mirrors it to produce a symmetric pattern, which can then be safely repeated.

1  2  3  2  3  4  1  2  1  4  1  2  1  4  3  2  3  2
                       <-- | -->

Treadling

Once we have a threading sequence, the other key ingredient for a weaving pattern is the treadling.

There are two popular methods to convert an overshot threading sequence into a treadling sequence called "star" and "rose". Once we have a list of the adjacent pairs of threads, the star and rose methods are fairly simple. For the star method, read through the list of pairs, and convert each into a treadle using this rule:

Pair	12	23	34	14
Shafts lowered	12	23	34	14
Shafts raised	34	14	12	23
Treadle	1	2	3	4

The treadles we're using correspond to the standard 2/2 twill tie-up for a sinking shed loom. For a rising shed loom, this standard 2/2 tie-up must be inverted (turn each tie into a non-tie and vice versa).

The rose method is similar, but using this conversion rule (it's the same but with the treadles reversed):

Pair	12	23	34	14
Shafts lowered	14	34	23	12
Shafts raised	23	12	14	34
Treadle	4	3	2	1

For both of these treadling techniques, overshot also requires you to add alternating tabby picks (shafts 1 & 3 and 2 & 4) between each pattern pick, to get a stable cloth.

An alternative treadling method is "tromp as writ" or "treadle as written" — for this method, the treadling sequence is simply the exact same as the threading sequence. Just like with star and rose, you can also vary this method by reversing the order of the treadles. Tromp as writ usually works fine without tabby (although you can use tabby if you wish).

All of these treadling methods can be further modified with a parameter that this pattern generator labels "treadling offset": this number is added to the number of each treadle (with numbers past 4 looping back around to 1).