I’ve been plummeting down a rabbit hole of my own making, but I think I finally have enough figured out that it’s worth blabbing about. This is a work in progress (just like everything else), and it’s still a ways off from being “usable,” but I think I can show you what my intention is and have it make sense. Maybe.

The idea for this project comes out of the ongoing desire to go to in-person events (like, say a maker convention) and host a collaborative activity of some kind. I want to show up somewhere, do something weird, and facilitate an enjoyable experience for whoever might be interested. The activity itself isn’t as important to me as the effect it has on the participants, but I want it to be fun and engaging, I want to encourage people to work together, and I don’t want to have to charge people money to join in. 

So all that being said, I’d like to introduce you to my current undertaking:

Place Words

The premise is pretty simple: I want to put all of the words together into a single giant crossword-style construction, and I want to get strangers to do it for me. I want to have a handful of little electronic devices of my own making and have them available for people to interact with. The device would present the player with a handful of words and ask them to place those words into the in-progress word structure. And then they’ll earn points and I’ll rank everyone on a leaderboard because what’s wrong with a little motivation?

And I do mean all the words. I’m not worrying about proper nouns or things like that, but I do want this thing to be massive. I found an open-source word list (because the Scrabble list is copyrighted), and it’s about 170,000 words total. 

I also want to use this project as an excuse to learn more about Arduino/Raspberry Pi sorts of things, so part of my design goal is to use the cheapest/simplest hardware that I can. After looking at the various devices that are available these days, I settled on the RP2040 microcontroller. It’s new enough that I figure it still has decent support, but old enough that a lot of people have used it for a lot of different things. And it’s not a “computer” in the traditional sense: there’s no operating system or desktop environment or anything like that. You just write your code and load it up, and the device runs exactly what you programmed and nothing more (aside from a truckload of libraries and such).

To be more specific, I’m using RP2040 “feather” from Adafruit, because their feather devices are built for small/portable applications. They even have built-in battery charging circuitry. You just plug a battery directly into the board, then you can plug the board into a power source with the USB-C port and it automatically charges the battery without the need for extra components.

With that core concept and a hardware platform picked, we’ve already reached our first technical hurdle: how are we going to fit a 170,000 word crossword into the RP2040’s 264 KB of RAM?

Yeah, that’s not a typo. We have a quarter of a megabyte of RAM to work with. There’s 8 MB of flash storage, but that’s just for holding the code itself. Everything that the device does at runtime has to fit into that 264 KB. For context, the list of words itself is almost 2 MB. 

So clearly we aren’t going to be holding the whole game board in RAM at once, which means we need a way to store the board as we go. Which we probably needed anyway, since there’s no way this is getting done in one sitting. We’ll need a way to store a game state, turn off all the devices, and then restart the next day (or whenever) from where we left off.

We also won’t get anywhere if there’s just one physical device that people take turns with. So we need a host device that is controlling the game state and communicating with some number of client devices for players to use.

All that taken together gives us a nice parts list for our devices, and my first job was simply getting all that hardware working together. Here’s a diagram of where I ended up:

The RP2040 is a dual core chip, which allows for a convenient division of labor. One of the cores is dedicated to the communications with other devices (either host to client or vice versa), and the other core does everything else. We’ll need a radio to send/receive messages, we’ll need an SD card reader to save/load our game state, and the client will need a display screen and some buttons to make it usable for a player.

How hard can that be?

A hell-out approach

Many of you will be familiar with the concept of integration hell. If you develop a number of different systems (hardware/software/anything really) separately from each other, it can be legendarily painful to get those things working together in the end. So I figured it was best to deal with the integration hell part first. If I could just get all the hardware playing nice, with host-to-client communications and drawing to a screen and reading/writing with an SD card and taking button inputs and using all of that together in the same piece of software, then the rest of the game could just be built on top of that foundation and I wouldn’t have to worry about what might go wrong when I plug everything together later.

