After years of building Tim for Mac — a time tracker used by thousands of freelancers on Mac — and talking to the people who use it, here's an honest breakdown of what to look for and how the main options stack up.

What Freelancers Actually Need in a Time Tracker

Before diving into apps, it's worth being clear about what actually matters for freelance work:

• Fast to start and stop — if it takes more than a click or two, you'll forget to use it

• Menu bar access — you should be able to see what's running at a glance without switching apps

• Projects and clients — you need to separate time by client so you can invoice accurately

• Idle detection — catches the times you walked away and forgot to stop the timer

• Exporting — CSV, JSON, or something you can turn into an invoice

• Stays out of your way — the best time tracker is one you don't have to think about

What most freelancers don't need: team features, Jira integrations, automatic website tracking, or a $20/month subscription for features they'll never use.

Tim — Best for Mac-Native Simplicity

Tim lives in your menu bar and gets out of your way. You set up projects (called Groups) and tasks, then start and stop timers with a click. Idle time detection prompts you to clean up time when you've been away from your keyboard.

What makes it stand out for freelancers:

• Genuinely Mac-native — keyboard shortcuts, menu bar, the works

• Add notes to time entries, which is invaluable for billing ("reviewed contract, client call, revised proposal")

• Filterable export for clean reporting by client or date range

• One-time purchase option

The most common feedback from users: it hits the sweet spot between "too simple" and "too complex." It won't generate invoices directly or sync to QuickBooks, but for capturing and reporting time honestly, it's hard to beat.

Price: Free tier, Pro upgrade \(24.99 lifetime or \)4.99 monthly

Toggl Track — Best Free Option

Toggl is the safe default recommendation and for good reason. It's free for individuals, works across Mac, iPhone, and browser, and has solid reporting. The Mac app is well-designed and it syncs everywhere.

The tradeoffs: it's a subscription for anything beyond the basics, it sends your data to their servers, and the interface — while polished — has more friction than something like Tim for purely local, simple tracking.

Price: Free tier available; paid plans from ~$9/month

Timing — Best for Automatic Tracking

Timing tracks what you're doing automatically — it records which apps and websites you use and lets you categorize time after the fact. If you're the type who forgets to start timers, this approach is genuinely useful.

The downside: it feels less like tracking and more like reviewing surveillance footage of yourself. It's also subscription-only (~$8/month) and can be overwhelming to categorize retroactively.

Price: From ~$8/month

Clockify — Best for Teams

Clockify has a generous free plan and good team features. For solo freelancers who just need something free with web access, it works. It's not particularly Mac-native but it's solid.

Price: Free; paid plans for more features

The One-Time Payment vs. Subscription Question

This comes up constantly in time tracker discussions, and it matters more than most apps will admit. A time tracker is a tool you run every day, indefinitely. Paying $8-20/month forever for that adds up fast.

Apps with a one-time price (like Tim) align better with how freelancers actually think about software spend. You buy it once, it works, done. No recurring billing to justify, no features locked behind a higher tier.

If subscription pricing doesn't bother you, Toggl or Timing are both good options. If you'd rather pay once and move on, Tim is the obvious choice in this category.

What to Actually Try

Here's the honest advice: download the free version of two or three apps and use them for a real work week. Time trackers are deeply personal — what feels frictionless to one person feels clunky to another.

If you work in a predictable pattern (same clients, same types of tasks), Tim or Toggl will serve you well. If your days are unpredictable and you forget to track, give Timing a shot.

The worst outcome is spending months with a tool that has enough friction that you stop using it. A slightly worse app you actually use beats a slightly better app you don't.

Tim is made by Neat Software — a small indie shop building focused Mac and iOS apps. You can try Tim for free on the Mac App Store.

ToolbarItem {
    Button(action: {}, label: {
        Label("Like", systemImage: "heart").labelStyle(.iconOnly)
    })
}

let notificationsPath = "x-apple.systempreferences:com.apple.Notifications-Settings.extension"
let bundleId = Bundle.main.bundleIdentifier
if let url = URL(string: "\(notificationsPath)?id=\(bundleId ?? "")") {
    NSWorkspace.shared.open(url)
}

Unfortunately, AppKit does not offer an easy API for accessing the system sounds. However, we can find and read them from the file system:

func getSystemSoundFileEnumerator() -> FileManager.DirectoryEnumerator? {
    guard let libraryDirectory = NSSearchPathForDirectoriesInDomains(.libraryDirectory, .systemDomainMask, true).first,
          let soundsDirectory = NSURL(string: libraryDirectory)?.appendingPathComponent("Sounds"),
          let soundFileEnumerator = FileManager.default.enumerator(at: soundsDirectory, includingPropertiesForKeys: nil) else { return nil }
    return soundFileEnumerator
}

Next, we need to register the sound files with the system audio services so we can use them as sound effects in the app. Let's create a simple struct to store the sound name and registered sound id:

import AudioToolbox

struct SoundEffect: Hashable {
    let id: SystemSoundID
    let name: String

    func play() {
        AudioServicesPlaySystemSoundWithCompletion(id, nil)
    }
}

extension SoundEffect {
    static let systemSoundEffects: [SoundEffect] = {
        guard let systemSoundFiles = getSystemSoundFileEnumerator() else { return [] }
        return systemSoundFiles.compactMap { item in
            guard let url = item as? URL, let name = url.deletingPathExtension().pathComponents.last else { return nil }
            var soundId: SystemSoundID = 0
            AudioServicesCreateSystemSoundID(url as CFURL, &soundId)
            return soundId > 0 ? SoundEffect(id: soundId, name: name) : nil
        }.sorted(by: { $0.name.compare($1.name) == .orderedAscending })
    }()
}

Now we can use the SoundEffects anywhere in the app. Here is an example using SwiftUI to display them in a Picker and trigger the sound whenever the selection changes:

import SwiftUI

struct SoundEffectPicker: View {
    @Binding var selection: SoundEffect?

    var body: some View {
        Picker(selection: $selection, label: Text("Sound:")) {
            Text("None").tag(nil as SoundEffect?)
            ForEach(SoundEffect.systemSoundEffects, id: \.self) { sound in
                Text(sound.name).tag(sound as SoundEffect?)
            }
        }.onChange(of: selection) { sound in
            sound?.play()
        }
    }
}

One important note to mention: SoundEffect.systemSoundEffects needs to be invoked at some point when your app runs so the sounds get registered with AudioServices. For example, if you only used the Picker in a preferences window and that may not be open the next time the app starts up, the sounds wouldn't be registered. You could simply add it to your app delegate on launch to be sure:

func applicationDidFinishLaunching(_: Notification) {
   _ = SoundEffect.systemSoundEffects
}

You can see how we integrated this in a real app to add sound effect preferences in our time tracking app: Tim

A full demo app of this code can be found on GitHub: https://github.com/neatsoftware/SoundEffectsDemo