Before it was even October, my kindergartener son decided we ought to decorate for a truly spooky Halloween. Our concept: a scary cauldron which kids reach in to to retrieve their candy, complete with smoke and lights.

I took it upon myself to start on the (often overlooked) sound design. Spooky audio is an important component of any scary display or haunted house, and with today’s portable speakers, it’s easy to add. I’ll be placing a couple of small wireless speakers outside to play music and scary sound effects. As you might have guessed, I plan to use Rogue Amoeba apps to help.

Making Background Music

First up, we need some creepy ambient music. Finding something pre-made online is easy, but it’s even more fun to make this ourselves. I previously used GarageBand to make the example music loops we ship with our soundboard app Farrago, so I knew it would work well here too.

I started by making a new GarageBand project in a minor chord, and set the tempo to the slowest possible speed, five beats per minute (BPM). Then I added a bunch of loops and turned up the reverb. In about half an hour, I had made a pretty decent backing track. Almost everything sounds creepy at five BPM, so a little trial and error should be enough to arrive at something suitably unsettling.

Everything sounds eerie with these settings in GarageBand.

Samples like Bells, Choirs, Pads, Organs, and Vox all seem to work well. On top of that, the pitch-shift, echo, and reverb filters are useful to make them sound extra spine-chilling.

I encourage you to experiment and make your own audio, but you’re also welcome to use my audio file.

Here’s a short excerpt so you get the idea:

To get the whole file: Click to download (15 minutes, 11 MB)

Setting Up Sound Effects with Farrago

The music will serve as a backdrop, but I also want to be able to play spooky sound effects on demand. Here’s where our soundboard app Farrago comes in. I downloaded a bunch of sound effects from FreeSound.org and put them into a new set in Farrago.

First up, I added a bunch of on-demand effects. These are unsettling growls, howls, and cackles which I can play at random. I then added a bubble sound effect, to help sell my cauldron. Finally, I put in the spooky music file I made in the last step with GarageBand. I set the music and bubbles to loop, so they’ll provide he backing track and run continuously.

One great advanced feature of Farrago is MIDI triggering, which I’ll use to avoid the need to carry my 27” iMac to the front door of the apartment. The iMac can instead remain on my desk, running all the audio behind the scenes, while I control it remotely with an iOS MIDI trigger app on my phone.

I’ve set up an app called TouchOSC to control Farrago, though most any MIDI app should work. If you need help getting your iOS device talking to your Mac, this link should help.

Sending to Speakers with Airfoil

Farrago isn’t the only Rogue Amoeba tool I’ll be using. I’m also going to use our home audio streamer Airfoil to wirelessly send the desired audio from my Mac to speakers set up outside my front door.

The two speakers I’m going to use for this are my HomePod and a bluetooth speaker. Airfoil is a big help here, as it can send in sync to both bluetooth and AirPlay.

I plan to set up my speakers around the entrance to my house, and then set them as outputs in Airfoil, with Farrago as the source. Streaming audio using Apple’s AirPlay introduces a slight lag, but it should be plenty speedy enough to get some good jump scares.

In Airfoil, I just select Farrago as my source, and then click the Transmit buttons next to my desired outputs.

Audio is now streaming to my HomePod and Bluetooth speakers – perfect!

Getting It All Together

At this point, I have everything I need for the 31st. When the time comes, I’ll set my custom creepy music and bubbles playing on a loop, and use the MIDI app on my phone to trigger sound effects remotely. The sound coming from multiple sources in sync creates a very cool effect, like the sound is coming from everywhere, and is going to help sell the creepy vibe. A smoke machine, coloured lights, and creepy decorations from my son will bring it all together and make good creepy fun for all the neighbourhood kids.

Happy trick or treating!

While working on the recent launch of Airfoil 5.8 (with Sonos support!), I wanted to visually convey the idea of wireless broadcasting by using the tried-and-true pattern of concentric circles. To really sell the effect, I wanted these circles to animate when the mouse cursor was hovering over them. This took some doing, but a bit of inspiration from my childhood got us where we wanted to be.

Getting Started with Gradients

The easiest way to display concentric rings is a simple radial gradient, done in CSS. CSS gradients are a lightweight way to add all sorts of visual patterns to the web. This means not just the smooth gradual changes between colours generally associated with the word “gradient”, but also lots of other repeating patterns.

This is the desired look, but I really wanted these radial circles to move.

