#bleep space

[andymakesgames]

New Bleep Space wireless controller for the Dan Friel show at Wonderville a few nights ago. We projected Bleep Space between sets (and during setup) and passed the controller around the audience.

The controller itself is a wireless num-pad that I painted.

[andymakesgames]

Killipede: Programming A Music Video

A still from the Killipede music video.

[epilepsy warning: this music video and this post feature a lot of flashing colors. After the “keep reading” jump there are many animated gifs.]

I’m Andy Wallace, an independent game designer and professor who lives in NYC. I tend to split my time between systems-based arcade games and experimental, generative experiences. But today I’m talking about a music video.

Fanfare, the new album by Dan Friel just came out and I’m excited to announce that in addition to making the cover for the album, I created a music video for the single Killipede (which is a real noise-pop banger). You can watch the video right here:

This isn’t the first time Dan and I have worked together. In 2017 we released Bleep Space, a harsh sequencer toy which you can check out for free. I can’t recommend his albums enough. When he started wrapping up Fanfare he got in touch about making a music video for one of the songs.

What makes this project really fun is that this video was written entirely in C++. I’m a game designer by trade, and programming things that move is what I do. Rather than switch to standard animation tools, I stuck with what I’m good at and wrote the entire thing in code.

To create the style of the video, and to match Dan’s energetic and chaotic noise, I focused on JPEG corruption to create a set of filters and effects that I used in the video. The techniques used are not stylistic attempts to mimic the look of JPEG corruption; they are honest-to-god damaged JPEG files.

What does it mean to program a music video?

A scene from around 1:34 in the video

The idea might seem confusing. With most animation, somebody draws something on a screen or on paper that then gets brought into some type of animation program. For Killipede, instead of using traditional tools, the images and effects are all generated via code. The program exported each frame as an image, and eventually these images were strung together to make the video.

Here’s a look at my project. People love screenshots of code, right?

No outside assets (images, 3D models, etc) were used. All of the drawing was done with code. Any images used in the glitch process were first generated by the program and saved locally as JPEG files.

The one exception to this was this title card, which I made in Photoshop and which was used as an input image for one of the glitch effects early in the video.

Above you can see the one asset not generated via code (left) and how it was used in the video (right).

To help with the drawing-via-code, I used openFrameworks, a C++ library that I frequently use (PARTICLE MACE and Bleep Space were both written with openFrameworks). It’s a collection of C++ code that makes it a lot easier to draw shapes to the screen. It allows programmers to use commands to draw things like lines, rectangles & circles.

An example of programming a simple scene using openFramework commands.

I’ve done a lot of procedural animation for games and interactive projects using these tools. They may appear basic, but you can be surprisingly expressive with enough experience!

These drawing tools just make the basic image of each frame of Killipede, though. The real magic comes from the glitch techniques.

JPEG Corruption as a Style

Who doesn’t love some glitch art? Things go wrong and sometimes that makes them look great. JPEG is a way of compressing images in order to make the file size smaller. It is what is known as a “lossy-format” because this compression comes at some cost in the quality of the image. JPEG is widely used because it manages to make images very small, typically with very little loss in quality, but it is also susceptible to damage in a lot of ways. If you’ve ever seen a blown out, funky-looking image online, chances are it was saved, resized, posted online and saved again one (or ten) too many times. The quality of the file degraded as little aspects of JPEG compression happened over and over again. It’s not unlike a game of telephone. A little bit gets lost every time the image is repackaged. And once you know a bit about how JPEG compression works, there are little things that can be done to break the compression algorithm in specific and interesting ways.

0:34 in the video.

For Killipede I took advantage of this by having the program draw the initial frame using the basic shape tools built into openFrameworks, save the frame as a JPEG file on my computer, then reload and manipulate that file. This process of reloading, manipulating, and saving was often done many many times for a single frame of animation.

For some effects, the file itself is manipulated by adding or changing individual bytes. And in others, the image is loaded but then specific pixels are modified to do things like change the hue of part of the image. 

Many of the effects use a second image, taken from earlier in the video, as the basis to perform some operation. I often used this as a way to transition between scenes in the video.

An example of using an earlier frame as a second image input. The spiral background from earlier persists into a new scene. This can be seen at 1:32 in the video.

This whole process was largely inspired by a single example project that ships with openFrameworks. In a collection of examples about input and output–most of which cover standard utility things like how to load text files or save an image–a project called imageCompressionExample stood out. Every frame it loaded in a photo, resized it and saved it. It also allowed you to insert a random byte into the file and do some real damage.

