Welcome to the Glitch Gallery, an online exhibition of pretty software bugs! This is a museum of accidental art, an enthusiastic embrace of mistakes, a celebration of emergent beauty. Learn more?

Below you can browse the exhibits in our collection. Keep scrolling down to see them in more detail! If you have ever encountered such an accidental artwork yourself, we invite you to submit it to us!

Gemstone
ByteHamster, 2019

Lapin Noir
Jeroen Baert, 2015

Squid
Al, 2020

Moment before the infinite loop
Kofi Gumbs, 2019

Texture Recursion
Alex Chen & Andrew Desharnais & Bill Marcy & Jimmy Tang, 2020

Can We See Now?
Brian Davis, 2018

Rainbow Blur
polyfloyd, 2014

Collapsing Waves
Brian Hicks, 2020

Exploding Hedgehog
Brian Hicks, 2020

You are what you eat
Anonymous, 2018

melting a e s t h e t i c
Erty Seidohl, 2018

Cylinder Wrapping Gone Great
Hamish Todd, 2017

Hexagonal Big Bang
Hamish Todd, 2015

Tracey's Volumetric Snowstorm
Kirstin "Kiki" Rohwer, 2020

Fractal Pyramidal Moire
Hamish Todd, 2011

Bond Ball
Hamish Todd, 2017

Icosahedral Flower
Hamish Todd, 2014

Geodesic Flower
Hamish Todd, 2014

Trained Voronois
Topi Tjukanov, 2018

Degrees of a Sine Graph I
Dan Anderson, 2018

Degrees of a Sine Graph II
Dan Anderson, 2018

Psychedelic Ride
SPokDev, 2019

Chaos Center
Laura Klünder, 2017

Luchador
2DArray, 2018

Out of Line I
LambdaTotoro, 2020

Out of Line II
LambdaTotoro, 2020

Out of Line III
LambdaTotoro, 2020

Out of Line IV
LambdaTotoro, 2020

Not Quite Interpolation
Sebastian Morr, 2012

No Vectors' Land
Emile Hansmaennel, 2018

Subdivision
Emile Hansmaennel, 2018

Psychedelic Rainbow
ePirat, 2018

Traversing Berlin
Daniela Berger, 2018

Galaxy Smoothie
Raphael Michel, 2017

Floating Robots
Raphael Michel, 2017

Displacement Chaos
Michael Pucher, 2017

The Eye of the Cube
Uriopass, 2016

Disco Time
Jakob Runge, 2013

The Stanford Iceberg
Marc Kassubeck & Sebastian Morr, 2012

Uncontained I
Sebastian Morr, 2016

Uncontained II
Sebastian Morr, 2016

Uncontained III
Sebastian Morr, 2016

Uncontained IV
Sebastian Morr, 2016

Uncontained V
Sebastian Morr, 2016

For a practical course at university, I had to write an OpenGL game from scratch, without using a game engine. One of the first tasks was to load glTF files with 3d models. Actually, this image should display a yellow rubber duck. Instead, it turned out to be a colorful gem. I am not completely sure what went wrong but my guess is that I accidentally interpreted the normal buffer as the position buffer. With increasing complexity of the loaded model, the displayed object looked more and more like a sphere.

During the development of a visualizer tool for an academic paper I was writing at the time (Out Of Core Construction Of Sparse Voxel Octrees by J. Baert, A. Lagae & P. Dutré), I made an error in the code that descends into the hierarchical voxel structure we saved our models in, resulting in a render that not only omitted 80% of the voxelized triangle faces, but also did a hard cutoff of the normal information that was stored with them, resulting in this weird glitchy noir-ish classic Stanford Bunny. You’re seeing triangles which are actually built up from tiny voxels, in a 1024 x 1024 x 1024 voxel grid.

The renderer was a CPU-based raytracer that used OpenGL to display the final result in a screen-filling quad at a resolution of 512 x 512. Thanks to the inherently parallelizable nature of the raytracing algorithm I could slap OpenMP on it and get it to run at interactive speeds, whilst loading all university-provided cores at 100%, naturally.

Squid

Al, 2020

In an assignment to simulate a control system in MATLAB, I needed to plot its Lyapunov function v(t), which is a strictly decreasing function consisting of sums of errors in the control system. The function is calculated in part by multiplying the 4x1 error vector e(t) and 4x4 matrix P together as e(t)’Pe(t) (apostrophe is the transpose), which produces a scalar. In addition to some other problems, instead of assigning e(t) to the error vector at time t, I assigned error at every timestep to e, resulting in a 4x4000 matrix. As a result, plotting v(t) shows 4000 different signals that result from mixing error values from different timesteps. Since e at consecutive timesteps are relatively evenly spaced, the curves plotted are also evenly spaced aesthetically in a way that reminds me of glassblowing or squids swimming mid-stroke.

