Use the right shortcuts to get more work done with less effort. Every time you have to redo a task or repeat a series of actions, you probably wonder
Publish date:
Social count:
Use the right shortcuts to get more work done with less effort. Every time you have to redo a task or repeat a series of actions, you probably wonder

Use the right shortcuts to get more work done with less effort.

Every time you have to redo a task or repeat a series of actions, you probably wonder if there isn't a faster, easier way to get things done on the computer. Well, with keyboard shortcuts and macros there is a way, and it won't cost an arm and a leg. You will, however, have to spend some time learning a few new tricks.

Keyboard shortcuts and macros streamline your work by putting powerful operations literally at your fingertips. With macros, a single key combination can type in an oft used string of text, mount a network server, select and fade an audio region, or process a batch of files. Once mastered, a well-crafted set of macros and a thorough knowledge of built-in shortcuts can let you work at a blistering pace and execute complex tasks in a flash.

The term keyboard shortcut generally refers to a keystroke or combination of keystrokes used to select a command instead of choosing the command from a menu with the mouse. Your keyboard's F keys and modifier keys (Command, Control, Alt, Option) are almost always used in shortcuts. There are exceptions, of course, such as U&I Software's MetaSynth, which has many single-letter shortcuts.

A macro is a sequence of commands or a script that is triggered by a single keystroke or key combination. Macros are typically created in standalone utility programs. The macro-creation program records your actions as you perform them or lets you construct and edit a series of actions in a user-friendly scripting environment. Some programs, such as Microsoft's Excel, have a built-in scripting language, but few music and audio programs offer the same capability. (One notable example is Cakewalk's Cakewalk Application Language, or CAL).


Applications typically have built-in shortcuts for most operations. Basic shortcut examples include the rudimentary File and Edit commands such as Cut, Copy, Paste, Undo, Open, Print, and New File. Music and audio programs commonly add shortcuts for functions that are specific to studio-related activities, such as zooming in or out on a track or waveform display, jumping to the start or end of a region or session, and operating the transport controls.

Manufacturer-defined shortcuts are usually shown next to the corresponding menu commands, but sometimes they don't appear anywhere — even in the documentation. On the other hand, many manufacturers provide detailed lists of shortcuts in the manual or in freestanding quick-reference cards that summarize and organize shortcuts.

You will benefit greatly from compiling information about shortcuts for the applications you use regularly. One way is to collect quick-reference cards and keep them in a notebook. When using a lot of shortcuts in a number of programs, a quick-reference notebook eliminates the need to memorize every program's shortcuts.

You can also create a spreadsheet or, better yet, a database that organizes your programs' shortcuts. A database facilitates comparisons of different programs' shortcuts and makes it easy to print quick-reference cards in a consistent format. The key fields (pun intended) needed in the database are: Manufacturer, Program Name, Functional Class, Menu Command, and (of course) Shortcut. The Functional Class field is worth some planning, because it's the linchpin for searches comparing shortcuts for the same function in different programs.

When you print quick-reference cards, it's generally best to group shortcuts by function. In an audio program, for instance, the quick-reference card may be organized into groups such as Transport, Selection, Editing, Processing, and Mixing.

The most useful Functional Class field combines generic classes — such as transport control, selecting, and locating — with other important features. For example, if you do a lot of mastering, you may often need to locate places in a file using markers. A Markers class would therefore make a sensible addition. Other database fields, like Program Version, may be helpful but are not always necessary.


Almost all applications use common shortcuts for the basics, such as Command + C (on Mac) or Control + C (on Windows) for Copy. But sound and music programs often use different shortcuts for the same operation, such as Zoom In. You'll gain the most efficiency and speed, however, if a function's shortcut is the same in all your programs.

An increasing number of applications let you define the shortcuts assigned to some or all of the programs' functions, so you can remap the shortcuts to make them uniform among the applications. You can also assign shortcuts to commands you use regularly but to which the manufacturer did not assign a shortcut. That can provide greater uniformity among programs or within a single program. For example, I set up BIAS Peak shortcuts for Change Gain (Option + Command + G), Change Duration (Option + Command + D), and Change Pitch (Option + Command + P).