I was initially planning on using Python for this project. My reasoning was simple: I’ve used Python before. I’m no expert but I at least had some familiarity. In the past, the downsides of using Python haven’t mattered to me, but there’s one big drawback that we can’t really escape here: Python doesn’t really do that whole “dual core” thing. 

And that… stinks. That’s just half of the power of the RP2040 gone before we write a single line of code. It would also mean putting the radio communications and everything else on the same core, competing for priority. You could potentially miss out on a radio message while writing to the SD card, or drawing to the screen, and then you have to ask for a re-transmission, but you might miss that too, and things get messy fast. 

Which means we’re using Arduino code! This comes with a lot of benefits! We can efficiently divide our labor between the two cores, and we can be more precise about how we use our limited RAM space. Hooray! 

Uh oh

The downside: I’ve never written Arduino code before. Or anything in the C family of coding languages (Arduino is basically C++ with some stuff). I’ve never even tried.

Maybe that was a good thing as well, because it meant that I didn’t entirely know what I was getting myself into. 

I could write a couple paragraphs here about the painful process of learning about pointers, but let’s skip that part. I get how it works now but geeze.

Also the fact that you can just bulldoze over your own memory if you’re not paying attention kind of blows me away. I get how it works now but geeeeeeze.

What’s maybe more interesting is an issue I ran into with the hardware itself. I thought I was being smart by getting a pair of RP2040’s with built-in radios, instead of buying those two things separately and wiring them together. It’s a little cheaper and saves some work. Win-win, right?

I also got a screen that has a built-in SD card reader. Again, less wiring for me, hooray.

All of this was working fine right up until the point where I tried to get the SD card working in conjunction with everything else. Both the radio and the screen/card reader are SPI devices. The RP2040 can have up to two SPI devices. Should be fine, right? But when it came to actually assigning these two devices to their respective lanes, things started getting screwy. 

I still don’t fully understand the issue, but I did eventually find a support thread on the github page for the “core” (which is like the firmware) I was using where someone else faced a similar issue. They were using an RP2040 with a built-in SD card reader instead of a built-in radio, but there were similar issues with trying to get a second SPI device running. 

I took this as a sign to not get hung up on using the combo version of the microcontroller. If the author of the firmware doesn’t know how to make it work, I sure as heck wasn’t going to figure it out.

So I bought a standalone RP2040 feather and a separate radio board, and got everything put back together.

And that… solved it. Like, completely. I don’t really get why, but we’ll roll with it.

I spent a considerable amount of time trying to find a solution to this issue. It was the last leg of the integration hell, literally the step where I was trying to turn everything on at the same time, and it almost got me. 

But I survived! And with that sorted out, I could get this octopus off the breadboard and actually solder everything together.

And there you go. The client is able to hold enough of the game board in memory that it can draw to the screen, and it can load different chunks of the board from the SD card as needed. It can enter a new word into the game board and save the updated chunks back to the SD card. It can send and receive messages via the radio, and it can pass those messages back and forth between the two cores. It can accept button inputs and use them to move around the game board (or do whatever else). And it can do all these things at the same time!

That’s about where I’m at right now, but I’m ready to move forward with the next steps. I have just enough of the host code written that it can talk back and forth with the client, so there’s plenty of work to be done there. I’m going to need to get the full word list into the host code so I can start manipulating that massive amount of data and seeing what it breaks. 

Also we’ll have to figure out a case for these things, but that’s something we can work on now that we know what our hardware looks like. Sure would have sucked to change my hardware halfway through designing the enclosure, huh?

That’s about all I have to say about this for now, but keep an eye out for future updates! I’ll probably talk about it in Discord as well. The next blog post will probably be about the code itself, especially as I flesh all that out. I’m pretty proud of what I have so far!

I feel like I should have more to say. But, alas.

As far as livestreaming goes, I’ve been enjoying my continued experiences with Dwarf Fortress, specifically with our silly kobolds and the fortress of Leopardbends. And I’m glad that I seem to have found a way to communicate those stories outside of the gameplay recordings themselves. If you haven’t seen the edited and narrated videos from The Saga of Leopardbends, here’s a link to the YouTube playlist. I’m excited to keep those videos going! There is already so much that has happened in this world… 

