James Dalessandro

This piece came out of a week spent building a system for exploring turmites, or generalized Langton's Ant: little 2D state machines walking across a grid, reading pixel colors, changing them, updating their own internal states, and moving according to a rule table.

The system supports multiple turmites, shared or individual rules, different movement neighborhoods, different state kernels, multiple cell and turmite states, absolute and relative movement modes, and more.

This specific image is the result of over 1 million simulated steps from 4 turmites interacting with each other, their own trails, and the grid itself.

Each pixel in the simulation became one plotted dot, so the final drawing contains exactly 172,788 individual dots.

These works came out of a custom curl noise system I wrote in C#. I had to learn a bit more about derivatives than I expected.

The curl noise vector field determines where each trail wants to go, while the circles handle the collision logic. Since circles are each to distance-check, and even easier to speed up with spatial partitioning, the system ended up being surprisingly flexible. I can adjust the noise scale, time, min/max radii, trail length, radius growth, and a bunch of other parameters to get very different kinds of outputs.

The last step was converting each list of circles into these squiggle paths. That converter could still be better, but watching the plotter draw these little flowing tube forms is extremely satisfying. Pretty happy with both the system and how these pieces came out.

Usually with circle packing, the goal is to make circles tangent to each other. But if you keep increasing the radius of each circle while constraining everything inside a boundary, different pattern phases start to emerge when you visualize the circle centers as a voronoi diagram.

The circles slide and stick against each other under pressure, forming regions that shift between hexagonal arrangements, square grids, pentagonal strips, triangular clusters, and back again. The results look surprisingly similar to metal grain boundaries or crystal growth, with local structures forming and reorganizing as the system is compressed and relaxed.

What's especially interesting is that a simple pressure-based circle packing system can begin to visually echo metallurgical processes like quenching. If we advance the system into a new phase, then relax it slightly, larger chunks of ordered structure are able to form.

This was simulated with Kangaroo physics in Grasshopper, building off work by Riccardo Majewski.

Another piece stemming from the same Grains algorithm, but this time as a two-layer plot. The reddish pink layer runs horizontally, and the sky blue layer runs vertically, with each one driven by a different pixel configuration/simulation. Both simulations were paused and exported after 10 frames, and unlike the earlier checkerboard-based versions, these started from concentric circles. As the two plotted layers overlap, different regions build up different amounts of ink, producing shifts between pink, purple, and blue across the piece.

Another variation built from my Grains algorithm. I started with an 8-color palette and treated each pixel color as its own state, then mapped every state to a unique tile of horizontal lines. Different areas of the pixels were shifted, stretched, and compressed using a mix of 1-layer Moore neighborhood, 16-direction neighborhood, and 2-layer Moore neighborhood rules. After that, adjacent segments were joined into longer continuous paths to make the drawing more efficient for pen plotting. Total plot time was about 5 hours.

Blocks IV is the fourth piece in this series of generative pen plots built from 3D signed distance fields. Each wood block starts as a rectilinear volume with its own grain axis, and the contour lines come from taking progressive offsets through that field and slicing it against the visible faces. I then project the 3D geometry to an isometric camera plane, map it to the XY plane, and pack the forms across the page for a dense composition. Each face is hatched at a different density to attempt some marker shading, then I swap pens to add the heavier outlines.

These AD markers still smell exactly like I remembered... terrible!

This work starts with a DLA-like growth process, but in a more inverse form. Rather than sending circles inwards from outside the accretion, I try branching circles off circles that are already part of the structure. Each branching level is scaled down towards a minimum radius, continuing on until all available space is exhausted. Finally, a nearest neighbor search identifies pairwise adjacent circles, which allows me to generate trimming geometry that gives it a chain-like aesthetic.

This work uses two different CA rules plotted in pink and sky blue, and it also uses a drawing method I've been experimenting with lately: colorless markers dipped into ink instead of ink-filled pens. This time, the plotter is programmed to re-dip ever ~1500mm of total drawing distance, so the ink fradually fades until the distance drawn reaches that threshold, then resets and continues.

With two overlaid layers, I think it produces some nice qualities... Transparencies, changing saturation, and different color interactions depending on how much ink each marker was carrying at that moment.

This piece begins with simplex noise displacement, forced into a discrete vector field so the curvature resolves into stepped directional changes. Points that fall below a minimum displacement threshold are re-projected onto the original curves, which keeps some areas constrained while still allowing large scale deformation.

The largest white spaces by area are then filled.

Exploring pixel sorting through the slow process of drawing each pixel.

So much red ink went down on this one that the paper started curling and warping as it plotted. It took around 5 hours of dense, saturated passes to get there.

This idea didn't quite translate from what I imagined to the page. Some layer misalignment, a stray blue scrape, and I left too much white space.

It is built from three layers of 1D cellular automata, one per color.

This is a generalized Hilbert curve, split every ~3500mm to re-dip the marker so each segment fades out as it draws.

Those fades start to reveal patterns in the curve that would otherwise be hidden.

The hard part is controlling the ink level. I'm constantly adjusting it with an eyedropper depending on how long the next curve will be.

Experimenting with dipping colorless markers into ink. To achieve a good gradient with this technique, I've found its all about controlling the amount of ink vs the length of the path drawn.

I was thinking of RGB LCD screens when I made this one.

I've done multi-layer cellular automata plots in this style before, but this time I offset both layers so they have their own columns.

I added multiple states to this 3D subdividing cellular automaton. As with many cellular automata, more states doesn't necessarily mean more interesting structures. It often just introduces more chaos and noise, which is what happened here to some degree.

This is a 4-state system: state 0 is transparent, and each non-zero state gets its own color.

