The second solution I turned to, and the one that I have been using and fine-tuning for the last eight months, was VoodooPad. Despite some unique drawbacks of its own, VoodooPad offers near-perfect synchronization, a daily log that far surpasses Together’s in usefulness, and the ability to append text to practically anything. The only downside is that VoodooPad is less flexible about what it can store (and how you can retrieve that info later) because everything is text-based whereas in Together you can toss whatever you want into your scratchpad, be it a PDF, image, bookmark, etc.

Components

To setup your own scratchpad using VoodooPad, you’ll need three things:

• VoodooPad 4.2+; the lite version just won’t cut the mustard, and as of 4.2 the Pro version is rather anachronistic
• LaunchBar, Quicksilver, FastScripts, or some other easy way to invoke Applescripts
• The Scratchpad Template (that’s a download link)

If you wish to synchronize your scratchpad between multiple computers, you’ll also need MobileMe or any other WebDAV-based server.

Installation instructions are included with the scratchpad template; the key thing to remember is that your scratchpad has to be open in VoodooPad and be the only document with the word “scratchpad” (case insensitive) somewhere in the document’s name or the Applescripts won’t work.

What it does

The scratchpad uses enriched plain text to accomplish its organizational goals. Similar to TaskPaper, all of the text you enter in the scratchpad is without formatting of any kind. However, thanks to VoodooPad’s automatic linking of terms associated with a document page the text is enriched with links that lead you to various useful, automatically generated pages. (It’s worth noting that VoodooPad does support rich text; the scratchpad defaults to plain text because plain text is more portable if you decide to change scratchpad solutions and is also easier to export for the web. You can definitely switch the scratchpad to rich text if you like, but it’s untested.)

The most basic idea for the scratchpad is the textual tag. A textual tag is nothing more than a VoodooPad link, but the page it links to is special: it automatically collects all of the lines in the document that contain the page’s title and displays them in a list. This is a handy way to gather data from across the document without needing to do any work on your part. For instance, I create a textual tag for every one of my clients, so that when I need to review all the daily log entries associated with them I just click the client name in a recent log entry and am instantly provided with every other log entry for that client. You could also use textual tags similar to the way TaskPaper does and organize tasks with them.

A handy way to automatically create textual tags is to use any word prefaced by an @ symbol when using the daily log or quick note Applescripts (for example, “@today”). These will automatically be converted to textual tags (if they don’t already exist) without any work on your part.

There are other special scratchpad pages, as well: any page (including auto-generated pages) can be designated an inbox, which allows you to append information to it using the quick note Applescript; you can create index pages for listing tag pages, logs, etc.; and composite pages gather the full contents of other pages and display them in a long list (useful if you want to view all of the daily logs for a given month, for instance).

These special pages are all created the same way: you just add a new page to the document like you normally would (typically by selecting some text and choosing Edit → Make Link), and then attach a special Voodoopad page tag to the page. A VoodooPad page tag, unlike a textual tag, is applied to an entire page using the VoodooPad palettes. You can feel free to use VoodooPad’s page tags however you wish as long as you only use reserved tags like “tag”, “inbox”, and “composite” to designate special scratchpad pages.

Once you’ve added one of the special page tags to a page, the auto-generation script will populate the page contents the next time you open it. There are also several meta keys you can use to customize what is displayed on a given page, the order of items, and so forth. Full documentation is available within the scratchpad itself.

How I use it

Unlike my Together scratchpad of yore with its handy shelf, I interact with my VoodooPad scratchpad almost exclusively through Applescripts invoked via LaunchBar. When I finish a task or have something else that I want to log as a timestamped note, I hit control-space to open LaunchBar, type “dl” (for Daily Log), hit space, type my log entry, and hit enter to save it. VoodooPad typically is running in the background, so the whole operation takes a few seconds at most.

If I find a link or something else I want to save, I copy it, invoke LaunchBar, type “QN” for Quick Note, hit space, and paste in the URL or type whatever note it is that I want to save. I then hit enter, choose from the list of inboxes that the Applescript provides me with, and when I’m on my personal computer I can then check those inboxes to see if there’s anything I need to process.

I rarely use the automatically generated textual tags (although I thought I would originally) because I much prefer the clean @-less textual tags that I create by hand (which additionally can include space characters and so forth).

Additional deliciousness

Though my main usage of my scratchpad has tended over time to focus a lot on daily logs and—to a lesser extent—noting URLs or things I want to think about/remember when not at work, you can easily use your scratchpad in more interesting ways. For instance, the web export system is setup to automatically generate a nice-looking version of the scratchpad, including well-formatted daily logs, with everything else formatted using Markdown if you want to share it with someone.

Setting up a TaskPaper-like task manager would not be particularly difficult, either, since you can specify tag pages to be inboxes as well as tags (useful if you want to track quick notes right alongside relevant daily log entries, for instance).

I’m sure folks will come up with their own unique usages, too; I’ve tried to keep things flexible and simple enough that it can appeal to numerous different workflows. The page auto-generation and web exporting is controlled by a pair of reasonably simple Python scripts and a page that controls the web export template, so those should be easy to modify or tweak if you so desire and are comfortable with Python.

Caveats and downsides

Overall, I’ve been extremely happy with my VoodooPad scratchpad. Certainly it isn’t as flexible as Together, but it’s also been far more stable. However, it is not without downsides:

• Because auto-generated pages are only refreshed when you open the page, things can quickly get out of date if you leave pages open. Currently the only way to update every page in the document is to do a web export.
• As your scratchpad grows larger, opening auto-generated pages will grow slower. Mine is eight months old with hundreds of pages and still moving pretty snappy, but the slowdown is inevitable thanks to the way that I have to parse through every page in order to autogenerate others.
• The Quick Note Applescript relies on your inbox index page being up-to-date; sadly there is no way to request all pages in a tag from VoodooPad via Applescript, so you’ll need to close and reopen your inbox index whenever you create a new inbox.
• The lack of easy-to-define smart pages or collections is also unfortunate, although I’ve found the meta-information based approach to work reasonably well for me.

Make it your own

I’m providing this template because I’ve found having a digital scratchpad that I can easily sync among multiple computers to be extremely handy. If you end up using it, I’d love to hear how you find it useful or limiting! I’ll definitely be updating the scripts and so forth as I continue to use and refine it myself, and I’ll share any significant improvements (updating will likely be a matter of copying and pasting a couple of pages into your personal scratchpad and maybe updating the Applescripts).

Good luck, and enjoy the scratchpad!

Resources for the scratchpad:

• VoodooPad
• The Scratchpad Template
• LaunchBar, Quicksilver, or FastScripts

This turns out to be only half the story, however, and should you be a developer or user considering OpenMeta (or Tags) as a solution for your tagging needs you need to use it with eyes open. Although the technology OpenMeta uses is completely on the level, the way in which it achieves instant Spotlight availability is based on exploiting Spotlight’s preferential treatment of metadata that is identified as coming from Apple. This doesn’t mean that you should swear off OpenMeta and Tags (I’m still using them), but before you go tag-crazy you definitely need to consider the risks.

How does it do that?!

OpenMeta uses a technology called extended attributes to store and retrieve tags. Extended attributes (or xattr as they are often referred to by those in love with tech-speak) are a way for third parties or users themselves to add arbitrary metadata to files. Using extended attributes for tagging is entirely legitimate; the reason that they haven’t been used for generic tagging software before is that extended attributes are not indexed by Spotlight unless the program creating them registers them via a Spotlight importer, which means that the only program that will know about the special tagging extended attribute will be the program that created the tag.

Unfortunately, any given file can only have one Spotlight importer, which is usually the program that created the file. Clearly it isn’t feasible for a piece of tagging software to convince all the various developers whose files might be tagged to add support for their tags in their importers, so the typical route for adding information to the Spotlight index is out. (Thanks to Michael Tsai for clarifying this for me.)

OpenMeta gets around the Spotlight problem by identifying its tag attribute as coming from Apple. Spotlight automatically indexes extended attributes placed in the Apple namespace, and OpenMeta exploits this by quietly writing its tags into that namespace.

This is a problem because Apple doesn’t support other programs writing information to their namespace (the expected and sanctioned behavior is for programs to create their own unique namespace). Since Apple doesn’t support it, OpenMeta may or may not continue to work the way that it does now with subsequent updates to the operating system, and tag data may or may not be preserved.

OpenMeta (although possibly not Tags) does take steps to ensure that your information is backed up. In the event of extended attributes getting wiped for a file (which can occasionally happen if other programs are buggy in their use of extended attributes), OpenMeta stores backups of your tags in your Library folder. This, however, does not address the problem that OpenMeta is injecting information into an area that is reserved for Apple’s use.

So should I use OpenMeta?

Whether you should use OpenMeta is a question both developers and users should ask themselves before blindly adopting the technology. On the one hand, it has significant benefits and at long last offers a standardized way for programs to share tagging information with one another and the system without relying on Spotlight comments. On the other, the program is exploiting unsupported aspects of the operating system and can thus offer no promises about its future viability.

Michael Tsai of EagleFiler fame is the first developer I know of to have been willing to frankly discuss the downsides and specifics of OpenMeta’s implementation, and over the course of a long and wending forum discussion he recommends that OpenMeta change its focus from storing tags in an Apple namespace to storing tags in an OpenMeta-specific namespace available to all tagging programs with duplicate storage in the Apple namespace offered as an option for those to whom Spotlight integration is worth the potential downsides. For developers, I agree with Michael. Were I developing an app of my own that used tagging, I would be leery of relying on a framework that forced me to write to an unsupported namespace with no alternative, supported method for data storage.

For users the question of whether or not to use OpenMeta or Tags is more a matter of personal needs and preferences. If their functionality feels as much like magic to you as it does to me and you’re comfortable with using technology that isn’t officially supported by Apple, then by all means tag away. If you are using tags in a mission critical environment, you may want to think carefully about whether OpenMeta is for you but for most users the risk of data loss is extremely low.

Although I haven’t created a full-fledged system yet, I’ve slowly been developing a use for Tags which uses tags as supplemental information, pairing it with Hazel where I can to enable automatic sorting of tagged files into my standard folder hierarchy. I wouldn’t recommend using OpenMeta to try and replace a folder structure, but by utilizing it to add information I can have a richer store of metadata without being hamstrung if an OS update for some reason broke OpenMeta.

Whether OpenMeta will work for you or not should be based not just upon how great the product seems but also how comfortable you are with the methods being used behind the scenes.

My hope is that as OpenMeta and Tags gain traction, Apple will finally take note and address the problem of third party extended attributes having no way to get into the Spotlight index. Whether that happens or not, however, is impossible to predict; time will tell if OpenMeta is ahead of the curve or if it will ultimately go the route of SpotMeta.