Logic in the assignment process ensures faster operation later. Try to assign similar shortcuts to like functions. In my example, Change is the common characteristic.

Ideally, you choose the best shortcut for a function and configure your programs to use it. Unfortunately, reality often intrudes: not all programs let you remap shortcuts, and the ones that do don't always let you assign shortcuts for all menu commands. In other words, the command that you want may not be available, or a command that is not mappable may be using a shortcut that you need somewhere else.

Still, definable shortcuts can go a long way toward uniformity, and a shortcut database can be a great help. Be careful, though, not to assign a shortcut used by the operating system. For instance, Command + Shift + 3 on a Mac takes a screen shot, so avoid using that key combination for another function.


It is unlikely you will be able to create a comprehensive, consistent set of shortcuts across a number of programs using only their built-in capabilities. This is where a macro utility comes in. (For a description of several Mac and PC macro utilities, see the sidebar, “Macro Medley.”) Although macro utilities may be capable of executing highly complex scripts, most of their usefulness comes from simple functions such as creating shortcuts.

You can use a macro utility's shortcut feature to supplement the built-in shortcuts of programs. In that way, you can create a larger, more uniform shortcut set. For example, I used Option + Command + M for several years to execute a Bounce-to-Disk command. When I started working with Digidesign's Pro Tools, I decided to use CE Software's QuicKeys to define the same key combination as a shortcut in Pro Tools. Unfortunately, that shortcut was already used for something else, so I chose the closest combination I could find, Option + Control + M.

When I migrated to Mark of the Unicorn's Digital Performer after many years of working with Pro Tools, I simply defined the same combination to choose Digital Performer's Bounce-to-Disk command and used the shortcut as if I hadn't even changed applications. (Digital Performer and Pro Tools now include greatly enhanced shortcut-customizing features.)

Another example is Command + =, a built-in Pro Tools shortcut that brings the Mixer window to the front. Digital Performer's menus differ from Pro Tools' menus, but it was easy to assign the same key combination to the Mixer command in Digital Performer's Windows menu.


Macro utilities offer more than simple menu-command shortcuts and remapping capabilities. They also let you trigger short sequences of commands. Every kind of work involves a number of two- or three-step procedures that would be much more efficient if executed with a single gesture. Recording those sequences into a macro utility and assigning them shortcuts is generally quick and easy.

In Peak, for example, I assigned several shortcuts for normalizing audio. I use F9 for Normalize All to 99 Percent, F10 for Normalize All to 75 Percent, and F11 for Normalize All to 50 Percent. That is accomplished through a combination of menu commands, text entry, and dialog-box handling (see Fig. 1). Holding the Command key when I press one of those F keys triggers a sequence that normalizes only a selected area.

Another task I often perform is copying a selection from one file into a new file. I designed two shortcuts: one that copies the selection to a new stereo file and one that creates a mono file. In Peak, pasting stereo material into a mono file (or vice versa) automatically opens a dialog box that asks how the channel mix (or split) should be apportioned. I have not included dismissal of this dialog box in my shortcuts because it's often necessary to edit such sequences carefully to make them operate smoothly (see Fig. 2).

You might have to add a short time delay to a sequence to let the computer complete a task, or you might have to replace a step that works inconsistently with an alternate approach. At some point, the time spent fine-tuning a macro becomes more than I'm willing to spend. In any case, some procedures just seem to work best when they're broken into multiple short sequences rather than kept as long, complex macros.

Short sequences can have a startling effect on your work flow. For instance, sound effects and dialog editing in a digital-audio workstation (DAW) always entail fading in and out for virtually every region in the session. I have macro sequences that with a single keystroke select from the insertion point to the start or end of a region and perform a fade. Variations of the key combination select fade curves. All I have to do is position the insertion point and hit a key to get an exponential fade to the end of a region. Even if the program has built-in shortcuts for selecting to the end of the region and for bringing up the Fade dialog box, triggering the operation from one key speeds up the work tremendously.