During Char’s shaders workshop, I accidentally left an infinite loop in my vertex shader. Since KodeLife is constantly recompiling and running your program, infinite loops can cause the entire IDE to crash. The resulting canvas visualizes whatever data happened to be in the GPU registers from KodeLife’s final moment.

Texture Recursion

Alex Chen & Andrew Desharnais & Bill Marcy & Jimmy Tang, 2020

Writing an OpenGL game for a game jam, this was our first attempt to render to an offscreen framebuffer object. However, we had forgotten to re-bind the textures in our main loop, and now the active texture contained the framebuffer data. This meant that every textured object was showing the previous frame’s rendered data, creating an interesting hall-of-mirrors effect.

Can We See Now?

Brian Davis, 2018

I was attempting to create an efficient approximation for a line-of-sight test between two boxes. The naive method would be to send straight rays out from the boundary of the “seeing”/source box and check intersections with all other boxes. I thought I could use fewer rays by branching them as they got further apart This was the visualization which showed me I had not coded what I was envisioning. You can see the darker blue box which was the source in the center and the green box test object in the lower right corner.

When bored with my current screen saver at one time in 2014, I thought it would be awesome to have my screen saver be a blur of my desktop at the time I locked it.

I did not keep the code that produced this wonderful catastrophe. But if I remember correctly, the faulty blurring operation produced a value that was way larger than it should have been which was subsequently wrapped to cram it into 8 bits, producing these colorful waves.

I had some wrong initial ideas when implementing Wave Function Collapse—this is what happens when one only considers adjacent pixels instead of adjacent patterns.

Mixed media (math, HTML tables)

When I was building elm-particle I tried to make some fireworks, and messed up the speed and size in my calculation.

You are what you eat

Anonymous, 2018

This image was produced by a phone camera, where it seems to have combined several different photos, rendering the subject transparent. Taken at a market in southern Spain.

Erty and two friends were working on a generator for pixelart landscapes. They implemented coastline generation and reflections, but while experimenting with color palettes, they encountered this bug.

This (which is screens from a video) was meant to be something so much more boring: essentially just this animation. But I was drawing the circles parametrically, and their centers ended up put in the wrong place.

Imagine a grid of equilateral triangles, and imagine that every edge is a spring (which I was working on because I was making a game that involved hexagonal patterns and which I wanted to have some nice juice - I ended up scrapping this bit of juice though). But then, with that springy connectivity, initialize all the points to be at the origin. You should get this insane big bang/stereographically projected grid effect seen here.

This image was created while working on extensions for the raytracing software tracey as part of a university course. When building a volumetric light effect (rays of sunlight reflecting on dust particles in the air), there were various parameters to tweak for making the dust look like intended. Beginning with large amounts of opaque white dust, it looked more like a snowstorm at first. Which has its own kind of aesthetic and makes the sunny church scene look more like ruins on a postapocalyptic winter’s night.

This is meant to be multi-colored volume-rendered god rays. Although I certainly didn’t know those fancy words at the time! It uses software rasterization and is written in SDL. At this point it should mostly just have looked black but I think that a lot of the pixels had a whiteness value that overflowed, and the pattern of overflowings is what you see here. I am pretty sure that the value that the whiteness each pixel was getting was basically coming from the number of rays originating from the center that passed through it?

This was when I was first making a 3D model of a molecule, to go into the software that is my PhD project. What’s happenning here is simple to explain: you should be seeing a few hundred spheres, most of which are connected to each other with cylinders. For atoms A and B, the way I was programming those connective cylinders was:

  1. Make a cylinder whose length is the distance between A and B
  2. Align it to be parallel to the line segment connecting A and B
  3. Reposition the cylinder so that one of its ends is touching A (therefore, implicitly, its other end should touch B)

Buuuuut, step 3 wasn’t working - this meant that all of the cylinders were sitting with their one end at the origin :)

There is a regular icosahedron in there and I am pretty sure the petals are meant to be a net that “wraps up” to become the icosahedron.

This has a similar origin to Icosahedral Flower, but with some spherical projection. I think the projection center was at the origin, or at the corner of each triangle, when it was meant to be somewhere else - not sure though!

This was part of a data visualization around train positions. The image shows multiple Voronoi analyses, accidentally drawn on top of each other using QGIS. You can learn more about the background and about spatial databases in this article.

These graphs were made by mistake because the trigonometric functions were graphed in radian mode, while the rotation about the origin was in degrees, so the conflict of the two yielded interesting gaps and patterns.