For more information about the specifics of how OpenMeta does its thing, I highly recommend reading some of Michael Tsai’s posts in the aforementioned Ironic Software forum discussion. Although the thread ranges pretty far afield, some of the early information offers a very specific look at what OpenMeta is doing, and there are some interesting suggestions for alternative ways the software could go about achieving its various goals.

For the past few weeks I have been investigating software that might serve me as a scratchpad. Although I have not yet developed the perfect solution, I would like to share my first, somewhat flawed solution using Together from Reinvented Software. Together gets almost everything exactly right, but falls short for me thanks to the buggy and error-prone synchronization of MobileMe. Despite the shortcomings of its synchronization, however, setting up a scratchpad in Together is extremely easy and for people who don’t rely on synchronization (or perhaps just have better luck with MobileMe sync services than I) Together is an excellent choice for a scratchpad.

Update Sept. 2009: at long last I’ve published part two of this series describing my VoodooPad-based solution. Check it out!

Parts of the goal

When I set out to build myself a scratchpad I had two things I wanted:

1. Easy storage, synchronization, and retrieval of info
2. A daily log

The first is well covered by Together’s built-in tools for capturing files and so forth, complemented by some simple tag-based organizing and a couple of smart folders.

The second required a bit more custom work. The idea of keeping a daily log is one that I first discovered when Chris Bowler described his custom log file. Although his solution wasn’t really what I was looking for, the idea of keeping an easily updated, timestamped log of what I’ve done throughout the day grabbed my imagination. When I’m focused on a task, I rarely remember to switch to my time tracking software and enter details about what I’ve just completed, but adding a line of text to a daily log would be another matter since I could use my favorite tool LaunchBar to easily make a note without switching applications or getting out of the flow.

Setting up the scratchpad

To set up your scratchpad, you’ll first need to create a Together library for it (you could use your current library, of course, but you’ll have that much more data to sync). To add and manage libraries, choose Together → Library Manager. I named mine “Scratchpad”, but the name doesn’t really matter. If you’re going to be synching your library with MobileMe you may as well turn that on now.

You’ll have more luck with synching if you sync hourly (or less frequently). You can change how often MobileMe syncs in the System Preferences.

Aside from daily logs, whether your scratchpad is useful will rely on how you organize using groups and tags. Because I’m using two computers, one for work and one for personal use, what works for me is to start with two root level folders (I work for a company called Tierra Interactive; you could call the folder “Work” or the name of your employer just as easily):

As you can see in the screenshot, I’ve opened up the Group Info window (accessible by right-clicking a group and choosing Show Group Info or by choosing File → Show Group Info). One of the big reasons to have two root-level groups (aside from making it easy to focus in on those two areas) is that you can use them to automatically assign tags to any item that is added to that group using the Group Info window. This makes adding items to your library and being able to utilize intelligent smart groups much easier because you can either:

1. Add an item to the Personal folder when you import it to have it automatically show up in any smart groups targeting the “personal” tag.
2. Add it anywhere else, but manually assign the personal tag to make sure it shows up in smart groups targeting “personal”

This may seem redundant (in the first scenario, you’re effectively categorizing something “personal” twice), but consider the following: what if you find a link to a piece of software that you want to install on both your computers? If you found it at work, you may not have time to do it right then, so you’ll want to make sure it ends up in your work folder. However, you also want it in your personal action items. If you were relying solely on folder-based organization, you’d have to either duplicate the item or create an alias, both of which require more effort and thus make it less likely you’ll use the system at all.

Depending on how you use your scratchpad, having two folders (with tags available in case you decide to use smart groups in the future) may be enough. You could, if you desired, use the two folders to track items for work vs. personal, and once you’d dealt with an item either move it out of the folder and back into the library to archive it, or just delete it entirely. However, I wouldn’t be me if I didn’t suggest one further refinement: a simple system of tagging to make retrieving and acting on items even easier.

Taking action

When I was setting up my scratchpad, I realized that there are two basic types of items that I’m going to be storing:

1. Things I want to take action on
2. Things I want to remember

With this in mind, I decided to use a tagging system that allowed me to filter for action items and, if I needed, search for specific types of items using descriptive tags.

Although a simple “action” tag would work fine, I ended up using tags that look like this: “action: install”, “action: blog”, “action: evaluate”, etc. For some people, this may be needless complexity. For me, though, it provides a simple way to remind myself what I wanted to do with the item without needing to add a note or some other piece of metadata that would require something more than the Together shelf. Why did I bookmark that page? Oh, I wanted to blog about it.

Remember: the fewer tags you assign to an item, the more likely you’ll be able to maintain your tagging system. I generally only assign two or three tags to any given item: a descriptive tag or two and an optional action tag. (And Together automatically adds “personal” or “work”.)

For other items, I simply attach a descriptive tag to it: “password”, “big web client”, “idea”, etc. I’m not currently using any of these tags to filter my items, but simple descriptive tags will likely be useful down the road if I need to filter the increasing number of items in my scratchpad to, say, find all URLs pertaining to a specific client.

In order to be able to easily focus on my action items, I have two virtually identical smart views (only difference is filtering based on work vs. personal tags):

