Designing Weaving Drafts

A weaving draft has four linked components. Given any three, the fourth (or the resulting cloth structure) can be derived:

1. Threading – order in which warp threads pass through heddles on shafts
2. Tie-up – which shafts each treadle lifts (loom-specific; direct-tie-up looms skip this)
3. Treadling – sequence in which treadles are pressed
4. Drawdown – the resulting over/under pattern (the actual cloth structure)

Minimal Python example (plain weave, 2 shafts):

Python
import numpy as np
import matplotlib.pyplot as plt

threading = [0, 1, 0, 1, 0, 1, 0, 1]      # warp thread -> shaft index
tieup     = [[1, 0], [0, 1]]               # treadle -> shafts lifted
treadling = [0, 1, 0, 1, 0, 1, 0, 1]       # pick -> treadle index

def drawdown(threading, tieup, treadling):
    n_warp, n_picks = len(threading), len(treadling)
    draft = np.zeros((n_picks, n_warp))
    for pick, treadle in enumerate(treadling):
        lifted_shafts = tieup[treadle]
        for warp_i, shaft in enumerate(threading):
            draft[pick, warp_i] = lifted_shafts[shaft]
    return draft

plt.imshow(drawdown(threading, tieup, treadling), cmap='gray_r')
plt.gca().invert_yaxis()
plt.show()

Progress:

• Clarify loom type (shaft loom vs. tablet/card loom) and number of shafts/treadles or tablets
• Clarify goal: design a new pattern, convert an existing image/motif, or evaluate/choose a tool
• Define or derive threading, tie-up, treadling
• Generate drawdown and visually verify structure matches intent (twill, plain weave, block design, double cloth, etc.)
• Validate practicality (floats not excessively long, loom's shaft/treadle count respected, selvedge behavior)
• Export in appropriate format (WIF for physical looms, SVG/PNG for documentation, text draft for sharing)

Step detail:

1. Identify loom constraints first. Shaft count, treadle count, and tie-up style (direct vs. table loom with lever-per-shaft) determine what drafts are physically weavable. Tablet weaving has an entirely different model (card rotation direction/angle per pick, not shafts).

2. Choose representation. For algorithmic/generative work, use arrays (numpy-style) as in Quick Start. For interactive design, prefer browser tools (see Tool Selection below) so the drawdown updates live as threading/tie-up/treadling are edited.

3. Derive the missing component. Common cases:

   • Have threading + want a known weave structure (e.g., twill) → derive tie-up and treadling from the structure's standard pattern, then adjust treadling order for variations (herringbone, point twill).
   • Have a target image/motif → this is overshot/block-weave or jacquard territory; use block-substitution methods or a parametric tool (AdaCAD) rather than hand-deriving.

4. Check floats. A float is a thread that skips over/under more than ~3-4 adjacent threads without interlacing. Long floats weaken cloth and snag. Scan each row/column of the drawdown for consecutive same-value runs; flag anything beyond the weave structure's typical max (satin structures intentionally allow longer floats, e.g. 4-7).

5. Export. WIF (Weaving Information File) is the de facto standard for physical floor looms and is supported by Weave Patterner and little-loom. SVG/PNG suit documentation or tablet-weaving card diagrams.

Example 1: Input: "I want a 2x2 twill herringbone draft for 8 shafts." Output: Threading in point-twill order [0,1,2,3,3,2,1,0] repeated, tie-up as standard 2x2 twill rotation [[1,1,0,0],[0,1,1,0],[0,0,1,1],[1,0,0,1]] per shaft-group, treadling mirrored to match threading direction (ascending then descending) to produce the herringbone chevron. Drawdown rendered with matplotlib, verified no float exceeds 2 threads (correct for 2x2 twill).

Example 2: Input: "I have a scanned image of a motif and want it woven as a block design." Output: Recommend converting the image to a binary block map first (quantize to light/dark regions sized to realistic block counts for the loom's shaft count), then use AdaCAD or a block-substitution script to map blocks to threading/treadling units — not a direct pixel-to-thread conversion, since floor looms can't resolve arbitrary resolution.

Example 3: Input: "Which tool should I use to just try out tie-up changes quickly?" Output: Weave Patterner — no install, live drawdown updates as you click tie-up cells, WIF export when finished.