This started out as a photo of some busses

I found it fascinating and kept it in my back pocket. When Dan came along saying he wanted a glitchy video for his song, I knew I had my opportunity.

The Glitch Stack

While doing preliminary work on the project, I developed a lot of different ways of manipulating and breaking the JPEG images. There is a strong degree of randomness and unpredictability to all of them, and they are each expressive in their own way. I was able to exercise a lot of control in how and when glitches were used, but still be delighted and surprised by what was generated.

Laying the glitches on thick around 1:01 in the video.

Key to this was the ability to layer these effects. To accomplish this, I created a structure that allowed me to instantiate as many of these glitch effects as I wanted. Each effect receives a JPEG, mutilates it in whatever way it needs to, and then saves the result as a new image file. The Glitch Stack makes sure that the output of the first effect is used as the input for the second effect, and so on. Each effect in the stack can have its own settings and values as well, meaning I may use the same effect twice in the stack, but have it behave in slightly different ways.

An example image showing the output of several steps in a Glitch Stack on a single frame of animation.

Naturally, when saving the image for each step in this process, I have my code use the absolute lowest quality setting in order to introduce a little more entropy into the process.

For each scene, I programmed geometric shapes and movement and selected from my toolbox of glitch effects to find the best ways to “ruin” the scene. These effects as well as the basic movement of the objects in the scene were all timed to fit Dan’s music.

Some stacks required hundreds or even thousands of file saves to create the effect. Saving and loading images can be a time consuming operation in code, and this was no exception. I’m used to working in games where everything needs to run in real-time. Luckily, for fixed media like video, processing time is no issue, and I relished the opportunity to write effects that would take hours to produce a few seconds of footage. It allowed me to be greedy in a way I could never be with games!

Meet the Glitches

I wound up creating 10 unique glitch effects that were used in the video. It would be too much to go through all of them, but I want to highlight a few of my favorites. Once you know how they work, try watching the video again and you’ll see them all over the place.

Byte Insert

This is a variant on the effect in that openFrameworks example above that I found so intriguing. The basic idea is that the JPEG is loaded into memory, and then one bit is selected at random and changed to a random value before being re-saved. This creates big, flashy effects as the garbage value introduced often throws off the entire file from that point. This is often seen as a color distortion running horizontally across part of the image and then down everything below that point. Sometimes we get lucky and it shifts part of the image over, making the whole thing appear out of phase!

In this still from 0:20 you can see that the modified byte occurred about halfway through the image file, causing the rest of it to get a green tint. If you look closely you can even see the exact region in the JPEG compression where the byte was changed as it has become a small square of rainbow garbage data.

JPEG Compression (to a certain degree) stores the info for the image left to right and then top to bottom, meaning it describes the image in bands running left to right, moving down to the next band when it hits the right side of the image. This type of corruption displays this structure clearly. Everything to the left and above of the damaged part of the file is unaffected!

Here is the sample frame of animation from above being run through a double Byte Insert. Every frame, two bytes are chosen at random and replaced with garbage data.

This effect is very cool, but also very strong. It’s difficult to use as a filter for more than a fraction of a second because each frame can look wildly different from the one before it. To account for this, I made a second version of the effect that masks out a certain color from the input image (such as the background), and redraws everything else each frame to give the moving parts a bit more consistency. He’s a clip from an early test I did while working on this mask effect.

You can see how the red circle gets redrawn each frame, but the background is effectively transparent. The path of the circle gets covered up pretty quickly by the Byte Insert glitch.

Crunch

This was maybe the simplest of the glitches used. This effect works by taking the image, scaling it up (just 1 or 2 pixels bigger), saving it to disk, reloading, scaling it back down, and saving it again. When done once or twice, there is no real loss in quality, but when done 200 or 1000 times, the image gets very fuzzy.

Here’s the same sample frame of animation going through an increasing number of passes through the Crunch.

You can start to see square or rectangular fuzz. That’s because JPEG compression works partially by breaking the image up into square regions. By resizing the image to be just a pixel or two bigger, these regions get broken, and what would have been a small, difficult-to-notice line of fuzz becomes extreme as it is pushed back and forth over that border point.

Wanting a bit more control, I also wrote a version of this glitch that can be “cropped” so it only affects a specific part of the screen. The entire thing is crunched, but then only pixels from a given region are transferred on top of the source image.

A still from around 0:50 in the video where horizontal bands of Crunch are applied.

