A few punctuation marks and, somehow, an embroidery machine

///

I turned three or more forward slashes into a racing-inspired system that makes both a digital artwork and the embroidery file for a physical version.

It starts with three or more slashes, then you notice the controls, the 15-thread limit, the cuts, and all the production logic hiding underneath.

Project 09 of 11work / collaboration
/// #0: minimal racing-inspired slashes built from embroidery-ready thread paths.
/// #0View live
Released
Oct 11, 2023
Format
Generative artwork + DST embroidery file
Edition
2,000 artworks
Platform
Art Blocks / Ethereum

The Idea

The algorithm places every stitch

/// was my first algorithmic embroidery project. Not an image that gets sent off and digitized later. The code decides where the needle goes, when it moves without stitching, when thread gets cut, which needle comes next, and then it writes the DST file itself.

I am really proud of that part. The digital artwork and the machine file grow out of the same set of decisions, so the physical constraints are not somebody else's cleanup job at the end. They are in there from the first line of code.

This became another strong proof for what we started calling Generative Goods: the output is not only something to look at. It knows how to become a thing. In this case a pretty serious embroidery machine can read the artwork directly, which still feels a little ridiculous in the best way.

Every Needle Drop

Fill stitches, underlayment, borders, travel moves, and cuts are all generated by the artwork. There is no bitmap-to-embroidery conversion step afterward.

A 15-Needle System

The thread order is fixed so a production machine can move from one output to the next without being rethreaded every time.

Three By One

The embroidery field starts at three inches wide by one inch tall. The racing mark is small; the production system underneath it is not.

DST Comes Straight Out

Press D in the live artwork and its own code assembles the Tajima command stream and downloads the machine-ready file.

From hash to hoop

The stitch plan is the artwork too

The screen view is only the finished surface. Each colored line belongs to an ordered run that the machine can actually sew.

01 / Build The Mark

The hash chooses the angle, arrow logic, slash widths, spacing, and one of five racing-ish types.

02 / Put Down A Foundation

The algorithm generates underlayment first. Those hidden stitches stabilize the fabric before the visible color goes on top.

03 / Route Every Color

Fill and border stitches are grouped into ordered runs across a fixed 15-thread machine setup, including travel and cut logic between areas.

04 / Write The DST

The same browser artwork encodes those relative needle moves, color changes, jumps, and the end command into the binary file.

The embroidery lab

Make one. Then watch the file sew itself.

This is the original /// renderer. Open this exact artwork on slash.snowfro.com. The simulator asks that same code for its DST, reads the machine commands in your browser, and draws them back in stitch order.

/// #0

This output

/// #0

Find another one

Mess with the live artwork

///

The stitches will show up here.

DST simulator

This is what the embroidery machine gets.

Pick an artwork, then make its stitch file.

Five ways through a corner

The type changes the whole posture.

They all start with the same dumb little mark, which I mean affectionately. Angle and arrow logic turn it into five families. Color and border systems sit on top of that, so two artworks with the same type can still feel nowhere near each other.

Chicane example, /// #0
486 / 2,000

Chicane

A slower bend with an arrow-like turn.

DRS example, /// #1
452 / 2,000

DRS

The quickest, most stretched-out line through the system.

Straightaway example, /// #2
449 / 2,000

Straightaway

Slanted slashes moving together in a steady direction.

Fast Corner example, /// #6
493 / 2,000

Fast Corner

A sharper turn that feels like it is already leaving the frame.

Grid example, /// #51
120 / 2,000

Grid

The rare flat-angle version. Less corner, more starting grid.

Twelve color systems

The names describe how thread moves, not just a palette.

  1. Two Color Gradient275
  2. Long Gradient258
  3. Short Gradient214
  4. Solid Single Color206
  5. Random Color Split201
  6. Solid Gradient Colors181
  7. Alternating Solid Colors179
  8. Solid Random Colors155
  9. Two Color Split103
  10. Patchwork172
  11. Hyper Single26
  12. Hyper All30

The machine was in the room from day one

I did not want somebody tracing a picture later