The first rule uses a feature of Together that I didn’t know about before I set out to create a scratchpad. In Together rules, you can use an asterisk as a wild-card, which came in real handy for my “action” tags. The other rules should be self-explanatory, although the label is new. The meaning a label assigns can usually be duplicated with a tag, but I often find labels useful for marking priority or status because they colorize items. I opted to archive items with a gray “Archived” label in order to visually separate out the items that I’ve acted on from the ones that await action when viewing either my folders or the root library group. An additional benefit of using a label to archive items is that I don’t have to lose information; if I deleted the “action” tag, then I would have to rely on memory to recall why I wanted that particular item in the scratchpad at all.

Once you’ve got your folders and smart groups set up, you’re ready to start using your scratchpad. However, if you want a daily log there’s a couple more steps.

Setting up a daily log

Personally, I prefer the idea of keeping a folder full of daily logs rather than just tossing everything into an ongoing text file (easier to append text files than parse them, if I need to switch down the road), so I wrote an Applescript that will look for a file named based on the current date, create it if it doesn’t exist, and then add a timestamped log entry. The Applescript actually doesn’t require Together, so if you feel like running a daily log without Together feel free to give it a look-see, as well.

Download Together Daily Log Applescripts

Whether you’re using Together or not, you’ll need to create the folder for the logs to live in before running the script. In the earlier screenshot of my folder structure you can see I have them living in “Tierra/Logs” in my Tierra library.

Once you’ve got the folders set up, open the Applescript in Script Editor (or the Quicksilver version, if you’re a Quicksilver user) and change the property declarations at the top of the file to point the script toward the right folder (see screenshot below). Once you’ve done that, save the script and you’re in business.

Assuming that you’re running Together, it should automatically import the log files when they are created (just make sure you have “Auto import files added to library folders” checked in the Import preferences). If automatic importing isn’t working, try relaunching Together and creating an empty text file using the Finder to kick-start Together (this worked for me, but if you’re having trouble please refer to the Together support).

Here’s my daily log workflow: I’m using LaunchBar and have it set to scan the scripts folder in my Library, so I put Daily Log.scpt here: ~/Library/Scripts/Applications/Together. To add an entry to the log, I invoke LaunchBar, type “dl”, hit space, type my log entry, and hit return. Easy, quick, and then a log of what I’ve been doing during the day is available when I need to fill out my timesheet.

I’ve been finding Together an excellent choice for a scratchpad that includes a daily log; hopefully you will find it just as convenient (or at least have found some food for thought in my approach to some simple tag-based organization).

Downsides

I’ve been using Together as my scratchpad for a couple of weeks, and overall have really loved it. As I mentioned above, MobileMe’s significant issues with keeping even a simple Together library in sync have convinced me that I need to look elsewhere for my perfect solution, but if the synching were consistent and painless I’d have no qualms using Together for the long haul.

That said, there are some potentially significant downsides to this system, particularly for people with an eye on their budgets. MobileMe is not a cheap service, and because it’s the only way to sync Together it’s definitely necessary for anyone who’s interested in a scratchpad they can access from multiple computers. For an optimal workflow with the daily log you’ll also need LaunchBar or Quicksilver, and although Quicksilver is free, LaunchBar is far superior in my experience (and has the additional benefit of not having been abandoned by its developer).

It’s worth mentioning, too, that a computerized scratchpad like the one I’ve outlined here is completely worthless for some folks. Unless you’re on your computer for most of the day, you’ll likely find a pad of paper and pen far more useful.

Other options

Although Together was one of my first picks for scratchpad software, I did investigate other options. Evernote as an idea was extremely appealing, but in execution the service only seems worth using if you’re on the road a lot and need to store info (particularly images) via your cell phone. The desktop Evernote program is simply too clunky for someone who is always at the computer like myself, particularly given the existence of several excellent file libraries.

I also considered just using plain text files and making a daily log that could double as a scratchpad, a la Chris Bowler’s solution, but I wanted a simple organizational method (in this case using tags), which was not possible with plain text. Tossing URLs that I want to visit into my daily logs would just be throwing them into a black hole; I doubt I’d bother to take the time to review them when I switched computers.

Together’s competitors, Yojimbo and EagleFiler, were worth consideration, but neither could handle the workflow that I desired (EagleFiler because of its lack of any kind of easy-to-use synching, and Yojimbo because it doesn’t offer any good way to append text to a file/library item so far as I could tell). For people who want a scratchpad for a single computer, however, EagleFiler might be worth a second glance (particularly if you own it and don’t own Together).

Looking forward

As you may have figured out from my dissatisfaction with Together’s synching and the “part one” in the title, my quest for a scratchpad is not yet over. I’m currently in the early testing stages of an alternative solution using VoodooPad Pro 4 that has fantastic synching support but requires a bit more gruntwork on my part to get up and running. I’ll be sharing my second scratchpad solution once it’s finished, but in the meantime I hope that my work with Together will benefit some other folks who have been battling with the same mind-overflow issues that I’ve been facing.

Resources for the scratchpad:

• Together
• Download Daily Log Applescript
• LaunchBar or Quicksilver

Although I still think it’s priced a bit high, I was completely in error about Leap’s existence in limbo between file system taggers and file libraries. Leap is a full-fledged file system tagging solution that is unlike any of the other solutions currently on the market. It certainly isn’t perfect, but Leap provides a number of different ways to access your tagged files and introduces a unique way of working with files in your current folder hierarchy that no other tagging software provides.

The most important thing to know about Leap is that it both reads and writes Spotlight comments tags that use the & or @ syntax (&tag vs. @tag), which means that if you’ve been rolling your own file system tagging using TagBot, Default Folder X, and/or Quicksilver Leap will fit right into your workflow without effort. This is kind of a big deal, so take a moment to ponder it. You don’t have to have Leap running to do basic file tagging. You can use tools like Hazel to automatically tag files using Spotlight comments, and Leap will keep track of them.