I’m also very grateful for all the voiceover contributions I’ve received for those edited videos. I’m excited about continuing that trend, as well. So far I’ve gotten voice work from Radu, Blind, and The Smitchell. They are all great friends, and they all stream Dwarf Fortress, so you should check them out if you haven’t already.

Also also, I just got done making a whole big batch of Shorts to go up on YouTube, all from the Dwarf Fortress streams. They’ll be going out daily for all of August, and I’m quite happy with them.

I don’t have much to report on things outside of Twitch and YouTube, though. I’m itching for another craft project, and I’ve been doing a lot of weird brainstorming. Nothing to commit to paper yet, though.

I spent the afternoon today fixing the newsletter signup situation, and got a better setup for actually sending out newsletter emails. I think.

I’ll be busy with some offline things for most of August, so streams will be sparse for a short bit, but don’t worry! I’ll be back and re-energized before you know it. I think my big goal for when I get back will be figuring out some merch…

Anyway, that’s all the words I have for now. Stay tuned for more something, eventually!

Long-time Dwarf Fortress-ers will know about the various restrictions that players sometimes put on themselves to make the game more interesting or difficult. There’s an extensive page on the wiki detailing playstyle challenges that you can voluntarily adopt if you are interested. There are things like “only ever have one dwarf,” or “pretend to be elves,” or “embark onto a frozen ocean.”

Dwarf Fortress is a true sandbox in the sense that you aren’t given much direction from the game as to what you “should” be doing, and there are no end goals. And while this allows for endless freedom for players to concoct their own goals and pursue them in whichever way they choose, it’s also sometimes hard to think of something new to try. 

The playstyle restrictions and megaproject ideas on the wiki are generally pretty broad, as well. Sure, I can restrict myself to one dwarf, but then what do I do? I can roleplay as hobbits just fine, but that’s not something I can accomplish. That’s not something I can optimize. Or speedrun.

This is the context in which I would like to propose to you: bingo.

What?

What if you didn’t have to come up with a challenge because it was randomly generated for you?

What if the challenge was a concrete task (or collection of tasks) that could be definitively accomplished?

What if the challenge was bite-size enough that it could be done from a fresh fortress in 2 - 4 hours? Or a couple of in-game years?

Bingo. I’m serious!

Take a look at these:

View fullsize

View fullsize

View fullsize

View fullsize

View fullsize

View fullsize

These are a handful of sample bingo cards that I generated using Bingosync.com and my own custom dataset. If you aren’t aware, there is a whole little scene of people making bingo challenge modes for various video games, and often racing each other to complete a line on their bingo card. Many of these games are supported natively by Bingosync, which was built specifically for this purpose. See if you can recognize what games these are for:

View fullsize

View fullsize

View fullsize

View fullsize

View fullsize

View fullsize

There are endless variations even within this super-niche style of game-playing, like needing to complete multiple lines on the card, or when one player gains a square it locks out other players from obtaining it. This all generally exists as a subset of speed-gaming, where players are trying to complete discrete tasks in the minimal amount of time.

This is generally not how people play Dwarf Fortress. Most people would say that it’s not a speedgame. I disagree, but fret not! There’s no reason you have to race another person, or play as fast as you can. In fact, I think using the in-game calendar instead of a real-time clock is quite fun as well, since you can pause and menu to your heart’s content. As a bonus, this also removes the speed variances that you get across different hardware. 

The process

Anyway, back to those bingo cards. It’s probably worth explaining just what I did to make them. The first thing I did was come up with a list of about 400 small tasks that can be done in Fortress mode. I’ll go into more detail about all those tasks later, but I tried to limit them to things that can be accomplished in the first few years of a new fort, and things that can be shown to be completed somehow in-game.