I could also set the number of Crunch passes each frame to do effects similar to screen-shake, where it would suddenly get very blurry and crunched and backoff over time. This was a nice effect for things like kick drum hits.

The first shot of the video where the kick drum is especially apparent.

While simple, this effect has the single longest processing time because of how many times it requires loading and saving an image.

Stretch/Resize

Related to the idea of resizing an image to break it, a different effect can be achieved if the resizing process is applied in a weighted way, so that instead of reverting the image to the same size, it gets wider or taller over time (for example, expanding by 4 pixels and then reducing by 2 over and over). In this version, the image experiences some of the region breaking from the Crunch, but it also stretches and distorts in a way that almost looks like digital melting, complete with heavy artifacting.

Here is the Stretch/Resize effect being used on the same sample frame.

Because this effect benefits strongly from being able to see it grow over time, I typically used it along with a mask so that the same image could be stretched while new things were drawn on top. It made for a great transition early in the video.

A clip from 0:16 in the video. To get this to fit on Tumblr, I had to crunch this one even more than most of the gifs in this post. Watch the video to see a clean version.

Cleaning Up

This is just a sampling of a few of the effects I wrote for this video. A lot of time and lines of code went into the 1 minute 45 seconds of Killipede. While certainly not the only video done in this style, I think if you made a pie chart of animation tools, C++ would make up a pretty tiny sliver.

It was a fun challenge to bring my game development and programming sensibilities to a non-interactive piece of media. And on a personal level, it was fun to make a music video again, as that was something I used to do back in the Flash days.

Make sure to check out Dan Friel’s new album, Fanfare. It’s been on heavy rotation in my apartment since it came out a few weeks ago.

Album cover by yours truly.

And if you like this kind of thing, you might love Bleep Space, the sequencer toy that Dan and I created. It’s free for iOS (on the app store) and Mac/PC here.

[andymakesgames]

Bleep Space Launch Party Photos

Last night Babycastles hosted the Bleep Space launch party! We had the game setup on the projector, one of Babycastles arcade machines, and the custom tabletop arcade. And if that wasn’t noisy enough, there were sets by Passive Tones, Nylon Viper & of course, Dan Friel who did the audio for the game. Dan even brought a horn section with him that added a really joyous element to his already fantastic music.

The game is out now and free, so you should check it out! You can download it for iOS, PC or Mac at bleepspace.com

Lippe was also there taking pictures, which was unexpected and lovely. Here are a few of his pictures from the night:

You can find more of Lippe’s work on twitter at @lippemfg and on Facebook.

And here are a few that I took on my phone of the space and the setup:

Thanks for an amazing night everybody!

[andymakesgames]

Adding Headphone Jacks To Bleep Space

Last weekend, Mark Kleback and I added two headphone jacks to the Bleep Space tabletop arcade.

As a sequencer installation, it’s a lot of fun, but it’s also pretty loud. And since it’s a sequencer, it requires sound to be fun at all. The result has been that I don’t always bring it to shows with lots of other games around because it either takes over sonically or nobody can hear it.

We’re thinking about bringing it to MAGFest along with the other machines so I wanted to include headphone jacks so people could plug their own headphones in and we can keep the overall volume a bit lower.

Getting the innards setup on the work bench:

Soldering mounted headphone jacks on to the end of a splitter I bought:

Mark drilling them in place:

Ready to be plugged in:

You can play Bleep Space and all the other Death By Audio Arcade cabinets at MAGFest in January!

[andymakesgames]

What I Made in 2017

Alright, here is is, slightly late: My 2017 year-in-review!

I made fewer projects this year, focusing on a handful of larger ones, but still had a pretty large output. Let’s hop in!

Death By Audio Arcade

I’m delighted to report that Death By Audio Arcade continues to grow. We just got back from MAGfest, our biggest event of the year, where we brought 11 of our own arcade cabinets and worked with Babycastles to curate even more.

DBAA became a recognized profit this year and we’ve been running a lot of events. Hopefully it’ll be full steam ahead in 2018.

(Photo by Nick Santaniello)

Weird MTG

This year, I formalized my intermittent, themed Magic: The Gathering events into an event series. Weird MTG focuses on overlooked or underutilized parts of the game. Events this year featured a constructed event attempting to mirror the play environment in 1996, a cube draft of cheap rares, and finally, my most ambitious event, a RoboRosewater booster draft. More on that in a moment.

You can sign up for the Weird MTG mailing list at weirdmtg.com.

Spelunky Stream June-September