In case you’re wondering, this is very cool. Granted, Spotlight comment tagging is still a sub-optimal solution, but since Apple hasn’t seen fit to give us the tool to implement true Spotlight tagging there’s not much we can do.

Leap will also optionally write out your tags to Extensible Metadata Platform (XMP) or Spotlight kmdItemKeywords. XMP is a technology developed by Adobe intended to embed metadata into files (as far as I know, Spotlight has no knowledge of XMP metadata, so unless you use it already for something you probably won’t need this feature). Using kmdItemKeywords doesn’t actually work the vast majority o the time, because it will be overwritten by a documents default Spotlight importer (which is why most file system solutions use Spotlight comments). Nonetheless, it’s nice to see that Leap covers a number of unconventional bases.

If you took a look at Leap in the early public betas, you’ll be surprised how much the interface has changed, too. Leap sports a much classier look centered around what Ironic Software calls the “crumb trail”:

The first button in the crumb trail lets you save your search as a bookmark, while the rest of it does the heavy lifting. Basically, the crumb trail is like a sentence: “I’m looking for what in where that contains search term.” As you select tags and so forth to refine your search, they show up in the crumb trail. For instance, the screenshot shown is saying “I’m looking for tagged files in all preferred places that have the tag critique“.

Leap’s sidebar then shows you a list of the various tags that show up in that location, intermingled with broad date filters and the folders that contain the files (shown at right). This method of mixing tags, folders, and dates is provides a brilliant way to take advantage of your current hierarchical folder organization while beginning to conceptualize the entire organizational process as tagging. Fortunately, if you need to target, say, just tags, you can easily change what is included in the sidebar using buttons at the bottom. Leap also allows you to show an alternate middle pane that makes it explicitly obvious where the files you’re looking at are located:

In an interesting move away from the norm, Leap doesn’t provide any sort of over-arching tag cloud, either for browsing or editing. Sure, there’s a tags window that will let you rename and delete tags, but it only shows those tags that are available in the active search. For people used to tagging software that lets you manage all of your tags whether or not you know which documents use them, this will be pretty strange and awkward.

There are a number of other features (and a couple small interface annoyances) that have been introduced in Leap 1.0, but overall you should now have an excellent idea of how Leap deals with tagging. This is a new, innovative approach to tags that will allow you to ease into using tags without abandoning the information about files supplied by your folder hierarchy.

I’m really excited that Leap reads in tags from Spotlight comments that you created before you started using it (or when the program isn’t running). Although I was a bit underwhelmed by the early public betas, Leap is now an excellent product to look into for tagging newbies and seasoned file system taggers alike, and a compelling alternative to the current file system tagging offerings.

I’m honestly a little perplexed by the number of independent Mac developers releasing alpha software these days, complete with bugs and lacking promised features. I’m sure that the pending release of OmniFocus is the reason GTD developers are pushing their software out the door as soon as possible, but it still seems like a fairly dangerous move. Even software that is publicly released in beta form often gets seriously delayed as the developer becomes swamped by feature requests and duplicate bug reports, and I imagine the problem is far worse for hotly anticipated applications like Things and iGTD 2. I’m sure releasing alpha software results in an initial burst of interest, but I wonder about the long-term benefits.

But don’t wait until version 4! If you want access to some of Default Folder X’s sweet capabilities now, you’re in luck. St. Clair Software has an upgrade policy that will allow you a free upgrade to version 4 if you buy version 3.0.6 now. Version 3 is fully Leopard compatible (as long as you aren’t running any 64-bit apps); it just lacks the translucency. For more information, and to download Default Folder X 3.0.6, see the Default Folder X website.

There are some similar aspects to all GTD task managers, but I think one of the primary deciding factors whether or not a particular piece of software will work for you is how much structure you need or desire. With that in mind, here’s the GTD software for Mac OS X, ordered from most structured to least: Midnight Inbox, OmniFocus, iGTD, TaskPaper, iGTD 2 (early development), and Things (approaching public preview). If you’re like me and agonize over task managers, then this is a pretty daunting list (and if you count some of the less polished options, it’s nowhere near complete). However, with an eye to structure, I don’t think it is all that difficult to narrow the list down to a couple of applications that you should try.

Just what is “structure,” anyway?

Structure in a GTD app applies both to the metadata attached to tasks (do tasks have contexts attached? Tags? Priorities?) and to the workflow that the application’s interface encourages (are you encouraged to focus on projects, or focus on tasks that you need to do today?). Some applications give the user very specific information and a very specific workflow (the more structured apps), while others allow much more freedom (the less structured).

For some people, the highly structured apps will be the most appealing because the workflow and information attached to tasks makes perfect sense to them. For others (myself included), the less structured apps will be more inviting because they allow the user to craft a more personalized system (and are often less complex for users who don’t want to use the advanced features).

Figuring out whether you prefer more or less structured approaches to GTD is something everyone will have to do on their own. Odds are if a screencast or feature list for a given application makes you think, “Wow!” and start imagining what you could do with it, that’s the type of application for you.

But enough with generalities! Let’s take a look at the actual applications side-by-side.

Structure to live by: projects and contexts