Gradients are super useful, but they’re usually about as animated as a Moai. Unlike many other web elements, you can’t just set the start and end states, then have the browser interpolate out a smooth animation. I expect this will one day work in the major browsers, but for the moment it’s not supported.¹

Stop Motion Inspiration

To get the animation I was after, I reached back into my childhood. Long ago, in the days of VHS, I made stop-motion animations with my family’s clunky camcorder. I would painstakingly build a tiny set and characters out of clay, then move it all very slightly, to animate a scene one fraction of a second at a time. It was arduous, but much like CSS now, I had to work with what I had.

A still frame of an unlucky Play-Doh guy getting hit in the head with a snowball, circa 1992 or so. Sorry Pixar, I went into software design instead of animation.

I realized we could put a new twist on that old stop-motion technique, by writing out CSS to create one frame at a time, then using the animate function to cycle through them. It would work a lot like those old animations I used to make, but with the “frames” created from code instead of images.

Animating with CSS

Doing this in CSS requires two steps. We first defined our frames using the @keyframes function. After that, we applied the animation to our banner with the Animate function, which defines how the frames will play.

Step 1: Defining The Necessary Frames

The good thing is that the CSS needed to generate each frame of our animation was relatively straightforward, though quite repetitive. We simply incremented the progress count by 2%, and the radius of the ring portion of the gradient by 1px each frame. My co-worker Lee made a quick script to brute-force generate the 51 frames in our loop, which we then placed in the related CSS file.²

I won’t show all the frames here, as there are too many, but here are the first two frames as an example. One thing worth noting is that we actually built the animation with the rings radiating outward, because the math was slightly easier. In the second step, that animation is reversed, to get the desired effect.

Here’s the first (0%) frame of an animation I’m naming waves:

@-webkit-keyframes waves {
0% {
background: repeating-radial-gradient( 15% 50%, circle, #E5F8FF, #E5F8FF 0px, #B8DDED 0px, #B8DDED 2px, #E5F8FF 0px, #E5F8FF 52px);
}

This code may be a little complicated to the uninitiated. It sets the repeating background gradient we want, with the size of the inner ring at 0px, and a total width of 52px. We need to increment the radius of the inner ring by 1px for each frame, to make the rings move a single pixel outward (remember, we’ll reverse it later). So, the second frame looked like this:

2% {
background: repeating-radial-gradient( 15% 50%, circle, #E5F8FF, #E5F8FF 1px, #B8DDED 1px, #B8DDED 3px, #E5F8FF 0px, #E5F8FF 52px);
}

There are another 49 frames, omitted here in the name of brevity, which increment the ring size by one pixel per frame until we hit 100%.

Step 2: Making Those Frames Move

The above code creates the individual frames which will result in our desired animation. However, we still have to define how they will animate. HTML and CSS keeps the animation and the definition of how it plays separate in the name of reusability. Making this animation apply to our banner was then as simple as adding the following bit of CSS of our banner element:

.banner:hover {
animation-name: waves;
animation-iteration-count: infinite;
animation-duration: 1s;
animation-direction: reverse;
}

This last bit of code is equivalent to the playback controls, and defines aspects such as speed, iteration count, and direction. By separating the actual animation elements (the frames and instructions), from the playback controls, you could very easily apply the same animation to different elements, but with different playback parameters.

A good example of how this separation is useful is that our animation frames are built in the opposite direction of how we wanted them to run, so we’ve specified in the playback controls for them to run in reverse. If I wanted it to run the other way, or even ping-pong back and forth, I wouldn’t have to define a whole new animation, I’d just edit these playback controls.

Our End Result

Here’s a slightly modified version of the banner which appeared on our front page. To better show the effect, this version doesn’t require hover to animate:

Stream to Sonos

Airfoil now sends to Sonos’s
AirPlay-compatible speakers

As you can see, our CSS animation got us what we wanted. The concentric rings draw via CSS, and are then animated inward, representing audio streaming to these devices. CSS gradients and animation allowed me to achieve the effect I wanted, while remaining very lightweight. The frames are only about 15KB in total, a pittance for an animation in today’s world of overweight web pages.

I’m very happy with this result. This was an effect I’ve wanted before, but I hadn’t previously figured out the right approach. There’s a good chance you’ll see this technique used again before too long on our site. Perhaps you can make use of it yourself as well!

Footnotes:

1. Surprise kudos to Microsoft, because the current version of Edge does support this type of animation. ↩︎

2. 60 frames would have been ideal, to fit into the 60 frames per second most computers display. However, CSS keyframes are defined as percentages, which makes it difficult to define keyframes that don’t fit easily into 100. A bit more math may have made it possible to get the animation to take exactly 60 frames, but 51 frames wound up working quite well, with less work. ↩︎

Despite this post’s title, I’m going to start by talking about minimalism.

I’ve been at least a partial follower of the minimalist Steve Jobs/Jony Ive school of design since I was a teenager. Early on, Jobs famously lived in a mostly-empty home (as seen below), and he eventually minimized his wardrobe to the same bespoke turtleneck, Levi’s jeans, and New Balance sneakers. I looked up to Steve as a pioneer of interface design, and took on some of his minimalist ideals.

Steve probably wasn’t the best host for a movie night with friends.

Photo credit: Diana Walker

Being the son of an auto mechanic, however, I likely have a less high-minded approach to design than Steve had. I see minimalism as more of a tool than a religion. I also like to have furniture in my house.

From 1x to 2x

Minimalism in UI design most recently came into vogue shortly after the adoption of ultra-high resolution (“Retina”) displays. Decorative elements had less appeal when everything on screen looked so nice and crisp. Like many designers, I followed Apple’s lead on iOS 7, and purged my work of textures, drop shadows, and glossy finishes.

Flatter app icons in the style of iOS 7

Photo by William Hook on Unsplash

I’ve mostly maintained these minimalist ideals in my designs, but outside of work, I’ve increasingly found myself drawn to things that are complicated, chaotic, and full of surprises.

So I’d like to take a couple minutes to celebrate some great things that shun the idea that less is more.

The Sagrada Família

Seeing Antonio Gaudí’s sublime church, the Sagrada Família, in Barcelona is what first made the idea of maximalism pop into my head. I thought “I’m always trying to pare things down, but this place does the exact opposite, and it’s wonderful”.

Partial tours are available of the cathedral, which has been under construction since 1882, and at best will be completed in 2026.

One small corner of the massive church

Photo by Rutger Lanser on Unsplash

The Sagrada Família is decidedly not an exercise in removing every unnecessary thing until the platonic ideal of a cathedral remains. Instead, it is the chaotic addition of more and more, until every space is overloaded with surprises. Every single crevice of this building, inside and out, is filled with carvings, statues, stained glass, engravings, and shafts of coloured light. Exploring the building puts one in a constant state of discovery and delight.

Gloomhaven

Next is the ridiculously epic tabletop combat game Gloomhaven, which is one of the best games I’ve ever played. Gloomhaven comes in a 20+ pound box, and takes 100+ hours to complete. The total number of figures, cards, and pieces in the game is in the neighbourhood of 2000. It’s not without elegance, but it is definitely not minimal.

Some of what comes in the Gloomhaven box. This isn’t even all of it.

Photo by Darcy Pennell on Board Game Geek

Gloomhaven is the first game I’ve tried that’s worthy of the word “epic”. It will realistically take me years to finish, and even then I’ll probably only ever see a small percentage of the content in that mammoth box. Knowing there’s so much in there I’ll probably never see is actually part of its appeal.

RuPaul’s Drag Race

There is nothing subtle about this show.

I don’t much care for fashion or makeup, and my wardrobe is a muted rainbow of drab colours and earth tones. So I’m as surprised as anyone that a television show about people dressing up in gaudy outfits and garish makeup is one of my very favourites.

“RuPaul’s Drag Race” is basically an outright rejection of subtlety, with one judge even outright stating that he “hates minimalism”. It’s unabashedly over-the-top. I’m a sucker for watching skilled people do their thing, whatever it is, and this show is packed with exactly that.

Drag Race miraculously takes what could be flaws and turns them into strengths. Endless corny jokes, over-acting, and garish colours are woven into a uniquely compelling extravaganza.

Maximalism as a Tool

All these maximalist things use their expansiveness for different effects. For the Sagrada Família, maximalism creates a sense of wonder. In Gloomhaven, it gives the world an epic feel. RuPaul’s Drag Race uses maximalism to create a sense of celebration. The idea that minimalism, or any other style, is superior to all other aesthetics is silly—all of these things would be much worse if done in a minimalist style. The style of something should follow its goals.

Where Apple’s Minimalism Has Gone Wrong

While thinking about maximalism, I also got to thinking about Apple’s recent excesses of minimalism. Apple deserves tons of praise for their transformative design work, but recently, it’s seemed as though the company has forgotten why they’re pursuing things. There has been a great deal of pushback on recent designs, most notably with the finicky keyboards and lack of ports on their recent laptops, as well as a lack of progress on their pro-level Macs. There are undoubtedly many reasons for these issues, but it seems to me that part of the problem is that Apple is more concerned with making their products minimal than making them useful.

Apple is a company with strong design in their DNA. Since the days of Steve Jobs, they’ve sought to make tools that are as simple as possible, while still enabling the user to accomplish their goals. Recently, however, it seems like they’re making things simpler at the expense of being able to get the job done. It increasingly feels like Apple is following the path of minimalism because it’s something they’ve done in the past, and not because of a clear understanding of how that minimalism actually helped people work.

Similarly, Apple’s obsession with getting manufacturing tolerances ever more exact seems to have moved beyond the point of it actually bringing any benefits. A few years ago, making parts out of precision glass and aluminum led to rugged and well-wearing products. Adding an additional decimal point to their manufacturing precision seems only to have resulted in keyboards that can be rendered unusable by the tiniest speck of dust.

Apple’s recent MacBooks Pro famously cut ports and computing power in exchange for being smaller and simpler.

Photo by Bram Naus on Unsplash

I applaud their pursuit of progress in design and manufacturing, but minimalism in itself is an empty pursuit—helping people work or play should be the goal. Relentlessly cutting features, size, and especially ports for its own sake eventually leads to negative returns. People, especially professionals, have the capacity to handle complexity. We need look no farther than the wonderful maximalist examples previously mentioned to prove that.

Apple’s relentless pursuit of minimalism for its own sake was perhaps best lampooned in The Onion’s video: “Apple Introduces Revolutionary New Laptop With No Keyboard“. It was posted in 2009, but it has never felt more relevant than now.

In Closing

As far as my own design inspirations go, I still love simple things like a beautiful Dieter Rams-designed radio, or a wabi-sabi inspired garden. I live in a small apartment and try to minimize the quantity of stuff I own, while striving to keep things of high quality. Still, it’s good to recognize that not everything needs to be simple, minimal, or elegant. There is also a place for the big, the bold, and the over-the-top.

The intro video for our new soundboard app Farrago has been very well received, so I thought I’d discuss how we made it. If you haven’t seen the video yet, take just 73 seconds to watch it, then read on.

When we decided to make a video to accompany the release of Farrago, the concept we began with was very different from what we wound up with. The original video featured a montage of mostly still screenshots, with animations between them. A great deal of time was spent making ultra-high detail vector screenshots of the app, then compositing them in Apple’s Motion app.

A screenshot of the original video being animated

Unfortunately, though the resulting video looked gorgeous in 4K, I couldn’t shake the feeling that it was overly flat, even lifeless. Much work went into making Farrago a lively app that’s full of subtle motion, and the video simply wasn’t doing it justice.

Thankfully, a better idea arrived in an unexpected flash of inspiration. While I was assembling the video’s soundtrack, it struck me that the layout of my GarageBand-based project looked rather like Farrago itself, with coloured sound file blocks showing waveforms. I wondered how the video’s audio track would look if I actually brought it in to Farrago.

The GarageBand project that inspired the concept

After spending just a few minutes porting the audio over, I knew I could make a much more dynamic and effective video by simply recording my screen while I ran through a sequence of steps live in Farrago. Instead of disjointed screenshots, the new video would have a continuous flow from one feature to the next, with no cuts or editing. Crucially, it would show exactly how the app works.

I created a rough abstract for the team to review, and everyone was immediately on board with the new concept. I unceremoniously dumped most of the work from the first video and started fresh. While we kept the voiceover largely unchanged, I had to decide what exactly we would show. I took inspiration from the classic first level of Super Mario Bros., deciding that the video would slowly reveal different parts of the app. As the video builds on previous items step by step, the viewer gains a solid understanding of the whole product.

To do this, Farrago became something of an instrument, and I had to practice over and over to get the desired sequence just right: Click this tile, wait five seconds, drag in a new file, and so on. Every mouse movement and key press was deliberate, and when I messed up, I’d start again. I ran through the entire flow at least 50 times before I was ready to create the actual recording to use in the final video.

Amusingly, when I set up my screen recording software, I realized I had an audio issue. I needed to get Farrago’s audio into my screen recorder, which only accepted audio from an input device like a microphone. Thankfully, Rogue Amoeba’s own software helped me work around this in mere seconds. Using Loopback, I was able to route audio from Farrago right into my screen capture app. With that solved, I was ready to record.

Loopback saves the day!

Once I had my raw recording, I dove back into Motion to assemble everything. I added zooming and panning to emphasize different parts of the app, but nothing else was changed. Everything in the video is a real action, done in real time, in one long shot. It took many takes to get it right, but it was worth it to get the final result.

In the end, I think it was our willingness to throw away the effort we had already expended on the first concept that helped the video turn out as well as it did. When an obviously superior idea came along, we were willing to pursue it, even though it meant additional work. The end result is a video that vividly shows how the app works, rather than just telling, and viewers have responded to that.

Since I started working as the designer here at Rogue Amoeba in 2015, I’ve contributed to several major updates. However, our new soundboard app Farrago is the first Rogue Amoeba app I’ve designed from the ground up.¹ The design process for a new application is very involved, with countless discussions, hours of research, and even plenty of guesswork. A long sequence of hundreds (or even thousands) of little choices is required, with each decision impacting choices made later on. Ultimately, designing a new app feels more akin to pruning a bonsai tree than to simply drawing a picture. The design lives and grows in ways you can’t always predict.

Planning for Farrago began in 2016² with a simple pitch: “We want to provide users with a fast way to play short audio clips”. Building on that, we prepared a rough list of features the app would require, including basic playback, looping, volume control, and much more. With that, we began to flesh out what the app would look like, and how it would work. Farrago went through many iterations to get to the version we shipped late last month. I thought it would be interesting to share a look at a few different parts of our design process.

Early Sketches

From its very first mock-up, Farrago focused on easily arrangeable tiles. The rigidity of other grid-based interfaces was something we wanted to avoid. While many things changed from my initial sketches, there’s still a clear resemblance to the Farrago we shipped almost 2 years later.

The earliest sketch of Farrago I could find. The top bar and tiles were present from day one. The idea of sets on the bottom was abandoned not too much later (phew!).

Early on, we also decided we wanted to split the app into two modes: a nonlinear mode shown as a grid, and a sequential mode shown as a list. To quickly work out a basic transition between the grid and list views, I used Keynote and its indispensable Magic Move transition. This ultra-fast tool provides a quick sense of how an idea will work (or fail).

The five-second movie above shows the first mockup of the transition between grid and list views. We eventually went one step further, making the tiles follow arced paths that don’t overlap as much while transitioning.

Tile Troubles

Farrago’s UI is built around tiles, with each tile containing a single audio file to be played, along with many controls and settings for playback. My initial planning had each tile’s face containing multiple click zones to enable different functions. These early drafts show different click areas for playback, ducking, scrubbing, and editing settings.

Assorted sketches of sound tiles, with controls on the tiles itself.

A good amount of time was spent tweaking the layout of the tile face, but the ideas were all excessively busy. These sketches were fussy, filled with too many click areas and tiny icons. The design went in circles, as I repeatedly tried to cram the functionality I wanted on the tile’s face. We wound up stuck on how this critical aspect of the design would work.

There were a lot of conflicting sketches like this. We couldn’t decide how to proceed.

Ultimately, we realized tiles with multiple click areas were a dead end. Getting there, however, actually required us to reevaluate some of our base assumptions for the app.

User Interviews Cut Through the Clutter

Despite a key element of the app being up in the air, work was progressing in many other areas. Eventually, I knew we needed to figure out a way to solve the problem of how tiles would look. To break out of my rut, I decided to bring in outside viewpoints.

I reached out to my social network here in Montreal, and sought out the sort of people who might use a soundboard app — podcasters, radio folks, theatre techs, and more. I bribed several of them with free lunches, during which I showed them mockups and got their responses.

The feedback I got was immediate and consistent: Prospective users didn’t want to rely on a mouse or trackpad to play clips at all! They wanted to use their Mac’s physical keyboard to play sounds. Though I’d been focused on providing access to many controls right on the tile face, it turned out that mouse-based controls should be secondary.

This pivotal insight gave us a clear path forward, and in fact, it now forms the basis of how we expect Farrago to be used by most people. At this point, we decided the tiles would be mapped directly to the keyboard, and this would be the primary way to trigger sounds. Rather than being cluttered with on-face controls, each tile would consist of one large click area. A simple click anywhere selects the tile, while a double-click provides an alternate method of triggering playback.

The final tile design is all one big click area.

This change led us to move many secondary controls into our Inspector area. In that location, they’re still easy enough to reach, without being obtrusive.

The inspector in its final form.

Close(r) to Complete

At this point, my mockups really started to resemble the Farrago 1.0 we eventually shipped. The keyboard-focused interaction model seems clear to us in hindsight, but it took a serious amount of work to arrive there. The outside feedback we solicited was invaluable in helping us move forward.

A mock-up from spring 2017 that pretty closely matches the final design.

Zooming in on this mockup will show you the ridiculous placeholder names nobody was ever meant to see, such as “Onions” and “Fudge”. Ugh. You’ll also see the code name under which Farrago was developed: Iron Beetle.

The above mock is similar to our final product, though we still made many smaller adjustments and tweaks after this. The value of outside feedback continued to be proven during our private beta period as well, as testers forced us to reconsider more of our assumptions, and make changes based on real-world usage.

While our design was getting pretty close to what we eventually shipped, actually getting it all coded and tested would take many more months of work. From this point though, the design work was more about making things look nice, as well as solving smaller functional nitpicks.

Farrago’s Icon

After the design was largely complete, I took some time to work on nailing down Farrago’s app icon. While the design of the actual application is crucial for long-term use, the application’s icon is often the very first thing people see, and we all know how much first impressions count . Ideally, the icon should be distinctive and pleasing to look at, while also conveying something about the software itself. Farrago’s icon went in several different directions before arriving at its final form.

Most of the iterations riffed on the general idea of tiles and playback in some form. Here’s an assortment of different sketches I toyed with:

Very early rough sketches done on paper or iPad.

A key part of my design philosophy is to put designs in place as soon as I can. I created icons from these early hand-draw sketches, so we could use them in early builds of Farrago. This way, we could see how well they worked in places like the Dock.

One of the very rough hand-drawn drafts actually being used in the app.

Later designs began to look a lot more like what we eventually shipped. The final icon design started out purple, temporarily took a sidetrack into a rainbow neon phase, and ultimately returned to our toned-down final purple shade.

The design on the left looks pretty similar to the finished icon, while the design on the right shows a temporary experimentation with neon colours.

Icon design is less scientific than application design. While feedback on icon designs is useful, in the end it makes sense to just go with what feels best. After numerous iterations, we landed on the final Farrago icon. It’s not too flashy, but its distinct shape and colour make it easy to differentiate.

The final icon design is quite a bit more subdued than its livelier neon predecessor.

A Team Effort

I led the design for Farrago, but I was very lucky to be able to work with fantastic teammates. No designer wants to hear that their design is “impossible” to implement, particularly when the developer actually means it’s merely “impractical”, or even just “difficult”. Farrago’s lead developer Grant never once backed down from hard problems I threw at him. In fact, he frequently went the extra mile to make the Farrago interface really shine.

To show just one example, we could have only allowed dragging tiles into open spots on the grid. Instead, tiles dynamically rearrange themselves when needed, to make space.

As a result, you can do ridiculous stuff like dragging 15 tiles at once, and it just works:

In addition to Grant’s great work, Rogue Amoeba co-founders Quentin and Paul did everything they could to help the project succeed. They served as the final decision makers on the app, but they also gave us the time and space needed to complete the project, while keeping distractions to a minimum. Working as an ad-hoc team of four, with one designer, one developer, and two “editors”, proved quite successful.

Beyond 1.0

After many months of work, Farrago shipped to the world on January 24th, 2018. We’re very happy with the 1.0 version of Farrago, but we also look forward to making it even better. At this point, the design process will be more externally influenced. More and more people are using the app in real situations and giving us great feedback.

Over time, we’ll gather more data and discern trends in how the app is used, and how it can be improved. I’m looking forward to the next iterations of Farrago’s design. For now, we hope you’ll check out the first version of our new soundboard app, and keep an eye out for updates as well!

Footnotes:

1. In an amusing coincidence, this is not the first app I’ve worked on with the name “Farrago”. That distinction belongs to a now-defunct augmented reality app. ↩︎

2. The idea of a soundboard app from Rogue Amoeba was actually several years old at this point. Prior to my joining Rogue Amoeba, development was done on a soundboard plugin for Audio Hijack called QuickSounds. This work never made it past the early stages of development. In fact, I didn’t see it until after Farrago shipped!

   QuickSounds in all its glory, circa 2011

   While this app didn’t influence my own thinking directly, years of folks at Rogue Amoeba mulling the idea undoubtedly helped our final product. ↩︎