Once I had my task list, I sorted them all based on how “difficult” they are. Bingosync uses a very specific method for generating bingo cards, so you need to feed it information in a rather specific way. All tasks need to be given a difficulty rating from 1 to 25, so you end up with 25 different groups of tasks. The bingo card generator then takes those 25 lists (in the form of a very specifically formatted JSON file), and picks one item from each list to populate the 25 squares on a bingo card.

There are some other factors that go into the arrangement of a bingo card, as well. Since each of the different lists are given a difficulty score (from 1 to 25), the generator can ensure that each of the different lines on the bingo card add up to the same total difficulty score. Here is another bingo card, and its arrangement of difficulty scores.

View fullsize

View fullsize

The other factor that the generator accounts for is the type of tasks that appear together in a line. As I came up with the list of 400 tasks, I assigned each task a couple of tags. For example, some tasks put restrictions on your embark site, so they got the “embark” tag. Some tasks involve crafting larger or small quantities of specific items, so they got “make-big” or “make-small” tags. This helps make sure that conflicting tasks don’t appear in the same bingo line (like “embark in a good biome” and “embark in an evil biome”), and keeps each line more varied (so you probably won’t have two “make-small” tasks in the same line).

Here’s that same bingo card with the relevant tag(s) of each task.

View fullsize

View fullsize

But once I had this list written up and sorted by difficulty and tagged sufficiently, all I had to do was perform some Excel/Python magic to crank out a nasty JSON file. You can see it here:

https://pastebin.com/e7UDdLWP

Not exactly human readable, but it’s good enough for Bingosync.

Your turn

In fact, if you just copy the JSON file from that link, you can use it to generate your own bingo cards as much as you like. Here’s a quick rundown of how to set that up:

When you visit bingosync.com, you'll see a "new room" section on the home page, which will let you create a room for yourself (or others). 

-Name the room anything you want, and give it a password