Midnight Inbox ($35) is by far the most structured of the available apps, and it is also one of the few polished GTD apps available (and has been available for some time, unlike the still-in-development OmniFocus). Personally I think that using Midnight Inbox is like having David Allen standing behind you, twisting your arm, and shouting in your ear, “Do it my way!” That said, if a five-step, context-oriented task workflow makes sense to you and you’re willing to let the software know best and collect what it thinks you need to organize, then Midnight Inbox is worth a look. It’s certainly a polished-looking piece of software, and is one of the few GTD applications available as a stable, tested release.

Midnight Inbox’s biggest strength (which also happens to be its biggest failing) is that it can collect practically anything on your computer automatically (email messages, iCal to-dos, text documents in a specific folder, etc.) and encourage you to review them for actionable tasks. This can be really handy, but for myself I’d just end up frittering away all my time collecting, organizing, and reviewing tasks rather than completing them.

OmniFocus ($39.95 prerelease; $79.95 standard) is nowhere near as controlling as Midnight Inbox, but it is still highly structured around projects and contexts. Tasks have quite a lot of specific metadata attached to them, but are displayed in an easy-to-understand outline similar to OmniOutliner.

OmniFocus is another app where, for me, there’s a little too much complexity (bringing about a “I’m not getting any work done because I’m constantly playing with OmniFocus” type of workflow). In its defense, OmniFocus does provide an inviting interface to tempt you in, and with complexity comes great power. If working out of contexts and projects makes sense to you, then OmniFocus is probably your best option, if only because of Omni’s attention to detail, great interface design (overlooking, for the moment, their obsession with inspector windows), and dedicated support team.

An unfortunate result of OmniFocus being the only one of these apps that is produced by a larger company (compared to the individuals and small teams working on the other apps) is that its price will be less competitive when it finally goes release candidate. At the time of this writing, there’s a lot of pressure to just buy OmniFocus without really being able to experiment with the other options because the prerelease price is half what it will cost after January 8, 2008.

Then there’s iGTD (free). I have a love/hate relationship with iGTD. It has a lot of power, but terrible interface design. Balancing that out, it’s free, which is a pretty tempting price point. iGTD has a far worse learning curve than OmniFocus and is plagued by many of the same problems (as far as restricting you to contexts and projects). It additionally has a bad case of feature bloat which OmniFocus, while pretty overwhelming at first glance, has minimized.

If none of the other options look like they’ll provide the power you need to manage your tasks, then iGTD is very likely the perfect program for you. It integrates with just about everything (notably MailTags) and provides more metadata than you ever knew you needed. However, particularly given the brief glimpses we’ve had of iGTD 2, iGTD looks like it will be badly outclassed in the very near future.

Straddling the fence between the more structured and less structured apps is TaskPaper ($18.95 intro price). TaskPaper is by far the least complex GTD task manager available, and if all you need to do is jot down lists of tasks sorted by basic projects and tags, then TaskPaper is probably the perfect solution for you. TaskPaper doesn’t compete with the other GTD apps as much as it provides an interesting counterpoint in task management minimalism. It is extremely limited, but a perfect step up from plain text lists for some people. Unfortunately, its tagging is only really effective when used similar to OmniFocus/iGTD contexts

I’ve actually been using TaskPaper as my primary task manager for the last few weeks just to see if I could, and it’s been an interesting experience. On the one hand, using TaskPaper made me realize that I don’t need a really complicated solution. On the other, it turned out that some features from the other GTD apps are things that I want. I highly recommend using TaskPaper for anyone who has tried a number of GTD task managers without being able to pick one. It’s an experience that really helps clarify your needs.

Laid-back structure: focus and tags

As much as I wish it were otherwise, the two less structured GTD apps have not yet been released to the public.

Although there has yet been nothing except preview screenshots and short screencasts, iGTD 2 (forthcoming; free) is looking like a solid step in the right direction for iGTD. iGTD 2 looks like it will abandon the standard project/context framework supplied by the many other apps in favor of tags and “focus.” Focusing on tasks, a central component of both iGTD 2 and Things, is basically looking at tasks based on general shared characteristics (such as tasks that need to be done next versus tasks that need to be done today).

Not only is iGTD 2 much less structured than other available apps, but it looks like it will be pulling on some of the immense power of iGTD, but filtering it through an interface that is far, far superior. The tabs and saved workspaces in particular are a pretty ingenious approach to viewing complex assortments of tasks. I also think that its attempt to use natural language for its interface elements is bang on target, and may well help iGTD 2 to dip into the more casual task manager crowd that iGTD is currently alienating through its complexity.

And finally we get to Things (forthcoming; pricing as yet unannounced), the least structured of all the task managers. Like TaskPaper, one of Things’s goals is to simplify task management. However, unlike TaskPaper, Things still provides a lot of potential power through its versatile and intuitive tagging system. Things doesn’t yet provide feature parity with some of the more structured applications; what it provides instead is an elegant and easy-to-use system for sorting and accomplishing tasks that scales to the complexity the user wishes to have.

Things still has a definite structure, of course; it provides an interface that expects your workflow to include steps like collecting tasks, organizing tasks, and then completing tasks like most of the other GTD managers. Tagging (and Things’s intuitive tag filtering) is what allows more freedom in Things structure than within, for instance, OmniFocus’s strictly defined metadata.

Which solution?

If you know whether structure appeals to you or not, you should hopefully now have a better idea of which GTD apps are the most worth the time it takes to evaluate. Thinking about task managers in terms of how they structure tasks and workflow is a much different way to think about software than most people are used to (feature comparisons are much more standard), but I think it’s one of the most important things to think about for an application that is so intimately related to the actions that you take in your life.

