Using EXE files to create found audio

Turning data strings like DNA and what-not into audio can produce interesting results. YouTube user r2blend says, "If you import an EXE file into an audio program as audio data, you hear all kinds of cool stuff. The most awesome by far for me was MS Paint." Fisco130 then made a club remix of the MS Paint data audio. Wonder if any scans of great works of art contain secret music? Does malware translate to sad trombone sound, or Rick Astley? [Video link]


  1. That was surprisingly excellent. Can anyone understand (and possibly explain) why there are entire sections of repetition w/ variation?

    1. Most programming is based on If/Then and Do/While statements, testing for different input and deciding what to do. In this case, I’m betting that many of the statements that make up Paint are repetitive with minor variations. Since the executable is the compiled result, it would be changed slightly, but I believe that some of the original structure would be maintained.

    2. Here’s my guess at the interesting repetition-with-variation effect

      Often a program will contain routines for doing a whole bunch of things that are very similar but not quite the same (in the case of MS Paint, e.g., dragging the mouse with the paintbrush tool, dragging the mouse with the pencil tool, dragging the mouse with the rectangle tool, etc).

      The godawful and unmaintainable way of writing that would be to copy and paste the body of the routing, and edit each copy for the specific tool. When compiled, this could result in a whole bunch of nearly identical sections of executable code.

      The more elegant way of writing it would be to have functions that try to isolate the common elements of all those routines, and then the similar routines would handle the specific unique parts of their actions, and all reference the one routine for common aspects. This way of writing the code is much more maintainable – a change to the common aspect of the routines can generally be made once, rather than in X different places.

      You might expect this to eliminate the repetitious nature of the compiled code, but it wouldn’t always.

      There is a performance cost associated with jumping to different locations in memory – the CPU will have queued up sequential operations in very fast memory, and jumping to a different spot will often require it to throw away everything it has queued, and refer to lower-speed memory to get the new instructions.

      For that reason, compilers will often make executables that reverse the elegant coding practices I described above – they will stick exact duplicates of the same code in each place where the a common function is reference, so as to reduce the frequency of control flow jumping to different memory pages. This can speed up performance, at the cost of having larger executable files.

      1. That’s what I was thinking. Lots of functions that look the same, possibly due to (as mentioned above) macro expansion or using a LOT of inline functions.

        Or possibly a lot of only slightly different arrays.

        It’s interesting to consider that a modern CPU is consuming this “data” at greater than gigahertz speed while the audio player is relatively plodding along in the kilohertz range.

  2. We used to do this when we were kids. Our Atari 800 had a cassette tape reader as an input device, and our only game for it, Zaxxon, sounded excellent when we played it through our tape recorder.

  3. This is awesome.

    I once played a .zip of an MP3 in a media player and all I got was 13 seconds of a weird ethereal song.

  4. Back in the 90’s I would import .exe files and anything else I could into Photoshop for creating interesting visual noise to then layer on top of what I was working on.

  5. yep, if you open binary files as audio, you can get some pretty cool sounds. not just EXE files, either: i personally recommend uncompressed image files.

    here’s an in-depth blog post i wrote about this back in ’09, complete with instructions on how to do it and even how to take it a step further!

  6. There is a Japanese named Ryoji Ikeda who has been doing similar work converting data into video and audio works. I’m not really sure of what techniques he is using but his stuff is really interesting.

    I have been listening to his Dataplex CD while wandering around the city at night recently. It makes a normal night out seem like a Neil Stephenson novel.

  7. But how to parse the data? PCM, I presume. 8-bit? 16-bit? Stereo? Mono? 22, 44, 48kHz?

    I’m reminded of those Bible code nutcases who are looking for a certain kind of result, then tailor the steps used to analyze the data until they get what they want.

  8. And as for what causes the similar-but-different repeated sounds: My guess is macro expansion. If they have big-assed macros in their code, it will expand to the same instructions with different data. When the instructions are the same but the data is different, it sounds overall similar but not quite the same.

    That’s just my guess.

  9. Actually, the mistery of the regular patterns is pretty simple. You hear the random noise at the start, that sounds exactly like I expect unaligned machine code to be, ie, a random mess. Then the largest part of the file are resources for that application, including all the icons and buttons in uncompressed format – that’s what provides the regular “beats” as they draw the mostly empty and regular boxes. As you might expect, Paint has many of these, for several resolutions and bit-depths.

    1. One type of file nobody has mentioned that can make interesting listening is log files: there’s usually enough repetition of log messages for your ear to pick out a tone. I discovered the Windows 95 boot log sounded pretty interesting this while working on a song for my music composition class back in high school…

      Takashi has the right idea with the image resources, BTW. The arpeggio effect is because the image resources are icons, and each icon has several different size variants (from 16×16 through 64×64): the pitch is related to image width. Yes, I opened mspaint.exe in a resource editor to double-check. Code templates wouldn’t generate anywhere near that much data unless the programmers were doing something *really* wrong.

      You might see that kind of repetition with old shader programs that need to be parameterized and recompiled for performance — I’ve seen hundreds and thousands of variants generated in a shipping game — but not in plain ol’ C++.

      1. bwcbwc, while grabbing a random piece of music and turning it into an working exe file is a literal monkey writing the complete works of Shakespeare, several bands released audio tracks that were actually executables (for 80’s microcomputers, mostly ZX Spectrum):

        This still carries on, with I think Apex Twin having odds and bits of Spectrum audio and I think a Beck song as well.

  10. This takes me back. In the college dorm, where we were all looking for various “entertainments” from time to time, we hit on placing a programmable calculator, running a looping program, on the turntable of a stereo system with a tape deck and a tuner. Finding an appropriate station (where nothing was actually being broadcast), we would hear the electronica piping out of the calculator. Some of those calculator music tapes were actually fairly listenable. I believe the regular beat attributable to the 33 1/3 rpm input oscillation was helpful, and the loops of the programs added a nice bit of hemiola to the mix.

  11. Most of the windows games sound the same. Internet explorer exe files make some interesting noises

    1. Checked the comments just to see if someone had mentioned Dirk Gently yet. That reveal was a sublime moment in fiction.

  12. that’s some lazer crunk ish. all it needs is an 808, lil jon on backing vox and some candles and you’ve got the soundtrack to a very sexy time.

  13. Conversely, I wonder what would happen if you stuck an exe header on say Pink Floyd’s Dark Side of the Moon and tried to run it? I wonder if there are any musical (or video) works that can run like this without actually crashing.

  14. Whoa, listening to this brought on flashbacks to long gone days working maintenance on NORAD support mainframes. Thousands of neon bulbs (+65vdc forward bias to illuminate) lighted their refrigerator-sized cabinet faces and units were tested via magnetic tape routines.

    Midnight-shift room lighting was always dimmed and speakers cranked to maximum as maintenance tapes looped through two-hour test routines. We’d sit as neon flashed in choreographed marches following the beat of each test as subsystem audio sang strange but individually memorable test-chants.

    Listening for system problems in test rhythms & watching those ones & zeros dance around the room was an experience I will never forget. My kids don’t understand what I mean when I tell them computers haven’t been the same since they took out the neon.

Comments are closed.