Psychedelic Ride

SPokDev, 2019

SPokDev is developing a racing game, and was writing a post-processing effect that maps certain colors to another from a gradient texture. Accidentally using a noise image produced this result.

Chaos Center

Laura Klünder, 2017

This was a rendering bug caused by reading the xyrgba property in an OpenGL shader (instead of xyzrgba). Laura encountered this bug while developing c3nav, an indoor navigation system for the 34th Chaos Communication Congress at the Congress Center Leipzig.

This happend when 2DArray used a Signed Distance Field technique for rendering 3D scenes for the fantasy console PICO-8. A broken lighting operation caused the wrong color indices to be picked.

Out of Line I-IV

LambdaTotoro, 2020

These pieces were created by a buggy version of Variations on Variations, a python bot for Mastodon that creates images inspired by Max Bill’s Variations series.

So it was always meant to generate art, but it did so very incorrectly. Angles don’t line up, colours are not unique, some polygons escape the boundaries entirely, it’s all a bit messed up. However, I also liked a few of the results for their own sake.

In university, I took a course where we implemented our own ray tracers. For a homework exercise, we had to implement texture support, and were supposed to interpolate large textures, so that they wouldn’t show up pixelated in the result. I don’t remember what went wrong.

During the simulation of galaxies, the visualization of the overall forces acting on the individual stars failed after the length of the vectors was miscalculated. The colors can be seen as the intensity of the force acting letting the vector itself only display the direction of the force acting.

While creating a Barnes-Hut-Tree for a galaxy-simulation, the position of new child cells broke after their position was offset in on a wrong way: (new center = old center ± width / 2) instead of (new center = old center ± width / 4).

It was an accidental image decoding glitch that produced these interesting and very colorful patterns, produced by gpu_jpeg2k, a JPEG 2000 codec library using CUDA for fast GPU-based de- and encoding.

Due to a bug in the file reading and parsing code, it ended up reading invalid data, causing colorful glitch art.

Traversing Berlin

Daniela Berger, 2018

I wanted to use the GTFS data of the public transport association VBB to create art about the Berlin public transport system.

I extracted the latitude / longitude of each traffic stop to use them to create paths in a SVG file.
All stops in Berlin lie between around 52°N 13°E, so I could drop the first three chars (“52.” and “13.”) and use the next three chars as coordinates in a grid.

I poured the data into my SVG generator, and this image was the result :-)
It has been pointed out that it illustrates very exactly what Berlin traffic feels like, but still…

I later found out that I had messed up the substring by throwing away the first four chars and then using the next three chars for the points in the SVG.

Galaxy Smoothie

Raphael Michel, 2017

This happened while trying to smoothen the image of a galaxy using a convolution kernel that turned out to be completely denormalized.

Floating Robots

Raphael Michel, 2017

The coordinate system for the robot’s movement were mixed up when simulating a walking movement.

Credit for the robot model is due to to Yue Hue and ORB.

Displacement Chaos

Michael Pucher, 2017

When performing finite element statics analysis, one aspect of interest is how components of an object are deformed under load, each vertex of the model has a corresponding displacement in the x-, y- and z-direction. The displacements are added to the actual vertex coordinates and one displacement component is being used to color the model. This is were the bug comes in: the nodes are being stored in a particular order, with subsequent nodes being kinda close to each other on the model. Now if there is an off-by-one error in the code that stores the displacements in the vertex buffers, the color of the nodes will be somewhat correct, while the displacements are being applied in the wrong places.

I was simulating waves with a bounding box by shoting particles in all directions, and I forgot to convert milliseconds to second, making the simulation time steps 1000 times too big, explaining the behavior.

Disco Time

Jakob Runge, 2013

This was the result of a force directed graph drawing algorithm. Nodes are initially placed randomly and spring-like forces are computed between each pair of nodes. To minimize these forces, nodes are moved, which often results in a cleaner graph picture. When moving the nodes, Jakob forgot to clean old edges that had been drawn, and just added new edges, resulting in series of similarly positioned lines of the same color.

Here’s the intended, final result.

The Stanford Iceberg

Marc Kassubeck & Sebastian Morr, 2012

This happened when we were working on an assignment in a real-time computer graphics course. We were supposed to draw the Stanford Bunny using OpenGL’s Vertex Buffer Objects, but it seems we got the indices wrong! You can kind of see the shape of the bunny’s ears and nose, though!

This series of images was created when I was working on packing problems. The task was to find an algorithm which could always place the provided circles inside of the triangular container without overlapping each other. As you can see, many strategies were unsuccessful! :)

The drawings were done using SageMath.