For my current master's I've been fucking around with these nifty older machines called 'pen Plotters'. In essence, these machines draw based on given instructions sent over a COM port. It is janky, imperfect, surprisingly precise, and I absolutely love it.

One of the first results from experimenting with this hardware were these things called lenses; a number of increasingly small/large circles with variance in how filled in they are. They are visually appealing (to me atleast) and might make for a cool tattoo someday I think, as have a surprising number of people also said.

Here I found that the results from a pen plotter arent quite digital and not quite analog, but an interesting inbetween. It's clearly drawn, you can see where the pen is picked up and placed down and it bleeds in a very hand-written sort of way, but it is mechanically precise like how a modern printer would be!

I saw a lot of potential in this for making interesting graphics, textures, whatever honestly. and so I set out to mess around with it more, especially with writing python scripts that help generate the instructions necessary to make things like these efficiently, and also, semi-randomly generated.

import random # cuz im a widdle wandom :3c

lineType = 0
lineLength = 0

print("rows")
rows = int(input())
print("columns")
columns = int(input())

print("spacing")

print("x coord")
xCoord = int(input())
print("y coord")
yCoord = int(input())

print("how many cirgle per lens")
circles = int(input())
print("starting radius")
radius = int(input())
print("how many spacing betwwen cirgles")
gap = int(input())

print("naem of fiel (will add .hgl)")
filename = input() + ".hgl"
file = open(filename, "w")

file.write("IN;\n")
file.write("SP1;\n")
file.write("PU" + str(xCoord) + "," + str(yCoord) + ";\n")
file.write("LT;\n")
file.write("CI" + str(radius) + ";\n")

for y in range(0,columns):
for z in range(0,rows):
for x in range(0, circles):
lineType = random.randint(1,6)
lineLength = random.randint(1,5)
radius += gap

file.write("LT" + str(lineType) + "," + str(lineLength) + ";\n")
file.write("CI" + str(radius) + ";\n")

file.close()

sample script to generate instructions for a set number of lenses in a grid with set and/or randomized variables

Side tangent: fractals! they are very cool, and using Python it's possible to generate a set of instructions for a pen plotter to draw them! You simply specify the start and end point of the first branch and go from there, creating in this case a binary tree fractal, much like the one you can see on the right here >>>>.

But what if you introduce randomness?

Well then you have a lot of variables you can mess with, for example what if you randomize the branch angle between two set thresholds, and do the same with the ratio? Turns out you end up with very organic-looking tree structures! Example below vvvvvv.

Depth: N/A but probably 15 or so; angles: randomized between 10 and 60 degrees; ratio: randomized between 0.5 and 1;

def tree(x1, y1, x2, y2, angleLeft, angleRight, ratio, depth):

# this line makes this function halt when it finishes doing the set amount of recursions
if depth == 0: return

# write the instructions for the current line to the .hgl file
file.write(f'PU {round(x1)},{round(y1)};\n')
file.write(f'PD {round(x2)},{round(y2)};\n')

# set the next two branches' starting position and rotations
base = np.array([x2 - x1, y2 - y1])
new_base = base * ratio
right = rotate(new_base, angleRight)
left = rotate(new_base, -angleLeft)

# set the end position of the two next branches
end = np.array([x2, y2])
right_end = np.add(end, right)
left_end = np.add(end, left)

# call this function again using the newly established variables, this time deducting 1 from the depth to count one recursion as done
tree(x2, y2, right_end[0], right_end[1], angleLeft, angleRight, ratio, depth - 1)
tree(x2, y2, left_end[0], left_end[1], angleLeft, angleRight, ratio, depth - 1)

the function that generates branches recursively, based on a buncha variables

These explorations made me interested in generative art, not the evil swimming pool-evaporating kind, but the tuneable kind, which I can hopefully do more with in my coming project(s)! First up has been a browser extension called Webby Sprouts, which takes the open webpage's DOM and turns it into a tree fractal; visualizing the bones of a website.

Turns out: a lot of websites have a sort of finger print, their DOM is visually distinct to a certain extent! The Facebook Fan, Bluesky Reed, Itch Twins, it's cool poster material, and it can become a fun toy in and of itself I think.

And yes, every single branch is an individual div, rotated and sized based on its parent div, so in the DOM it's also a fractal in a dropdown kind of way, fucking SUE me Jana!!!!!!

So what now? I'm going to finish up the Weeby Sprouts browser extension to make it more customizeable, more fun, more playful! After that who knows, maybe do this stuff in 3D?

The famed Bluesky Reed

Pen Plotters, Fractals, and Other Whimsical Tangents