After mastering the basics of developing software for Mac OS X, I decided to swing for the fences with a big project. I was becoming interested in digital art and photo editing, but as a young teenager all I really had access to was stuff like MS Paint and office software on my parents' computers. For example, I made the icons for my first few apps by laying out shapes in Pages '09 and screenshotting the result. Of course, I knew about more advanced software like Photoshop, but from what I could glean of how those tools operated, they seemed shockingly untuitive and limited compared to what I expected.

So I had this brilliant idea: I would simply make my own program! My goal was to creating one unified product that would give you the same level of control over both vector data (shapes, paths, etc.) and raster data (pixels), handling both in a fully non-destructive fashion. Part of me would ask in hindsight, "what were you thinking?!", but I don't regret the time I spent on this. I learned a ton and had a blast taking complex ideas and bringing them to life before my eyes.

In the digital realm, the concept of a "destructive" operation includes real-world analogues like deleting files (or content within a file), but the core idea goes much deeper than that. It's really about the permanence of your actions. In the real world, when you lay down a stroke of paint, once it dries, that's it. Depending on the type of paint, you might be able to scrape it off, but probably not without damaging whatever's underneath. Software gave us abstractions like independent layers and undo/redo features, but even those still carried significant drawbacks. For example, if you make a mistake and paint on the wrong layer, it would overwrite image data you meant to keep and the only way to get that back would be to throw away all of the work you had done before discovering the mistake. The whole point of software is that it's not bound by the mechanics of the real world. Why should we accept limitations like this merely because we're used to them?

Initial development (2012-2015)

Putting these ideas into practice, the software wound up being essentially a vector tool with extra steps. Actions you could take that would be destructive in another program were all saved as individual layers or adjustments, and source data like images pasted in from elsewhere were always saved in their original form and only modified on the fly.

I was still very new to complex programming, and I had to learn and figure out a lot of stuff as I went. Unfortunately, by running with the first technologies I found that seemed to work, I set the project up for failure without even realizing it at the time. The Core Graphics framework, designed for drawing buttons and text and other things used for the UI of a program, turned out to be a very poor fit for the primary rendering engine of an image editor. Sure, it was very easy to control and interact with, but I eventually figured out that was because it ran entirely in a single thread on the CPU, instead of the massively parallel architecture seen inside a GPU that enables it to process large amounts of data efficiently.

As I got further into development and needed to do more intricate things with my images, I started adding features from the Core Image framework. This software WAS capable of running on the GPU, but only if you used it correctly. Commercial applications like Pixelmator successfully took advantage of this (in fact, basically its entire list of filters was really just the Core Image stock set provided by Apple), but my Frankenstein's monster of an engine wasn't capable of such finesse. Rendering a full stack of layers and effects could require multiple round trips between the two frameworks, and at its worst the app would literally hang for several seconds just to draw your work once. Drag a slider around, hide a layer, it didn't matter. Any time the screen needed to update, you had to wait.

I made some attempts to optimize things, such as calculating the bare minimum area that needed to be redrawn and only doing that portion, but none of that could address the fundamental problem of rendering simply being so inefficient. Even if I kept working and got the software into a feature-complete state, there's no way I could release it publicly with performance as bad as it was. So I quit working on feature development. With just the move, select, pen, and shape tools fully usable, the app was well short of my vision but still somewhat functional enough to use for personal projects, like producing the graphical assets for Coffee Buzz and my first website.

Confronting the sunk cost (2015-2019)

In late 2015, I set everything aside and started over with a clean sheet and a rebrand. Since beginning the project originally, the state of the OS X ecosystem had advanced considerably. Instead of building every piece of the user interface in an individual file, I could assemble them into storyboards, making the relationship between each part more clear. Instead of working with the aging and clunky Objective-C programming language, I could write tidy, elegant code in Swift. And instead of finally having to figure out how to use the OpenGL graphics library, a new lighter-weight system called Metal was now available.

Now that I knew what pieces were needed to build an image editor, I decided to take a different approach and ensure I had a solid foundation to build on top of this time around. Unfortunately, I overcorrected. I spent way too much time refining the file format, thinking about the process for reading and writing it, building extraordinarily robust systems for handling compatibility or corruption issues, and so on instead of just biting the bullet and starting to learn the important fundamentals I'd need to build aboveground once again. To this day, I still haven't touched serious graphics programming or other topics like how color profiles really work under the hood.

This whole time, I was also busy working on my college degree. By the time I finally finished that and had a better understanding of how much work would be required, the cost/benefit no longer made any sense at all. And after entering the professional workforce, I largely gave up programming as a hobby altogether.

My dream of making the perfect piece of software was dead, but thankfully I wasn't the only one who had this same idea. While I was hard at work on my first attempt, Serif Labs released the original versions of their Affinity suite: first Designer, then Photo a year later. While the two were distinct products, with feature sets kept separate for marketing reasons, files from either tool were fully supported by the other, showing that under the hood they both used the same engine. I've been happily using the Affinity products for years now, and Serif's acquisition by Canva and the subsequent consolidation of Affinity into one piece of software finally realized the vast majority of what I wanted to create to begin with.