Of course, features are important, too. The applications with the most features (and thus the most complexity) are probably iGTD and OmniFocus. Things and iGTD 2 are difficult to evaluate based on features because neither is feature complete yet. Midnight Inbox is fairly feature-rich but in an all-in-one-solution way, and TaskPaper almost doesn’t have features at all (in a good way).

The truth of the matter is that it still isn’t possible to compare OmniFocus vs. Things vs. iGTD or iGTD 2. Until we have at least a 1.0 release candidate for all of the main contenders, it will be very hard to compare features and performance, which is why I avoided trying to compare specific features of any of the applications.

Just looking at the software that’s publicly available, iGTD and OmniFocus are the best choices if you need a feature-rich application, and TaskPaper is the best stopgap for people with simpler needs. Depending on how many features Cultured Code is able to cram into its public preview version of Things, Things may also be able to serve some people before it is released.

Although I’m really looking forward to the less structured software (I do love my tags), if you prefer a structured solution to task management you may be able to find the perfect application without much more ado. Whatever your preferences, good luck! Finding the task manager that works for you can be a difficult and time-consuming process, so I hope that this general comparison has helped you slim down the options somewhat.

What excites me about Things is the flexibility that it provides with its tagging system. OmniFocus appeals to me a lot (I used Kinkless for a while so it’s familiar, and, let’s face it, Omni rocks hard and long), but I’m not so much a fan of the way it structures tasks. Contexts make sense as a way to view tasks, but they aren’t terribly flexible and honestly don’t really suit me personally that well. iGTD 2 actually looks very promising, but that’s because it appears to be moving in a Things-like direction (that is, relying on tags instead of on mountains of metadata like the original iGTD).

The Things development team told me that they tried to remove as much complexity from task management as they could, providing the user just with the basics they needed in the spirit of “getting things done”, but that they added tags as a way for more advanced users to apply more powerful approaches to task management. Although what the final version is like remains to be seen, I honestly think that Things is on track to provide this kind of scalable power, and am very happy that I was allowed to play around with an early development version.

In any case, Cultured Code is hoping to provide a public preview of Things in the near future, so if you’d like to try it yourself soon (rather than watching me drone on about it), head over to the Things website and sign up for their mailing list.

This is definitely an exciting teaser for the future of what is currently the top GTD contender (in my opinion; your mileage may vary). iGTD is not without flaws, as I have remarked myself, but iGTD 2 looks like it will be a solid competitor for more polished newcomers to the field like OmniFocus and Things.

Definitely a useful article to read if you use Spotlight much (for finding tagged files, for instance), although it doesn’t have anything to do with tagging specifically. (Thanks to Daring Fireball for the link.)

To kick things off, I’ve got a special treat for you: an interview with Tom Andersen, one of the two developers of Leap, a new application for tagging your file system. I don’t generally go in for interviews, but the recently released Leap public beta made me pretty curious and I decided to head to the source. Tom reveals where Leap is heading before the final 1.0 release, explains why you need to ditch your complex Finder hierarchies, and describes why Cover Flow in Leopard is not actually your friend.

Tagamac: First off, can you say a bit about who you are and what you do? Who are those men behind all that Ironic Software?

Tom: Ted Leckie, Tom Andersen (that’s me), and – that’s it! Just two people. We are a little on the technical side, since we both like to program full time. Our programming pasts have been largely linked together, since we wrote Starry Night from 1995 to about 2003. Then we went off to try and start another company, and then in mid 2006, we started working on our PDF manager, Yep. Ted and I won a couple of Apple Design awards for Starry Night. Ted handles most of the UI coding and layout, etc, while I tend to do the ‘under the hood’ stuff.

Tagamac: Few software developers have turned out even one solid tagging application, and you’re right on the cusp of releasing your second. What draws you to tagging?

Tom: I think that the big thing is that sinking feeling that you get when you have to navigate to a file using the Finder. Tagging gives you many paths to get to the same file. By paths here I mean it like this: with a document tagged ‘green, environment, idea, and boston’, you can get to the document by using a path in any order: green/idea/environment/boston will give you the same set of documents as /boston/green/idea/environment.

Tagamac: Okay, enough with the chit-chat; let’s talk Leap. In thirty seconds or less, how is Leap going to change the world (or my computer, which is the same thing, really)?

Tom: We want to free you from the file hierarchy.
The thing that you are actually working on, be it an email, word document, ad layout, etc, gets relegated to 2nd place in your head while you concentrate on the mundane task of descending a file hierarchy. People don’t remember /Users/tandersen/Documents/Ironic/business plan/ideas/plan template.pdf; instead, they remember the ‘blue PDF in ironic’. With the Finder you have to navigate the whole hierarchy, only to find out you went to the wrong path. Then you do a search (how do you search for blue?) and end up with 100 PDFs that mention template in them. Not good. With Leap it’s two clicks – clicks without thinking.

We want to help you manage thousands of files.
The hierarchical system for storing documents was created when 1000 documents was a lot, and people managed only a few per day. Now we have a hundred (more or less) files a day coming at us (if you include emails). With Leap, click on Images, and you can see where on your computer your 17,068 images are located. Just poking around a bit, I found folders with tens of thousands of files that I have no interest in clogging up my laptop.