After the simulation, I isolate the largest connected voxel region (ignoring states). That can sometimes end up removing a lot of voxels, but I'm only doing that while I work on my rule evolver which will help find rules that naturally result in a single fully connected voxel region.

This work is part of 3D subdividing cellular automata techniques that I've been developing for the past few years. It starts as a single cubic cell; with each iteration, cells subdivide, resulting in a single fully connected voxel region.

These are always quite difficult to get good results from due to the rule spaces being unfathomably large, so you have to also make some method of exploring/evolving interesting rules automatically.

Each of these is around 1-3 million voxels.

Custom extended-neighborhood 1D cellular automaton, used to generate a network of edge loops that are traversed to form cyclic paths. The longest resulting path is identified through a distinct color.

Bitonic sort turns a random list into an ordered list by repeatedly building and merging bitonic sequences (sequences that increase then decrease). Here I have visualized each iteration by connecting the points we sort with a curve.

I was experimenting with CMYK process color workflows. CMYK plotting is tough because it is really hard to digitally visualize how the final result will actually look. Usually I don't put enough ink on the page to get a good result... They're not all gonna be winners.

I stopped this one after only a few iterations, because I love how you can still see bits of the initial checkerboard throughout the composition.

Plotted the grains algorithm. Starting from an initial configuration of concentric circles, pixels are shifted, stretched, and squeezed. Then adjacent pixel coordinates are connected into lines, which are joined consecutively into larger lines and simplified. Then plotted with a 1mm Rotring Isograph. Somewhere around 18k little lines even after joining...

Now the grid cells themselves slide around as well.

Rather than all grain movements being dictated by global noise values, we have discretized the noise into (invisible?) grid cells, each quantized to either a single direction or a per-cell noise function. Grid cells themselves are static but the noise within them animates over time.

Pixels move like grains of sand, pushed around and swept up, shrunk and stretched until nothing of the original pattern remains.

A branching angle of 80 degrees makes numerous, shard-like slivers. It is a testament to how robust the line-line intersection algorithm is that no intersections were miscalculated.

I am realizing this base algorithm is a good starting point for many other algorithms. I spent improving performance, order of magnitude speedup. Now does 2k lines in ~200ms.

Sometimes really simple algorithms are worth revisiting.

The Voxel Automata Terrain algorithm grows a dyadic voxel grid in coarse-to-fine passes, filling cube midpoints (center, face, edge) through a fixed neighborhood rule and a tiny optional state permutation for variation. A 2D seed grid biases growth upward into plateaus, struts, and voids; the result is complex yet interpretable topology from repeated multiscale local rules.

I see similarities to certain forms achievable by 3D subdividing cellular automata, like Driessens & Verstappen's "Breed" (1995-2007), but there is no subdividing here, only a similar scale change per iteration via what voxels are visited in the grid.

This was a tough algorithm to wrap my head around... but now I feel I have a good understanding, and I love the results in form it can create, so I will be exploring variations on this. One thing that comes to mind is rule evaluation with simulated annealing to encourage fully connected voxel regions.

Matter conversion outpost on a remote planet. I stole the Toa Heavy Industries logo from BLAME!

I love using Magicavoxel. It is one of the best quality free pieces of software I've ever used (besides Blender), and every time I come back to it is a joy. I can and do spend hours in this program...

255x256x512, ~5-10 million voxels each. Generated with Three.js, rendered in Blender Eevee

Not sure if I like this algorithm better with or without the blue. But it reminds me of terraced cliffs with pools of water

2 layer custom 1D cellular automata plot I did in a different style than usual

This time 9 layers, took about 6-7 hours...

I modified my p5js bitfields project to output to a CSV of palette color indicies at every grid cell. GH + C# to combine cell regions, connected ends hatching code is still a WIP but it worked well here, and streamed the gcode to my iDraw with my plugin, iDraw_GH. Tombow markers, 5 layers. I just dumped all my markers out and compared them to the colors on the digital palette and picked the closest ones, worked great I think.

This algorithm assigns colors to pixels through bitwise operations and modular arithmetic based on each cell's (X, Y) coordinates. Some cell states are transparent, allowing multiple multi-scale layers to visually interact and form intricate patterns remniscient of 1D cellular automata. Color palettes sourced via the Lospec API, matched to each output's number of visible cell states.

Changes to the PRNG, box generation, packing algorithm, and line weights.

Changes to the PRNG, box generation, packing algorithm, and line weights.

Computer controlled pen on paper

Petri Dish is a project presented by Plottables, in the form of 128 generative pen plots. Each mint becomes a collaboration between the artist and the collector, as they run their pen plotter to draw the art. Anyone who has a plotter knows that what ends up on paper depends so much on speeds, inks, pens, paper - all choices that I as the artist am no longer solely in control of.

Lacunae is a sold out collection of 111 generative artworks, presented by Art Blocks. The code lives immutably on the Ethereum blockchain. Minting was executed through a smart contract.

CORALYTE is a site-specific installation that creates a spatial experience that changes as you move through it. Inspired by skeletal remains of coral polyps, CORALYTE is over 13 feet tall and 17 feet wide, with internal voids in the branching structure large enough to fit your body through. The proportions of CORALYTE were designed to bring a first person experience of coral to the human scale.

Computationally designed and digitally fabricated, the structure is laser cut from 146 sheets of bristol paper, and is held together without the use of glue or tape, only binder clips.

Starting from a line network where each intersection node was at most valence-3, we were able to apply a clean topology mesh skeleton. This let us vary the weight in warp and weft directions on the mesh for the minimal surface formfinding simulation, which was key in keeping the cross-sections of every subassembly near circular, another important factor for rigidity.

Once the form was finalized, it was remeshed into triangles with a target edge length of 4 inches, which allowed us to discretize the mesh into strips for fabrication.