Macros' usefulness in the studio is not limited to work within your audio applications. I spend a lot of time working in an environment that relies heavily on a network, so I've created a collection of macros that mount servers and open the folders I need to access most often. Those macros can even save my passwords, so the server can be mounted with just a keystroke. Other macros let me sort my file view by name, date last modified, or kind of file.

Macro utilities typically provide a “wizard” or other kind of help for assembling macro sequences (see Fig. 3). Most macro utilities also include a scripting language with more-powerful lower-level programming capabilities (see Fig. 4). Almost all macro programs can store shortcuts in collections that can appear in toolbar palettes for easy access with the mouse. A collection loads when the corresponding application is started up.

AppleScript is for Mac users brave enough to delve into something that looks a lot like programming. Cranky, idiosyncratic, and incomplete, AppleScript can nevertheless do so much that you might feel guilty watching it perform all the work. There are other noteworthy scripting languages, such as Frontier, but AppleScript is the best supported. If you're going to explore this area, do yourself a favor and buy a development environment such as Late Night Software's Script Debugger ($189; or Main Event Software's Scripter ($189; Script Editor, which comes on every Mac, is usable but just barely. Danny Goodman's AppleScript Handbook is another invaluable resource.

Macro utilities are generally more useful with music and sound programs than AppleScript; unfortunately, few audio-software manufacturers bother to implement AppleScript in their programs. A notable exception is Norman Franke's SoundApp (, a freeware sound-file player and format converter with a robust AppleScript implementation. Because AppleScript is primarily a “wrapper” for AppleEvents messages, which every application responds to in one degree or another, some applications that ostensibly have no AppleScript implementation may respond to basic AppleScript messages. AppleScript really shines in automating the Finder and moving data between business applications such as databases and word processing programs.


Shortcuts increase efficiency only if you use them, and that means making a commitment to learn them. At first, you will have to make a conscious effort to learn shortcuts that are not common to many programs. When using a new program, you may have to force yourself to pull down a menu and view the shortcut before using it. Initially, that's less efficient; if you pull down the menu, it clearly would be faster to choose the command. In the long run, however, the time spent learning the shortcuts is made up many times over in the smooth, unbroken work flow.

It's also important to start using the shortcuts you've assigned — within the program or with a macro utility — as soon as possible. Some assignments may prove unsatisfactory and need to be changed. It's best to discover that before you totally commit the shortcut to memory and go through a lot of trouble to make it the same in several programs. Sometimes when conforming a third program to the same shortcut, you'll spot a conflict you hadn't seen before. Other times you might come up with a more logical shortcut, perhaps one that fits more systematically with other shortcuts. In any case, changes are quite common, so the sooner you spot the problem the better.

A shortcut reference is invaluable for learning and for daily use. Besides quick-reference documents, you can make keyboard overlays that show the commands executed by the keys. You have to change overlays rather than just flip pages in a notebook when you move between programs. Sometimes I print a small set of shortcuts (like the network sequences) on a 2-by-3-inch sheet of paper and tape it to my computer monitor's lower edge.


In essence, using shortcuts and macros is a process of identifying the functions you need most and then configuring your computing environment optimally for those functions. The process demands a time investment, but the dividends can't be overstated.

Begin by noting tasks that you do often or that you always do the same way. Consistent use of a task marks it as a good candidate for a shortcut or macro. Keep a list near your work area and add to it every time you catch yourself performing a task that fits the description. Many functions you'd like to streamline are the same among programs. You'll also find important functions missing and a lot of short command sequences that you do repeatedly.

Armed with that information, investigate the shortcut implementation of your primary applications. Document your findings in your database or spreadsheet.

Once you have collected information about existing shortcuts, compare the shortcuts in the programs you use, identify new ones that you need to build, and formulate your strategy for assigning shortcuts. Take the time to really dig into your macro utility and find out its capabilities. If you use the macro utility's features cleverly, you can often pull off much more sophisticated tasks than would seem possible.

When you have done the necessary groundwork and have tested your shortcuts and macros, you'll be on the verge of a new working experience. Shortcuts and macros will soon become as much a part of your work as the programs' features themselves. Clients will be delighted and amazed at your speed and ease in handling the tools, and you may be hard-pressed to act nonchalant as the work flies by. Once you've become a convert to shortcuts, you'll wonder why you ever went the long way around.

Larry the O reminds you that America was discovered because Columbus was looking for a shortcut. Too bad he hadn't heard of macro utilities.


Although macro programs usually share a number of common features, their capabilities vary. It's therefore important to identify shortcomings or missing features in a macro program; otherwise, you may invest a lot of time and energy before discovering a fatal flaw that keeps you from reaching your goal. Many macro utilities can be downloaded as fully functional demos that operate for a limited time, so you can try before you buy.

The following are five of the most popular macro programs for Mac and PC:

QuicKeys ($89.95, Mac; $49.95, Win)

CE Software's QuicKeys ( was one of the earliest macro utilities, and it's the only one available for both Macintosh and Windows. Differences between the two platforms, however, preclude moving macros from one to the other.

QuicKeys makes it easy to build sequences and macros of simple to moderate complexity. The Windows and Mac versions include full-feature scripting capabilities, though the Mac version has the advantage of interfacing with AppleScript, which significantly extends what it can do. The Mac version can also trigger sequences through voice commands.

QuicKeys not only has a keyboard shortcut that opens its macro editor but also has one that displays a QuickReference screen showing the macros for the active application (see Fig. A). That screen is not just for reference, however; clicking on any macro icon runs it.

OneClick ($59.98, Mac)

OneClick is a Macintosh program from WestCode Software ( that is as much a scripting environment as a macro environment. OneClick's EasyScript language is quite extensive and includes features, such as opening and reading data from a file, that rival AppleScript's. However, OneClick is trying to join 'em, not beat 'em: it can exchange its variables bidirectionally with AppleScript's. For example, you could use AppleScript to get plug-in parameters from a database and pass those values to OneClick, which can enter them into the plug-in windows' appropriate fields.

The old power-versus-ease-of-use trade-off becomes an issue: OneClick's scripting features are more like programming than less-comprehensive macro-scripting environments. Conversely, OneClick is less adept at the kind of quick-and-easy solutions in which programs such as QuicKeys excel.

KeyQuencer ($49.95, Mac)

The other major Macintosh macro environment is Binary Software's KeyQuencer ( KeyQuencer strikes a middle ground, letting you build quick little sequences and more elaborate scripts. In addition to its scripting language and support for AppleScript, KeyQuencer has links to 4D (the cross-platform database from 4D, Inc.) and Metrowerks's CodeWarrior (a group of serious program-development environments). KeyQuencer offers speed and stability and demands only a modest amount of memory.

KeyQuencer comes with Batcher, a standalone application that lets you configure KeyQuencer sequences into a batch process. Like OneClick, KeyQuencer can store sequences as standalone, double-clickable applications.

Macro Express ($34.95, Win)

Macro Express from Insight Software ( provides plenty of macro-recording features along with a powerful scripting language that even includes a set of commands for audio and MIDI devices. A few commands — such as that which can read a standard tab-delimited text file and process the data in each field — make it easy to use Macro Express for batch-processing files from a list.

To help you with the program's features, Insight built in a number of wizards that walk you through the process of building a macro library.

Macro Magic ($39.95, Win)

Iolo Technologies' Macro Magic ( has most of the standard macro-utility features, but it also has features for use across a network. A user can gain access to a Macro Magic sequence residing anywhere on the network (providing all the appropriate permissions are set). That could be handy in a multiroom facility for letting an editor or engineer obtain access to his or her macros, no matter which room is being used.