I’ve been playing Spelunky for years, but this summer I decided to stream my daily runs. This was a new experience for me and I had a lot of fun with it, not to mention my ability to consistently get through hell has gone up considerably!

Salmon Roll: The Upstream Team August

I worked with Jane Friedhoff and Diego Garcia to create this installation game for Play NYC. Inspired by the 1983 arcade attraction Ice Cold Beer, Salmon Roll is a co-op game where two players control beavers attempting to guide a rolling salmon safely upstream. The game is played on a giant five foot long controller held by both players.

Since it debuted at Play NYC, it has been shown at several Death By Audio Arcade events.

Photos by Jo Chiang

Bleep Space October

A lot of my year went towards working on this sequencer project. This was a project that started with me wanting to mess around with a sequencer I had gotten one weekend, and eventually grew into a much larger project, including an audio collaboration with one of my favorite local musicians, Dan Friel.

Bleep Space launched for free on iOS, PC & Mac, and was accepted as a finalist to IndieCade this year. The launch party at Babycastles may have been the most fun I had all year.

(Photo by Lippe)

Bleep Space Arcade October

When I found out that Bleep Space had gotten into IndieCade, I worked with Mark Kleback to create a tabletop arcade for it. This arcade featured light-up buttons that would flash every time their sound was played, as well as a round screen that allowed players to approach it from any angle.

(Photo by Crystal Brackett)

Julio Le Parc Animations October

Jane and I were in Paris to show Bleep Space at IndieCade Europe, and we spent much of our off time at the many art museums throughout the city. A painting by Julio Le Parc caught my attention. I loved the execution of the predictable, but not entirely obvious, pattern on the canvas and made a series of small animations in Processing that animated the original and then riffed on the core pattern.

Urza’s Dream Engine June-November

A lot of the year went into this one as well! Urza’s Dream Engine, my first foray into machine learning, generates new art in the style of Magic: The Gathering cards. I created the bot to make artwork to accompany the text from RoboRosewater, a machine-learning bot that creates new MTG cards. After months of training the bot on art from different cards, I combined the output with the RoboRosewater cards and held my final Weird MTG event of the year: a booster draft using cards generated entirely by machine. This event was held at Babycastles in NYC.

The resulting format was shockingly playable. All of the art as well as print-and-plays of the cards are available (with the blessing of the folks behind RoboRosewater) at andymakes.com/urzasdreamengine.

(Photo by Lippe)

Smaller Things

As I tend to do, I also made a lot of small, silly, one-day projects this year. Here are a few of my favs.

Times New Roman April

Timez New Roman takes the classic Times New Roman font and replaces the S glyph with a Z. You can download it here.

Wolfram Moon June

This is a simple Wolfram animation using moon and sun emojis.

H0l0 Visuals August

I got to do visuals for a musician at a Death By Audio Arcade show at h0l0 in Brooklyn, and had a lot of fun dusting off some old code experiments.

shrimp-heaven-now.com August

A silly little fan site for those good good boys.

Khitomer Funk September

This is just a terrible joke, but it makes me laugh.

That’s it! That’s everything I did this year! See you next year!

I’ll keep posting my work on this blog, and if you want to see a more curated portfolio, check out andymakes.com.

[neondeathcat-blog]

Photos and video for Bleep Space @ IndieCade 2017!

Photos/ video/ info can be found at http://bleepspace.com/

Bleep Space is a sequencer toy for iOS, PC & Mac devloped by Andy Wallace with music by Dan Friel. In addition to the free digital release launching on November 4th, Bleep Space also worked with Mark Kleback to create a tabletop installation to house the game, featuring light-up tactile buttons and a round screen. This device is currently touring different locations in New York and was debuted at the IndieCade festival in L.A.. 

[andymakesgames]

Building The Bleep Space Tabletop Arcade (featuring lots of pics)

If you’re coming to IndieCade West in a few days or IndieCade Europe at the end of October, you’ll see me there encouraging people to make noisy beats on a custom sequencer/arcade machine! Bleep Space has been accepted as a finalist, and to show it off, we built a tabletop arcade for it to live in! Can’t make it to LA or Paris? We’ll be doing a launch party show at Babycastles in NYC on November 4th, featuring a live set by Dan Friel, who did the amazing, jagged audio samples for the game.

Look at this gorgeous thing!

The Bleep Space arcade is being built by me and Mark Kleback, show-runner at Death By Audio Arcade. Bleep Space isn’t an official DBAA project, but it is certainly under the umbrella. Mark is a wizard and it is always great working with him to create physical homes for our games (including the PARTICLE MACE arcade cabinet, which will be turning 4 soon and is still kicking).