Most people meet machine embroidery through a picture and a separate digitizing step. Somebody has to decide stitch direction, density, underlayment, cuts, color order, all the unglamorous stuff that determines whether the thing actually sews well.

I wanted those decisions inside the generative system. If the algorithm made a weird little turn, it also had to solve how the needle would make that turn. The visual rules and production rules had to argue with each other while the artwork was being born, not after.

Fifteen needles, twice around

Color has an order because the machine has an order

The production machine was loaded with navy, the bright spectrum, white, and grey in a fixed sequence. The algorithm builds the interior passes first, then comes around again for the borders. Unused slots still have to be handled so the next artwork does not require everybody to stop and retool the machine.

That is not especially romantic copy, I know. But it is exactly the part I love. A color choice in the artwork also has to be a workable instruction for a physical machine.

  • Underlayment stabilizes the fabric before the visible fill
  • Fill stitch length is generated at roughly 1 mm
  • Color channels are ordered for a 15-needle production setup
  • Borders are routed after the interior stitch passes

It is not only the calm little preview

The live artwork has a racing brain

The static image looks very well behaved. Press Enter and it gets less well behaved. Noise, finish lines, outlines, dark backgrounds, and lonely mode pull out different pieces of the system.

Lonely mode is the intended way to view the artwork on a screen. It keeps the whole composition, with all of its slashes, but makes everything much smaller and sits it near the bottom with a ridiculous amount of open space above it. I often felt lonely while navigating everything that happened over the years, and honestly I still do sometimes. I could not use that as the default artwork render because most of the preview would have looked blank and people would reasonably assume it was broken.

Then D does the most important trick: it asks the artwork to stop being a screen thing for a minute and hand you the embroidery file it already knows how to make.

  • Enter — party mode
  • N — noise
  • Space — switch the background
  • O — outline view
  • F — finish line
  • L — lonely mode: the whole composition, much smaller and bottom justified in a lot of open space
  • D — download the DST embroidery file

Where this fits

The physical idea was already moving

Friendship Bracelets came first and really seeded this idea for me: a digital artwork could also tell you how to make something physical. Heart + Craft released before /// too, and pushed the same thought into fabrication files and an object you could build at home.

Heart + Craft and /// came out less than seven weeks apart, so I am not going to pretend the influence only moved in one neat direction. /// took the question into embroidery, where every output could leave the browser as a machine-readable file without another person redrawing it. That became another Generative Goods proof and fed into later work like LIFT.

Go Look Around

Go make the machine file

Load an artwork in the lab, press the controls, and ask it to build its DST. The panel above handles the artwork lookup for you and is probably the easiest way to explore. If you do use the original renderer directly, ?id=100 opens /// #100; the full token ID ?id=2000100 works too.

01View the collection on Art Blocks02Read the Red Bull collaboration announcement

Dates

A few dates

  • 2023-10-11Release / first mintsourced
  • 2023-10-17Art Blocks activationcontext
  • 2023-10-25Last mintcontext

Provenance

On-chain details

  • Art BlocksEthereum0x8cdbd7010bd197848e95c1fd7f6e870aac9b0d3c

In The Bigger Picture

Where this one goes

Surface
Slash/racing image
Deeper Layer
Controls, thread limits, cuts, layer order, and the actual embroidery file
Builds On
Friendship Bracelets' physical-from-digital seed, Heart + Craft's fabrication logic, and my weakness for extremely simple marks
Sets Up
The cartridges, boxes, embroidery, and other generated objects inside LIFT

Sources

Where this came from

These are the public links I used to check the dates and details. A few of them also have much longer versions of the story.

Official / primary

  • Art Blocks collection
    official projectprimary source

    The official /// reference for project facts and public links.

  • Art Blocks API docs
    official docprimary source

    Official documentation for /// mechanics and technical context.

  • NFTNow feature
    press profile

    Additional Official / primary context for ///; primary sources carry the core facts.

  • Oracle Red Bull Racing announcement
    official projectprimary source

    The official /// reference for project facts and public links.

Marketplace / provenance