We help you find files using Spotlight with more than a content search.
The Spotlight find commands in Leap allow you to search for file name only, file type, then filter more on contents, etc. Apple’s Finder allows you to do some of these things, but the interface is so slow and clumsy that most of the time people don’t bother. How many saved searches do you use on your computer?

Tagamac: Honestly, I’ve created two but I never use either of them. Point taken.

As far as I know, Leap is the only tagging software that bills itself as a Finder replacement. How has Leap replaced or substituted for the Finder in your own lives?

Tom: I use Leap to manage our web site. When I click on the website, I immediately see all files in the web site, without having to dig into all the ‘images’ folders. It is easy to spot the HTML I want to edit as it is fully rendered. The hierarchy of files that you need to develop a web site hides the files from you. As a programmer, I use it when looking at large software projects. Drop a project folder that you have never seen on Leap, and you can see that there are 25 .cpp files, 10 .c files, and 100 images all at a glance. It really speeds up the ‘getting up to speed process’. It also works well when you decide to look at a project that you yourself worked on a few years ago.

We are not even sure about the ‘Finder replacement’ label – there are lots of jobs that the Finder does that we have no interest in duplicating.

Tagamac: What inspired Leap’s creation?

Tom: We decided to build a iPhoto for PDFs application (Yep), learned about the power of tags, some of our users wanted more file types, and so we started to work on Leap.

Tagamac: Leap and its older cousin Yep share a certain amount of visual similarity. What good points from Yep did you craft into Leap? What Yep features didn’t make the cut?

Tom: Yep uses a tag cloud and an iPhoto-like view to show you all the PDFs. That was the core we wanted to keep. Yep, being a PDF manager has a lot of PDF-only tools in it, like our reader and the scanner interface. These two things did not make it into Leap – Leap is not a file viewer. We show you thumbnails, and on Leopard we will show you the Quick Look for a document.

Tagamac: Do you see Leap replacing Yep as people’s primary tag-based PDF manager? Or have you tried to leave space for more specific tagging solutions?

Tom: I see people using Yep to manage and track their PDFs, just like iPhoto works for photos. Some people deal with a lot of paper – be it downloaded scientific papers or scanned-in PDFs of actual paper. A dedicated tool that does not make you scan into a dreary OS 9 like application will always have a place. We want Yep to grow. Scanning on the Mac is a complete disaster. There are no good driver models, no support for many scanners, and no good OCR solution. Also, we think that our PDF viewer can be improved.

Tagamac: Do Leap and Yep recognize one another’s tags?

Tom: The beta of Leap imports tags from Yep on startup. We don’t let our beta application write into the tags of Yep. It will all work together when, or very shortly after, Leap ships 1.0.

Tagamac: So how well does Leap play with the other kids? Are Leap tags and so forth searchable via Spotlight?

Tom: We are working on this in a big way for the next beta. Many of popular tagging solutions use Spotlight comments to store tags. There are lots of issues with this system, but we have found some great ways to get it working well with Leap. With Spotlight, if you do a Spotlight search outside of Leap for a tag that you have entered into Leap, you get a result back showing how many documents have that tag within Leap. Also with the next beta, your tags will usually be up-to-date in the Spotlight comments, so individual results will also show up there.

Tagamac: Does Leap support or import tags from other popular tagging programs, such as Punakea, TagBot, or EagleFiler?

Tom: TagBot and other Spotlight tagging programs will be supported really well in Leap 1.0. Also, we are all for what the people who work on Punakea are trying to do – we want a stable, fast, simple tagging system that all applications can use. Spotlight comments will not work for the long haul.

Tagamac: I have to admit, that there’s a few nerds out there who like tagging (like me). Can you tell us a bit about how Leap stores tags? Is it xattr attributes? A specialized database? Magic?

Tom: Leap 1.0 stores tags in up to two places. One will be the Spotlight comments for the files, and the other is in an XML datafile that is not laid out like rocket science. What this means is that if your hard drive gets wiped but you can find a copy of the XML file that you backed up, you can restore all your tags to all your Spotlight comments, etc. This XML file is what we want to get out of managing. Apple needs to create a tagging database. They did it for Address Book a long time ago. I can’t figure out the resistance…

Tagamac: I know from my own use of the Leap beta that the Loupe tool is one of Leap’s most interesting graphical tools. Care to brag a bit? Maybe tell explain why the loupe is preferable to, say, fancy-schmancy Cover Flow?

Tom: When you watch an old crime show on TV, they never pull out a flip book with one picture per page, and then have the witness flip through it. Flip books do not work on a computer either (for search). With our system, your brain can pick out the candidates from our thumbnail view, and then the Loupe can be used to see that you have the correct document.

Tagamac: Care to share any pie-in-the-sky ideas that you have for Leaps of the future?

Tom: With Leopard, it is really neat how fast results come in over the network, since Leopard supports Spotlight queries over the LAN. I think that it will be easy to set Leap up in an office environment and a shared server. All the clients can then be set up to ’see and search’ the files on the server, with a minimum of network bandwidth.

Tagamac: And finally, what didn’t I ask about that you’re dying to tell us?

Tom: I guess it would be Leopard again. The other reason that we got into developing Leap was that we were very unimpressed when we saw the Leopard Finder. Knowing what the technology could do, and where things were going, we really expected more. When you run the Leopard Finder, you can really tell it is the same old Finder, with Cover Flow and some more Spotlight bolted on. We know that the computer can do more. All those billions of cycles and bits are supposed to be there to help you.

Tagamac: Thank you for the interview, and good luck with Leap!