Designing

Even before I found out that the game had gotten in to IndieCade, I got in touch with Mark about building a housing for it. The game is a sequencer at its core, so creating a physical object for it was a natural fit. He was down, and I started sketching in my notebook.

In Bleep Space, the user creates a beat by tapping the screen to add one of 15 sounds to the sequence. Each of these sounds has an accompanying motion graphic that appears on the screen. As the beat fills up, the screen comes alive with procedural animations.

For the arcade enclosure, the idea was to have a monitor in the center with a circular mask surrounded by buttons that would light up & create the sound/shape pairs. I also wanted to have the buttons 3D printed in order to have a tactile representation of the shape they would create in the game, although this wound up proving impractical.

Fairly soon after I made my initial sketches, I met with Mark and we made a design in Illustrator that we could use to create the final product. The end result was pretty similar to the initial design, but we added smaller buttons to control the tempo and to clear the beat. We also arranged the buttons into straight rows on each side so that they would not be confused with the on-screen time indicators which go around the edge of the screen in a circle.

This is also when we brainstormed and researched options for buttons and other hardware we would need. Although I’d made the sketches months earlier, this initial meeting was only a month before IndieCade so we had to move fast, and that meant buying our equipment early so it had time to ship.

Fabrication

Because we needed it done quickly and because this thing needed to to be able to survive flights to LA and Paris, we decided that instead of building it ourselves we’d go with South Side Design & Building, a fabricator that had worked with Mark on DBAA projects in the past. This is the first time I’ve worked with a fabricator and I’m very pleased with the results. We met with Doug at South Side, showed him the design file, and talked about what we needed. He had several solid suggestions (like putting rubber feet on the bottom) and about a week later, we had a great shell for the arcade.

The Frame

The frame of the arcade machine has a 3/4 inch laser cut acrylic top mounted on a wooden ring with drilled out holes for the speaker. The whole thing sits on on a circular wooden base with a hole for the power cords.

It’s about 8 inches tall and 22 inches in diameter. Enough for 4 people to comfortably stand around and still see the screen in the center, but not so large that one person can’t reach all of the buttons.

The screen itself is mounted on an adjustable platform on the bottom so that it is secure and can be raised or lowered as necessary (the buttons to clear the beat or adjust the tempo are mounted on top of the masked part of the screen so this flexibility was important). There are two screws that hold the top and bottom parts together so they can easily be removed, with the button controls staying on the top and the monitor/all other innards remaining on the bottom.

All in all, South Side did a killer job with the frame and they did it at a very affordable price.

What’s Inside

Let’s talk abut what we jammed into this thing!

The Computer

For money and weight reasons, we went with an Intel Compute stick for the computer. I’ve been disappointed with the Compute Stick in the past, but Bleep Space is a pretty lightweight application and the tiny form factor (and low price) of the Compute Stick made it a good option.

Audio

This being a sequencer toy, the audio is critical. Because we had room inside to mount speakers, we went with a set of car speakers attached to a small preamp. The preamp got screwed to the bottom, and we laser cut some mounts for the speakers. The result can get very loud. I hope my neighbors at IndieCade like noisy beats!

The Buttons

The buttons are where the Bleep Space arcade really comes alive. We bought 16 light-up square buttons from Adafruit, one for each sound/motion graphic the user can place in their beat. On these buttons, besides the typical switch leads leads, there are two additional solder points for the LED. The plastic top of the buttons also pops off so that a printed icon can be put into the button.

This is where we wanted to machine to really shine. Not only would the buttons let people add sounds to the beat, but they would light up whenever that sound played, connecting the Bleep Space arcade to more traditional sequencers.

I designed a set of vector icons to match the shapes associated with each sound in the game. Even if I was not able to make tactile buttons for each one, they still needed to look good.

I took these images over to FedEx and had them printed on transparencies so that we could take full advantage of the LEDs underneath them. In fact, we even ditched the lights that came with the buttons in favor of super bright white LEDs from Sparkfun. At Mark’s studio I set to work disassembling the buttons, cutting out the transparencies and combining everything.

Controlling The Buttons

For every button we had, we needed both input and output. Every button press needed to be represented as a key-press on the computer, and we needed a separate way of controlling the LEDs which would light up when the button was pressed or when that sound played as part of the beat. To accomplish this, we used two microcontrollers: an I-PAC for the input and an Arduino for the output.

I-PAC

