Turning a code grid into a stitch pattern

It’s been a while since I took a break from rewriting my basic instructions on turning words into stitch patterns. This is the next in the sequence; once I’ve written everything up, I’ll update the old version.

You might be asking yourself how to turn a code grid into a stitch pattern after choosing a layout.

(Charts only for this, because it’s about designing with charts.)

final chart for peace

The first and most obvious thing is that a black and white code grid looks very like a chart for colorwork. Go for it! Just keep in mind that more than five stitches in a row horizontally can be difficult because the strand is too long. Here’s an Interweave tutorial on managing long floats. An alternative from TECHknitter is the STUART method for dealing with long floats (this is a variation on the ladderback method).

Simple substitutions

Another possibility is to substitute a standard chart symbol for each black square. The simplest substitutions are chart symbols for stitches that take up only one square and which aren’t increases or decreases: purl dots, slipped stitches, and the like.

peace purl slip.png

Here’s the final version of peace from the previous page with the substitutions made for purl stitches and slipped stitches. This is actually a remarkably useful code grid: it doesn’t cause some of the more common difficulties for many stitches because there are no black squares directly above other black squares.

Here’s a code grid that would cause problems:

Peace method 4 7 columns v2.png

Do you see that vertical column of black squares?

If the black squares are converted to slip stitch symbols, it would mean that stitch 7 in row 1 would be slipped for three rows and wouldn’t be knit again until the next row 1. Now, this might be a good effect, depending, but it might not be what you want.

If the black squares are converted to purl symbols, it would make a short rib column and the stitches would draw together. This might or might not work in context.

In either case, swatching would reveal if this was a good effect or not.

Regardless, one way to avoid problems is to add a plain row between each encoded row. The slipped stitches now all have a plain knit underneath; the purl stitches become purl bumos.

Increases and decreases

Another name for this sort of stitch pattern is lace.

I usually substitute yarnovers for the black squares. The tricky bit is figuring out where to place the corresponding decreases. Sometimes it’s obvious; other times it requires a lot of swatching and trial and error. I’m not going to explain this process here on the blog.

Unless you’re comfortable with lace stitches on every row, it’s necessary to add alternating plain rows.

final chart for peace lace.png

This is the peace chart from above without removing the duplicated columns,  with the most obvious decreases added, and with the alternating plain rows. Really, this is a remarkably useful grid – it works for many different kinds of stitches. (Note that such a versatile grid doesn’t turn up very often.)

I haven’t yet knit a swatch from this chart, so it might change before it gets added to the final version of these instructions.

Hah! And indeed it did. In the end, this turned out not to work so well for lace; this is often the way. (The lace turned into creepy, grinning faces, which is all very well and good if you want creepy, grinning faces. But that’s not very peaceful to my mind.) This lace was made from the code grid labeled “Method 4, 6 columns”.

peace lace
Peace: a free lace knitting stitch pattern chart, by Naomi Parkhurst

Written instructions here.

Multi-stitch units:

What I think of as a multi-stitch unit is a common stitch pattern maneuver that takes up more than one square on a chart. For example, skyp: slip 1, knit 1, yarn over, pass the slipped stitch over. This takes up two spaces on an ordinary chart – it consumes two stitches and creates two stitches. That means it won’t fit in one black square on a code grid. It also needs alternating plain rows. Here’s how to deal with that sort of thing, first shown with a plain small checkerboard that isn’t meant to be a code grid.

The key is to figure out how many squares are needed for the stitch maneuver. Skyp requires two columns and two rows, so the key is to subdivide all the squares in the grid accordingly.

checkerboard skyp.png

The fake code grid is on the left: alternating black and white squares on a two-by-two grid. The subdivided version is in the middle: now the chart is four-by-four, but still has the same overall black and white pattern. The final checkerboard chart is on the right.

peace skyp.png

Here is the same peace chart from above subdivided, then turned into a chart with skyp. The red lines indicate the outlines of the multi-grid stitch.


Making basic cables with code grids is pretty straightforward: they’re multi-unit stitch patterns. I like to include purl columns as part of the unit.

peace 1-1 cable.png

Here’s an example of the peace chart from above with 1/1 cable crosses.


It is very occasionally possible to make complex cables that travel across the fabric like this. This is from the first peace grids I ever posted online. (I’ll be taking them down because the overall set wasn’t as good for explanations as the ones I’ve shown here.) However, I got lucky with that first one. I discovered later that it’s pretty unusual to have a code grid that makes that kind of cable work; I am therefore not going to explain the process.

Next up: swatches for the charts above. (Blog post in two weeks.)