-The "nickname" will be your name within the room (there's no accounts or anything, just put whatever you want)

-for "Game" scroll all the way to the bottom and select "Custom (Advanced)"

-Paste the pastebin contents into the field labeled "board."

-for "variant" choose "SRL v5"

-leave "mode" as "non-lockout"

-you don't need a seed but you can enter one if you have it

Then click "make room" and you'll be in a room! A room with a bingo card!

If you would like to re-roll the card you got, you can use the "new card" button in "room settings" on the right-hand side. You will need to paste the pastebin contents back into the prompt the first time, but the room will remember it for any subsequent re-rolls. 

If you are making a multiplayer game you can share the URL of the room, and anyone with the password can enter. 

Oh did I forget to mention? That this can be a multiplayer thing? I mean, it doesn’t have to be. You are welcome to use that pastebin to make your own cards and you can play on your own at your own pace and you can have a nice chill experience with Dwarf Fortress and a bingo card.

But also we could race. We could play competitive speed-game Dwarf Fortress. I told you this was mad science.

What’s next

This task list is my first naive attempt at putting such a thing together. I would love input and feedback on what should be included or not, or what difficulty ratings should be adjusted. There’s also no reason I couldn’t put together a separate task list balanced for longer fortresses, or even for adventure mode!

The JSON file itself is rather unreadable, so here is a separate document that lists all of the tasks, including their difficulty ratings and their tags.

https://docs.google.com/spreadsheets/d/1IVPraorSqGrWlkpj0zXqVdBZ6JnGPudMuh7GBGWPAIA/edit?usp=sharing

If you would like to discuss this, you should join the discord! I have even made a channel specifically for Dwarf Fortress Bingo. 

Also, if you want to see what a playthrough of this mysterious concoction looks like, here is a recording of me playing one of the above sample cards, which has no commentary.

https://youtu.be/JnqrA8v1vrE

I’ll leave it here as a standing challenge, to get the interest of anyone silly enough to accept: complete a line on that same bingo card in fewer in-game days than I did in the video above, and show me a recording. It doesn’t have to be the same line that I chose, and you can generate your own world however you like. I just wanna see it!

Anyway, I’m going to stop typing now. You should expect to see some bingo on youtube or live on Twitch sometime in the future. 

It’s hard not to be in January and not be thinking about the year ahead of you, or the year behind. Even without taking into account the broader Events, as stress-causing as they are, this year seems particularly… more?

I feel like I also stand on a threshold as a creator. A threshold I am eager to cross, but also aware of how much time and effort it takes. I’m excited to do more, and meet more people, and do new things, but I’m also scared of failing to figure out just what the heck it is I’m doing here.

I’m proud of what I’ve managed to do in a year, as far as the YouTube and Twitch things go. I’m seeing more interest in the VODs, especially with the cute kobolds. Dwarf Fortress seems to be my most-viewed stuff in general, but the recent stuff has been even more so. And now that I’ve done two of the Leopardbends videos, I think I have a pattern for some more videos to make in the coming months, which is exciting.

But also I’m getting the making bug again. I’m second guessing-everything in my most recent blog post, which feels like an absurd thing to say, but here we are. I really like the idea of creating some durable art-thing at an event and having it live on somewhere, but most places that want art-things want things that are made specifically for them or their spaces. Which is fair.

I want a larger crafting project to work towards, but I’m scare of picking the “wrong” thing. I’ve spun my wheels on a lot of things in the past. I’m brainstorming and reading and thinking on where to put my efforts. I have some cool ideas. We’ll see if any of them are doable.

That’s all that’s in my brain for now. Just wanted the void to know that I’m still here, I guess.

Happy New Year!

It’s possible that you have. You might even already know that it’s called an “aperiodic monotile,” and that it belongs to a small family of similar shapes that share some interesting properties. It’s also possible that you have no idea what that means. I want to talk about this funny shape a little bit (maybe a lot), but we don’t need to go super deep into the technical and mathy end of things. I’ll leave that to the actual smart people, as I am a much more pedestrian appreciator of these things.

That said, it does bear stating just what the heck this thing is. At it’s simplest, it is a tile, but that doesn’t tell you much about it. Tiles can come in literally any shape or size, especially when we’re talking about tiles as an abstract math construct. You can use tiles to produce “tilings,” which are collections of tiles that cover their space without gaps or overlaps.

Sometimes you can use tiles to make repeating patterns. These are “periodic” tilings.

You can find many examples of patterns that use multiple different shapes, but there are a couple of special cases where you can create a repeating pattern with just one shape. You’ve probably seen them before.

Source: Wikipedia

If you can repeat a pattern forever in every direction with just one tile, then we call it a “monotile.” But as you can see above, all of these shapes make a very simple repeating pattern. Each of these monotiles are periodic.

Hopefully you can see where this is going. There was an open question in the world of math that persisted for quite a long time: could you construct a single shape that would tile forever, but in such a way that it never forms a pattern?

This question was only fully answered just recently, within the last year or two. And the answer is yes.

And that’s just… weird, right? I think this is mind-blowing all on its own. There’s plenty more detail that can be gone into, but that’s really all you need to know for our context here: this is a shape that was specifically constructed to have the strange and special property of being able to cover an infinite plane without ever repeating. It’s an aperiodic monotile.

where is this going?

To me this has all the hallmarks of being one of those things that human brains were never wired to fully comprehend. We’re good at finding patterns in discreet spaces. But visualizing infinity? And that not being a pattern? There’s no way to really hold that in your brain and not have steam shoot out of your ears.

That’s when I knew I needed to get my hands on these things. Even looking at pictures of large groups of these tiles wasn’t giving me a real understanding of them. I wanted to pick one up and put it down somewhere else and see what happened.

So I taught myself OnShape. Then I found the paper that describes our special shape, and drew it up.

And then I ordered a bunch from SendCutSend.

And it… worked? I honestly expected to run into some problem or another. But soon I had my hands on sixty or so of these tiles. I quickly set to the task of screwing around with them.

They tile excellently just as intended, of course, but there’s some other interesting things you can do.

Obviously they can make little “patterns” like these, but you couldn’t continue out from here and cover everything.

When making bigger tilings, I quickly noticed that there are some really subtle mistakes that you can make. If you’re starting from one tile and trying to place them one at a time to continue the tiling, there are some “incorrect” placements that would break the tiling. Some of these are way more obvious than others.

Sometimes you can place a tile and immediately see that it creates a spot that cannot be filled, like above. But there seem to be other times where you can make an “incorrect” placement that allows the tiling to continue for a little while, but then it breaks several placements later.

I do not fully understand how to anticipate this. I’ve developed a bit of intuition around it, but I don’t actually understand it. I would love to have a set of rules for how to make only correct placements to continue the tiling forever. The paper describing these shapes (linked above) does give an algorithm of sorts, but it goes right over my head. That’s probably a topic for a future blog post, though.

the proposal

BUT FOR NOW – I want to pitch an idea. I want to do something. My brain has been full of questions recently. Not just about monotiles. About us. About how people act and treat each other and communicate and connect. About humans.

Remember those?

Sometimes I’d rather forget, honestly. But I’m afraid that if I do, then we will be lost beneath the rising waves of digital detritus. We cannot lose sight of what makes us the same, and we cannot forget about the uniqueness of each of our positions within this world.

Here is what I would like to do:

-I would like to attend Open Sauce 2025.

-I would like to set up a booth.

-I would like to bring a bunch of these monotiles, probably with a coat of primer but otherwise blank.

-I would like to bring a bunch of paint markers, so that the tiles can be easily painted and decorated by anyone.

I would like for us to create a monotile mural: a large tiling affixed to a backing of some kind, where every tile is decorated by a different person. I want to create something unique, in real-time, with the help of anyone who walks by and has any interest whatsoever. And I want this to be free for everyone to participate in.

And then, hopefully, I would like to give this mural to a museum or (indoor) public space of some kind, so that it could live on and be viewed by countless more people.

I’ve spent the last few months thinking and prototyping. My first ideas involved giant pieces of plywood with the tiles glued on, but that just makes transporting it complicated. What I’m thinking now is that the tiles can be glued to a large piece of cloth.

 Not only would this greatly reduce the weight of the mural, it would make it vastly easier to transport. We can assemble the mural on a table, gluing tiles down one at a time throughout the course of the event. When the event is over, we can cut the fabric backing into large chunks for transport to its final location.

Once the mural pieces arrive at wherever it’s going, the cloth can be glued back together with some more strips of cloth.

And then it could be displayed in any number of ways. I would likely install a series of grommets in the cloth before the event, and we would just have to make sure to not cover them up with the tiles. Then, once it comes time to install it somewhere, it’s just a matter of running ropes or wires through the grommet holes, and it can be hung up by a wall. I could even put grommets all the way around, and the mural could be hung from a ceiling, facing down.

This prototype was made with cheap muslin cloth, so it’s just a lightweight undyed linen. I used wood glue to attach the tiles to the fabric, and it seems to hold quite well.

I also found that if I limit the glue to just a single blob in the middle of each tile, we get plenty of hold and it allows the tiles to move a bit with the fabric, which I think makes for a neat effect.

That’s also what lets us cut the fabric after the tiles have been glued down. You just snip between the dots. This wouldn’t be possible with a rigid backing like plywood.

For this first prototype, I used the thinnest (cheapest) material that I could order from SendCutSend, which is chipboard. This comes in at 0.030” (0.76 mm) thick, and it’s incredibly lightweight. A hundred of these tiles would weigh about 5.5 oz (160 grams).

I figured the chipboard would be good for a prototype (and making sure my OnShape file was correct), but the more robust hardboard would surely be an upgrade, with its 1/8” (3.2 mm) thickness.

The hardboard tiles are definitely stiffer and more resilient, but they also weigh a lot more. I wasn’t even thinking about the weight until I went to pick up this second prototype. A hundred hardboard tiles would weigh two pounds (about 1 kg)!

The weight could probably be dealt with, but this prototype also doesn’t have the same kind of flowy flexibility that the chipboard one has. When the tiles move out of alignment, they don’t easily slide back into place, just due to the thickness of the tiles themselves.

So now I’m thinking the chipboard might be the way to go, even if they are a little flimsy. This will definitely be an indoor-only mural even with the hardboard, so it hopefully won’t matter much in the long run.

I grabbed a big chunk of muslin cloth from the fabric store because it was on sale, but this is probably the cloth I would end up using in the final mural. Muslin is cheap, lightweight, and is typically about as wide as fabric gets. It also isn’t dyed or treated, so I don’t have any concerns about the glue getting a good grip on the fabric.

For the sake of putting down some numbers, we could do something like this:

-1,000 tiles

-90” x 67” (2.5 yds x 1.9 yds)

-3.5 pounds for the chipboard tiles, plus about 1.5 pounds for the muslin, for a total of about 5 pounds (2.25 kg)

Alternatively, if we used the hardboard tiles, it would weigh upwards of 20 pounds for the tiles themselves, plus the cloth.

The mural could get longer in the short dimension without any issue. The muslin cloth itself is about 90” wide, and I have about 3 yards of it, or a bit over 100”. A 90” square could hold roughly 1,300 tiles. But there truly is no limit to how big this could get, aside from logistics.

I think that’s about all I have to say about this for now. My next task is going to be making some inquires to see if I can find a long-term home for the mural. Once I have that figured out, I’ll submit this as a booth proposal for Open Sauce.

And then… we’d do it?

Stay tuned for updates!

If you want to chat about this, feel free to join the Discord or reach out by email.

I really never thought I would see the day that I actually started my own blog on my own website. At least not since like 2005.

I have high hopes though. Words really are my favorite medium, and I’ve always struggled to find a space to properly use them. At least here I have full authority over what I say and how I say it. So don’t be surprised if you see some weird things.

But also most blog posts should be relatively “normal.” The next several will probably be about a project that I’ve been dreaming up. Some of the things that I want to do are bigger than would reasonably fit within a single YouTube video, and there may be long periods of time between conceptualization and fruition. This way I can write short updates about what’s going on, show the development process, and work through all the issues that inevitably arise.

However, sometimes I just want to put words together in a weird order and show them to you. I’ll do my best to use tags or categories to organize the posts, so that you vaguely know what you’re getting into.

I also want to keep these pretty short. There will probably be occasions when I have a lot to say about something, and I won’t hold back when that’s the case, but generally these will be brief. Not quite micro-blogging, but not quite full-size blogging either. Mini-blogging?

Speaking of weird words, I want to close out this inaugural blog post with a short piece that I wrote a while ago. This is from when I first started streaming on Twitch, and I wrote it as a weird little thing to live in one of the panels below the stream. I eventually removed it from my Twitch page in favor of more productive information and utilities, but this lump of text still has a special place in my heart. I don’t even really know what to call it, or describe it as. So I’ll just show it to you instead.

Your journey through the wild forest leads you to a break in the trees. This is an unfamiliar place, but it is filled with familiar shapes. A butterfly with mylar wings rests on a broad leaf made of linoleum. Small patches of colorful foxglove are strewn about the open space, their bell-shaped flowers emitting soft lo-fi music.

A tangled mass of moss-covered cables and conduits crawl across the ground like gnarled roots, all leading to a massive tree at the center of the clearing. The tree itself looks to be more metal sculpture than actual plant matter. Amongst the branches you see satellite dishes pointed to the sky and cell antennas pointed to the horizon. You cannot tell if this is a machine that has overtaken a tree, or if it’s the other way around.

As you approach, you are suddenly illuminated by a pair of halogen security lights that seem to be growing from the tree above. At eye-level you see a small screen embedded into the trunk, the rounded glass bulging from the bark surface. The screen ticks on, and a rectangular cursor scans across the display, leaving green text behind:

The only thing that’s real is kindness.