Broadly speaking, I'd say there are three main types of macros people are looking to make:

  1. Quick macros for simple things: Saving a file and then closing it with one keystroke.
  2. Text expansion macros: Typing a long phrase or two with a keystroke.
  3. Complex automation macros: Performing a series of system operations one after the other with one keystroke. Maybe SSHing into a server and executing some code, or opening an app and preparing a work session in it.

Oryx macros are meant to do the first kind. For that, they just work: This is what we want you to use Oryx macros for. It's a reliable use and saves a lot of time.

When someone asks us "Why don't you support long macros" it really comes down to one of the two other kinds — text expansion and system automation.

We've already discussed text expansion macros elsewhere — now it's time to talk about deep system automation.

What's complex automation?

On my own system, I have a macro that opens a terminal, SSHs into a production server (using a keyfile) and then opens up the Rails production console in that server. I launch it with one Alfred command, wait a moment, and ta-da, I'm working in the production console.

This is a classic example of an automation macro.

So, why not have my very expensive keyboard just do that for me? Why do I need to spend money on something like Keyboard Maestro (Mac) or spend time and effort learning AutoHotkey (Windows)?

The answer is simple: Feedback.

To see what I mean, try closing your eyes or covering your screen, and using just your keyboard, open up a word processor, type some stuff, and save the file in a specific location. (This is a dangerous experiment — do this at your own risk.)

When you're done, uncover your screen or open your eyes, and see where you ended up.

Do you still have a computer?

... And did your file get saved where you thought it would, with the correct filename and correct content?

Maybe if you're lucky or if you chose a simple task. But for a sufficiently complex automation task, this will not work — certainly not every time.

Automation requires feedback

For a complex automation to work, we need to check between each step that whatever was supposed to happen did in fact happen.

In the SSH automation I described above, I need to check:

  1. Did the terminal window open? Is it now the active window? (Okay, now I can type in the SSH command.)
  2. After I type in the SSH command and hit Enter, did I get a connection? Did the command prompt change, am I now on the remote server? (Okay, now I can navigate the server and start the console.)

If I just forge ahead without checking for these things and waiting for them to happen, if I just send a series of complicated keystrokes, it won't work reliably. Sometimes it might — other times I'll get some surprising (or dangerous) results.

At the end of the day, your keyboard is just a keyboard: It doesn't have a way to know the state of a window on your screen, for example. And an "automation" that only works some of the time is worse than just doing it yourself every time.

So for those of you wondering why Oryx macros are "limited" to a simple set of keystrokes, this concludes the second part of the answer. To summarize:

  1. Long text strings have privacy/legal implications since Oryx is on a public server and has no privacy protections.
  2. Complex automation macros require feedback to work, and don't reliably work if they're just a long series of keystrokes and delays sent with no awareness for the state of the system.

Both of these use cases are very possible: You just have to use the right tool for the job (not a keyboard).

Happy automating! :)