Hi, I'm Chad and I make things. I've been playing guitar and writing music for many years and earned a bachelor's degree in music composition along the way. Much of that music has been written with my brother Curtis in some form or another. While studying for my master's in electronic music at Mills College (and learning from some rather amazing people) I was introduced to SuperCollider. Ever since I've been furiously programming and figuring how to combine these things, usually while being very noisy. Currently I'm finishing my PhD in music informatics at the University of Sussex under the supervision of electronic luchador Nick Collins. When not creating potential thesis corrections I'm often performing with the band Glitch Lich, brewing beer with my wife Jessica McKinney, and programming way too much.
To play the media you will need to either update your browser to a recent version or update your Flash plugin.
As a composer and performer I've made music in many different contexts ranging from harsh electronic noise to Javanese Gamelan. I've been fortunate to be able to play and learn from some rather amazing people over the years, all of whom have had an influence over the music I write. Across these different mediums there is always some thread of experimentation and discovery informing my approach. I think music is often just more fun and interesting when you don't always know what's going to happen next. Lately I've been focused on using feedback, algorithmic structures, and interdepedancy in some capacity, both in electronic and acoustic works. In addition to the tracks on this page you can also go to http://www.glitchlich.com/ to hear some more music with my laptop band Glitch Lich or go to my sound cloud to hear some older music from myself and my brother, Curtis McKinney. You can download the mp3's available on this page as well as some other tracks from my old band Crab Cannon from this link here. Thank you for listening!
My projects are varied in use and scope, but in general they are mainly concerned with interactive systems. You can look through my portfolio above to see some examples of my work as well as look through my github account to see the full projects. I've learned something from all these and have been growing as a developer in the process. For this reason the code quality varies between projects, but I'm proud of it all.
Overview: C++ Library for various generative functions including Wolfram Automata (standard binary and multi-colored), Conway's Game of Life, 2D and 3D flocking, 2D and 3D Clifford Pickover Strange Attractors, and L–System fractals. The library also defines a set of geometric and mathematical classes and types to facilitate this functionality.
I've been using various generative and procedural techniques for years and found myself reproducing similar code in several projects. To prevent this from happening in the future I decided to bundle up the code into a small and lightweight package that doesn't rely on anything else except for a bit of the STL. This make it easy to use in different projects that may already be dedicated to a particular set of libraries or frameworks. For this reason I've used this in a few projects to do many different things including generating meshes, voxel geometry, drum sequences, and melodic patterns. The code is some of my cleanest C++ with well documented headers and concise but powerful functions and classes. The video above shows the demo project found here along with some ambient music from my band Glitch Lich. This demo code just shows various ways to use the library and uses Cinder and OpenGL for the graphics implementation.
Overview: An Interactive 3D environment for electronic music collaboration. Written in C++ using Cinder and OpenGL for graphics, SuperCollider and libSC++ for audio, and OSCthulhu for networking.
Shoggoth is one of my largest projects and was written as part of my PhD on collaborative music systems. It was my first effort towards creating a 3D interface for music performance and as such was a large learning experience. It is also for this reason that the code is a bit of a mess. There's several dead ends, many commented chunks (in case I changed my mind about something later), and confusing and overly complex implementations. That said the system works well and has been used in several live performances such as the video above from the Glitch Lich performance at the Network Music Festival in 2013.
The system is based on using four islands as step sequencers like in a drum machine. Players fly around using fist person shooter style controls and can manipulate the islands using several different algorithms found in my Artificial Life library. Loops can be created and destroyed using 3D picking implemented with a clever technique using an FBO and dawing triangles identifiers as colors. By finding the color at the center of the fbo a simple lookup finds the triangle. This provided a tremendous speed boost over my previous ray casting based attempt because each island contains 10,000 triangles. The networking does simple server based synchronization but because of the large size of the islands the actual meshes are not networked. Instead the algorithm (identified as an enum) and the parameters used with it are bit packed into a single integer. This makes the system work well even with poor quality wireless internet.
Live coding is an exciting new approach in electronic music. Live coders create performances by writing code to generate music in real time; manipulating, adding, deleting, and occasionally crashing, all for the audience to see. The TOPLAP (Terrestrial Organisation for the Proliferation of Live Artistic Programming) has a manifesto that can best be summed up with the phrase Show us your screens. I've long been interested in this approach but had never done much with it beyond some brief experiments. I decided that I should really get in on this live coding thing as there's some fantastic work being done with this approach. I considered what would make a live coding collaboration as easy as possible and decided to try the Web Audio approach. There have been several other web based languages such as Gibber, but I wanted to make something that was entirely focused on networking and collaboration.
I haven't done an official release (this is coming soon though) and have not made any big push for visibility (although a proper paper is due to be published for NIME), but it's already my most popular repository on GitHub. The code grew tremendously and changed wildly from the initial implementation. I tried many different things including writing the entire language using Continuation Passing Style and then undoing it because the performance drop was too great. The language is still buggy and lacks some features, but my band Glitch Lich has had several performances (such as the video above at an Algorave in Tokyo) and we have more coming. This is a project that I look forward to hopefully growing a community around and contributing to for years. If you want to try it out for yourself, you can find a small demo here
Overview: Mutli-user instrument for creating and manipulating audio feedback networks. Mainly written in C++ using Qt for the user interface, Cinder and OpenGL for graphics, SuperCollider and libSC++ for audio, and OSCthulhu for networking.
Feedback has always been something I've been attracted to. Perhaps I just like really noisy music, but when done just right feedback based systems become organic and start to behave in interesting and surprising ways. I created Yig to enable collaborative performance using these kinds of feedback networks. This is one of my earlier C++ efforts and for that reason the overall code quality isn't the highest. For example the network layer interacts with the main core logic in a different way than the main user interface does, instead of using some well defined controller (such as in MVC) or interface. For this reason the early versions of Yig were prone to crashes and bugs. After a year of continued patching and work it's become very stable and has seen the most performances out of all my music systems to date.
Overview: Mutli-user instrument for beat based music performance. Written in C++, Cinder and OpenGL for graphics, SuperCollider and libSC++ for audio, and OSCthulhu for networking.
Simulacra is a system mainly developed by my brother Curtis McKinney, but I was involved for the audio system implementation and I also did the Linux port. The user interface is exactly what is shown in the video, which makes it so that the audience can see exactly what the performers are doing while at the same time retaining a highly artistic presentation. We became more interested in this approach, which is also used in my Shoggoth project, because it provides a nice solution to both having visuals and letting the audience in on the actual performance. However, Simulacra did not start this way. It began with a different program written with Qt that communicated via Open Sound Control messages to the graphics and looked similar to a digital audio workstation (DAW) such as Pro Tools or Logic. That interface proved to be both incredibly cumbersome to use as well as buggy. As an experiment we decided to add keyboard and MIDI input to the graphics program to see if it would work well as the user interface in addition to the graphical projection, and it worked better than the old DAW version. This also made setup easier for performance as setting up mirroring with a projector is much faster and less error prone than negotiating different screens and windows with various possible resolutions.
Overview: Bit Torrent based sound art installation. The main system is written in Java using Processing for graphics and communications with SuperCollider via Open Sound Control messages for audio.
Leech is a sound art installation that explores the ideas of copyright and intellectual property in the age of the internet. Throughout the installation the Leech program torrents the most popular album on Pirate Bay and begins playing back modified versions of the songs. Each packet that is transferred is sonified and the locations of the leechers and seeders in the torrent network is visualized on the glowing map. The graphics were mainly developed by my brother Curtis McKinney, but I was involved with the audio implementation. This is an older work and the code is a bit immature, but we ended up with a great looking and sounding installation that has had good reception.
Overview: First person exploration and puzzle game using procedurally generated environments. Written in C++ using the Ogre3D SDK, Bullet for physics, and using Lua for scripting.
Entropy is another collaboration with my brother Curtis McKinney, this time in the form of a video game. I've made small game projects before, but this project was more ambitious than all of them. Because of the large scope we never finished the game, but it is still one of our largest efforts and includes procedurally generated voxel terrain, a nice custom water shader, physics with collision events, a hacking mini game, a grappling hook, a quest system, an inventory, custom level generation with file saving/loading, and even a chatbot that you could talk to. The code isn't perfect, but there's some nice solutions to be found. I'm particularly happy with my collision event system that uses bit masking to identify potential collision actions. This made our physics implementation much more efficient, which was critical as it was one of the most CPU intensive parts of the code.
The voxel maps were created using data generated from my Artificial Life library and gave the environment a unique look. While the project never shipped, it was a large learning experience. It was my biggest project using an established game engine and it made me consider how to make a game or interactive system when thinking more from the top down, using more developed systems for actors, meshes, and compositors. Previously my systems were developed using mainly Cinder and OpenGL, which allowed for more customization, but were much less developed and powerful.
Overview: 2D cyber punk hacking game written in C++ using the Ogre3D SDK.
This game, another collaboration with my brother Curtis McKinney, was born out of the efforts of another game project of ours called Entropy. When it became apparent that Entropy was far too ambitious to finish in our spare time we decided to switch gears and try to make the hacking mini–game into its own small game. However, soon after beginning working on this project my brother finished his own PhD studies and became a full time game developer, leaving our little project to never be finished. While it didn't get finished there was some interesting developments including a well fleshed out hacking system and a nice glowing text terminal emulating shader that hearkened back to roguelike games such as NetHack.
One of my favorite contributions was my A* path finding implementation. Previously I had used an old open source implementation that I had found from the late 1990's, but I never liked it because it was written using incredibly large functions with vast amounts of repeated code in deeply nested for loops and if statements. It also heavily relied on the use of heap memory which I felt was unnecessary for the task. So for this game I decided to make a nice stand alone namespace for A* path finding with support for various heuristics. The implementation (found here and here) is well documented with the logic broken up amongst a set of typedefs, classes, and functions. It reduces heap allocation by using an unordered map with simple integers for keys and the potential path nodes as values. Each node object in the path retains its parent node's ID as well as it's own. If the target tile is found, the chain of parent ID's is collected until the origin node is found. No pointers to heap allocated memory and no need for de-allocation to clean up. The result performs well and we were able to have many instances running with no issues or memory leaks. It also only takes up 600 lines of code, with a large percentage of that being Doxygen comments.
Overview: Haskell library for communicating with a SuperCollider scsynth server using Open Sound Control (OSC) messages.
After working on several large C++ projects and experiencing issues with code complexity, especially in multi-threaded contexts, I became interested in learning a pure functional language. I chose Haskell because it looked to be the most brutally pure and I preferred the syntax over the various Lisp dialects. The way I learn things is by working on a project and so I decided to make a Haskell client for SuperCollider, similar to my other library libSC++. This was a good choice because it was small, with a well defined set of functionality, and I had already created a C++ implementation for reference. I finished the project within about a month in my spare time and by the end I felt confident in what I had learned about Haskell. I haven't had the opportunity yet to use it in a larger project because I have been focusing on Lich.js as a component of my Phd. When I return to native programming (which I do look forward to!) I will likely try using this in something similar to Shoggoth or Simulacra.
Overview: Server and client framework for synchronized networking using Open Sound Control (OSC) messaging.
This is collaboration with my brother, Curtis McKinney, that was made to fix the networking in our band Glitch Lich. Previously we had been using another server and client system named OscGroups but we had consistent issues with dropped packets or blocked ports. The problem with OscGroups is that while it uses a server to maintain client information, all traffic is still peer to peer. OSCthulhu solves this problem by routing all the traffic through the server, preventing issues with blocked ports. Additionally we added a synchronization interface to the communication channels which we've used for several years in many different systems. OSCthulhu has seen performances with users spread out across the entire globe and has maintained functionality despite long distances and intermittent connections.
This is a set of audio unit generators (UGens) made to be used with my Yig music system, but they can also be used with any SuperCollider installation. This is one of my first real experiments with low level audio DSP and contains some interesting functions. The collection contains several UGens for Clifford Pickover Strange Attractors in 2 and 3 dimensions with several variations of interpolation methods (none, linear, cubic). Subsequently I've delved further into DSP but this project was a good starting point.
Overview: Small C++ library for linking to and using the SuperCollider scsynth server internally as a separate thread in a C++ application.
SuperCollider was actually the first programming language I learned many years ago during my master's degree at Mills College. Ever since I've had a deep love for it, but because I became more interested in 3D graphics and OpenGL I began using C++ for most of my work. I was still interested in utilizing the power of SuperCollider and so I developed this library that allows a project to bundle up an internal scsynth server using the libscsynth library as well as adding an interface for creating and manipulating synths. Normally SuperCollider runs as two distinct processes, a VM for the SuperCollider language (sclang) and another process for generating audio (scsynth). The language communications with the server via Open Sound Control (OSC) messages. My library allows a program to forgo the use of sclang and include scsynth as a separate thread in the same process. This is much preferable for binary distributions of programs written in C++ and has been used for several years in many of my projects. The code is a bit messy as my original scope was much larger, however I settled on a smaller subset of sclang to reproduce and now there is some dead ends in the code that should be cleaned up. Regardless, the code works well and has been incredibly useful to me since I made it.
Currently I'm finishing up my PhD research at the University of Sussex where I've been lucky enough to be supervised by Nick Collins. My dissertation is focused on visual representation and communication in collaborative music systems. Over the past few years I've published several papers that look at this subject in various ways and often my code projects are born out of this research. Below you can find a collection of my papers to read.