The I-PAC has been our default input device at Death By Audio Arcade for a while now. It is a very simple device with screw terminals for wires coming off of buttons. It is read by the computer as a keyboard but has special software that allows the inputs to be programmable. The result is that arcade buttons can be attached to it and set to act as any key on the keyboard.

Arduino

To control the LEDs, I am using an Arduino that is receiving serial communication from the Bleep Space app. The Arduino has Firmata loaded onto it, which makes it much easier to control. All of the logic is done in Bleep Space on the computer, and the Arduino just turns the LEDs on or off as directed by the app. We mounted a screw shield on the Arduino to make it easier to work with.

We made sure to use a powered USB hub to ensure that everything had enough juice to have the white LEDs be visible even in a lit room.

Putting It Together

Because all of the buttons and LEDs need to be wired separately, the end result is a lot of wiring on the top part of the enclosure. We also had to make sure that everything stayed on the edges, so that there would be room for the screen and the other pieces that would stay mounted on the bottom half of the frame.

On the bottom, it was a real mess of wires and power supplies at first, but once we had the speaker mounts in place, we were able to secure everything else in place with industrial velcro strips and zip ties.

The Acrylic Ring

One thing we found when we put it all together was that we had slightly miscalculated on the size of the hole for for the monitor. It wasn’t terrible, but a bit of the edge of the monitor was showing through, and it just didn’t look as good as it could. To solve this, we laser-cut a small black ring and affixed it to the bottom, providing a little bit more coverage on the mask and creating a nice black outline on the hole as well.

The Software

Bleep Space was written in openFrameworks and the software running on the Compute Stick is nearly identical to the general Windows build of the game, but there are some changes that happen when I turn on the ARCADE_MODE flag in the code.

Some features are disabled. Most notably, the more complex Step-Mode is inaccessible in the arcade build. Although Step-Mode gives users more control, it has more of a learning curve and is not well suited to a toy that I want to be very approachable. Any game in a public place needs to be understandable almost immediately or it risks losing players.

There are a few other arcade-only settings, such as a timer to clear the screen after inactivity, and a message that displays whenever the clear button is pressed that can be set via a text file that lives next to the app on the computer. This lets me make minor changes without having to make a new build.

The major difference is that the beat markers change position. In the normal build, they run along the bottom of the screen, but since the arcade screen has been masked to be round, I changed them to run radially around the edge.

Prepping The Computer

This is not the first computer I’ve setup to work as an installation. At Death By Audio Arcade, we’ve gotten a routine down to prep windows machines to work as an arcade. First thing is to disable all updates and set the power settings so it never goes to sleep.

After that, we put an AutoHotkey script in the startup folder that will launch the game when the computer first starts, and which will respond to the middle mouse button being clicked by closing the application (if it is open) and restarting it. This is very helpful in case the game crashes or freezes, which is certainly a possibility when we leave these machines running for 48 hours straight.

We drilled one extra hole in the frame made by South Side and mounted a small, button under the lip where it is hard to see. The I-PAC reads this button as the middle mouse click, so the game can easily be reset if anything goes wrong without having to open up the whole thing.

Extra Sound

The most exciting new feature is a special sound/motion graphic pair only present in the arcade build. We realized that the 15 sounds in the normal build would look weird distributed across the 4 sides of the arcade, so we decided to add one more!

You’ll have to come out to IndieCade or the Babycastles opening to see this one!

Come Play!

I’ve had a lot of fun making Bleep Space, and I’m thrilled that it has a physical enclosure now. I’ve talked in the past about how deeply satisfying it it to create physical objects for digital art. Having this thing that I spent so much time creating take up space in the real world is a great feeling.

And it’s a hell of a lot of fun to play with! If you want to check it out in person, the next three places it will be are:

IndieCade West in Los Angeles, CA 10/6-10/8 2017 IndieCade Europe in Paris, France 10/30-10/31 2017 Bleep Space Launch Party at Babycastles, New York NY, 11/4/2017

Here is the arcade, wrapped in bubble wrap and ready for the flight!

I’m sure I’ll be bringing it around to other events as well, but that’s what’s planned for now.

More Info

The Bleep Space app will be available for free on iOS and PC/Mac (on itch.io, of course!) on November 4th. Details and press info at bleepspace.com

[andymakesgames]

Bleep Space, the sequencer toy I'm making with Dan Friel is releasing on 11/4! Join us at Babycastles in NYC for some noisy fun on launch day!

More details soon, but in the meantime, here is the brand new trailer!

bleepspace.com