FileWorks — User Manual

Your first transfer takes just four steps:

When the job finishes, the files are in the destination folder. When moving files, FileWorks removes the originals only after the copies have arrived safely.

The toolbar at the very top carries the global commands — the ones that are not tied to a particular panel:

The panels are what the window is for: each stays wide enough for its list to remain readable. As you make the window narrower, the other areas give way step by step:

When the window gets wider again, everything comes back in reverse order, the inspector at its previous width. Your settings stay as they are: what you have hidden stays hidden. The window cannot be made narrower than the panels themselves. Inside the panels, the list columns adapt as well (see When a Panel Gets Narrow).

If you show the sidebar or the inspector explicitly — with ⌥ + ⌘ + S, ⌥ + ⌘ + I or the toolbar buttons — it appears even when there isn’t really room; the panels get narrower instead. Likewise, the sidebar takes priority when you drag it wider: then the inspector gives way. The next time you resize the window, the order above applies again.

One small detail saves time: when you move up a level, the folder you came from is immediately selected again. You can therefore continue navigating with the arrow keys.

The path bar shows the current location as a row of clickable folders. A click takes you straight into that folder. If the path is longer than the panel, the bar slides so the current folder stays visible.

Between two folders you see a small chevron. Click it and a menu of the neighbouring folders at that level opens. From there you jump straight into a folder alongside, without going up and back down.

Press ⌘ + ⇧ + G to enter a path directly. You can use an absolute path, ~ for your home folder or a path relative to the current folder.

As you type, the field suggests matching subfolders. Use ↑ / ↓ to select a suggestion, ⇥ to complete the path, ⏎ to open the folder and esc to cancel.

The drive icon at the top left of a panel opens the jump list — or press ⌘ + 1 for the left panel and ⌘ + 2 for the right one. It holds your favourites, with every attached drive below them. The location you are in right now carries a tick.

At the very top, under Other panel, you see the folder shown in the opposite panel, with its path beneath it. Click it to show the same folder in both panels. The entry is hidden in single-pane mode and whenever both panels already show that folder.

The quickest way to use the list is to start typing. Each character narrows the list, and the first match is selected automatically. For example:

Capitalisation and accents make no difference: grosse finds a folder called Größe, and doc is enough for Documents.

Each panel has its own row of tabs along the bottom edge.

By default your tabs are back the next time you launch. If you prefer a fresh start, turn that off under Settings  General.

Each panel shows its contents either as a list (⌘ + ⇧ + 1) or as an icon grid (⌘ + ⇧ + 2). FileWorks remembers the choice per panel.

The list is a table; sort it from the column headers. In the icon grid everything familiar works: drag a selection rectangle, ⌘-click and ⇧-click, ⌥-click to mark, type to jump. The arrow keys take you in all four directions.

Click a column header to sort by that column; click it again to reverse the direction. The same fields sit in the Sort menu: Name, Extension, Size, Modified and Kind. With Sort folders first switched on (the default), folders always come before files — whatever you sort by.

Choose which columns to display under Settings  General → Columns: Extension (as its own column — FileWorks then shows the name without it), Size, Modified, Kind and Finder Comment. The Name column is always there.

Space shows the selection in Quick Look, exactly as in Finder. The arrow keys page through the selected items inside the preview window; Space or esc closes it again.

If an item is inside an archive, FileWorks first extracts it into a temporary cache. If that takes a moment (large archives), a progress bar with a Cancel button appears.

You turn the inspector on with ⌥ + ⌘ + I. With exactly one item selected in the active panel, it shows that item’s details:

If several items are selected, the inspector shows a summary with the total size instead.

The inspector sits as a column at the right edge of the window. To change its width, drag its left edge; FileWorks remembers it. In a narrow window it gets narrower and, if need be, disappears (see When the Window Gets Narrow).

The selection is the familiar macOS highlight — the row (or rows) under the cursor. It follows the arrow keys and a single click. The cursor-related commands act on the selection: Rename, Quick Look, the inspector and opening a folder.

Marks are a second layer on top — the classic commander trick. A marked item wears a coloured pill around its icon and name (in the icon grid, around the whole tile). The key difference: marks stay. You can move the cursor, click elsewhere, filter — the marks hold until you clear them or leave the folder.

That is what makes them so useful. Almost every file command acts on the marks when there are any, and on the selection otherwise — Copy, Move, Duplicate, Delete, Edit, Pack, Multi-Rename, Create Link, Add to Drop Shelf and your own tools. So you can put a batch together at your own pace and then work on it. A stray click no longer clears your marks. The status bar shows it: "N of M marked".

Clicking selects; ⌘-click adds or removes single items; ⇧-click selects a range. Several ⇧-clicks in a row always measure from the same starting point, so you can grow the range and shrink it again.

Drag a rectangle from an empty spot — in the list below the entries, in the icon grid between the tiles. With ⌘ or ⇧ you add to the existing selection. Drag past the edge and the view scrolls along, even if you hold the mouse still there. A plain click on an empty spot clears the selection; marks stay.

If FileWorks is in the background, the very first click already counts: it selects, and you can start dragging right away — just as in Finder.

To mark with the mouse: hold ⌥ and click — in the list on the name, in the grid anywhere on the tile. This toggles the mark without touching the selection. For every modifier key, what counts is what you hold when you press the mouse button — not when you release it. The context menu also has Mark / Unmark.

The arrow keys move the cursor. In the list, ⇧ + ↓ and ⇧ + ↑ extend the selection into a contiguous range. ⌘ + A selects everything. esc clears the marks first, then the selection.

The main keyboard tool for marking is ⇧ + Space. It marks the item under the cursor and moves down one row. Press it repeatedly and you mark a whole run in one go. Plain Space stays Quick Look, as in Finder.

Have you just selected a range, say with ⇧ + ↓? Then ⇧ + Space turns that whole range into marks and frees the cursor again. You can build the next block somewhere else.

These commands are in the Actions menu. They all produce marks, so a stray click does not discard their result:

The three pattern tools appear in the same place: as a block above the file list. Each works on its own, so FileWorks shows only what you ask for. When several are open, they always keep this order:

From top to bottom they form a chain: each stage works on the result of the one above. That is exactly why you can use all three in sequence — search, filter the result, mark what remains by pattern, then press F5.

The order in the block is fixed; it does not depend on which you opened first. Each stage has its own ✕ and its own shortcut, so you can close it independently.

Marking by mask is a one-off action: you type a pattern, press ⏎, and the matching items are marked. The field then closes again.

⌘ + S unfolds it above the file list — in the same place as filter and search (see Search, Filter, Mark — Three Stages, One Place).

As you type, the field shows how many items the pattern would match if you pressed ⏎. Keep an eye on that number: this marked set is exactly what F5, F6 and F8 then act on.

Patterns you need again and again do not have to be typed every time. Under Settings  Patterns you store them under a name — say Temporary files for *.tmp;*.temp;*.bak;*~.

Five presets are set up already, in two groups:

Every preset also remembers whether it may match folders as well — which is why Version control finds the .git folder while Temporary files means files only. That switch also decides where the preset shows up at all (see below). A group sorts the entry into a submenu of its own; without a group it sits below the groups.

As soon as the first hits arrive, a Location column slides in right after the name. It names the folder below the search folder; a dot means "directly in it".

It sits well to the front on purpose: after the name, where a hit lives is the next thing you want to know. If you also show the extension column, Location moves behind it — that keeps name and extension together.

Clicking the column header sorts by location — by the containing folder, that is, not by the file name. All hits from the same subfolder therefore end up together. This works while the search is still running, too.

When the search ends, the column disappears again. If you had sorted by it, the sort order jumps back to Name. In an ordinary folder every entry shares the same location — the list would otherwise sit there in seemingly arbitrary order.

Without wildcards, part of the name is enough: invoice finds Invoice_2024.pdf as well as FinalInvoice.docx. Accents don’t matter — muller also finds Müller.pdf.

With wildcards the pattern applies to the whole name:

Separate several patterns with a semicolon or a vertical bar: *.pdf;*.docx finds both. A space does not separate patterns here — Invoice March searches for exactly that part of a name. In the mask row (⌘ + S) a space does separate; there you type *.jpg *.png.

There are two equivalent ways:

The button is more than a convenience. Changing a filter on its own triggers nothing — otherwise every keystroke in the exclusions field would start a new run. Without the button you would have to click back into the search field after each change and press ⏎.

So that you never have to guess whether what you see is still current, the button shows its state:

The states differ in shape, not just in colour. The macOS accent colour is freely configurable, so a difference in colour alone would not show under every setting.

Two menus sit to the left of the search field. They always show how the search is configured:

RegEx mode highlights its menu prominently, and for good reason. Characters like ., ( or + are perfectly normal in file names, yet here they suddenly mean something else.

Is the expression malformed? Then a red warning triangle appears and the search does not start at all. A message beats an empty result list that looks like "nothing found".

The same menu holds Match Case. Without that tick — the normal case — readme also finds README.md.

Both menus remember your choices, even across restarts. The filters in the next section deliberately do not.

The filter button unfolds a second row. It has two areas, and the difference between them matters more than you might expect.

Which hits count — these three filters work on what the search has already found:

Where not to search at all — the second area acts one stage earlier: folders whose name matches here are never opened. In a development directory node_modules;.git is often the difference between a search that runs into its limit and one that finishes in seconds.

Both shortcuts toggle: the same shortcut that shows a bar hides it again. The menu entry tells you which way it will go — it alternates between Filter … and Hide Filter, and between Find Files … and End Search.

Two further ways always work:

Closing tidies up as it goes. The filter empties, since the list would otherwise stay inexplicably short. And ending a search discards the results and shows the folder again. Want to empty the field but keep the bar? Use the button to the left of the ✕ in the filter bar.

Two pieces of information appear beside the magnifier: how many entries FileWorks has examined so far, and which folder it is reading. Without them you could not tell a slow area from a standstill — the hit count alone stands still as long as nothing matches.

When the search meets a folder whose contents are not kept on this Mac, it asks: include, skip or cancel. That is the same prompt as in the folder comparison (see Large Folders and Items from the Cloud). FileWorks asks once per search.

A warning triangle beside the hit count means the result is incomplete. Either you had folders skipped, or the search reached its limit. That limit is 50,000 hits and 200,000 entries examined. The second limit stops a search that finds nothing and would otherwise run unchecked through the entire tree.

The stop button ends the search. If it is currently reading a cloud folder, the last read may take a moment to finish, but the display reacts at once.

Mark items in the active panel and press F5 to copy or F6 to move them to the other panel. The same commands are on the action toolbar, in the context menu and in the Actions menu (⌘ + ⇧ + C / ⌘ + ⇧ + M).

In single-pane mode there is no "other panel" — then FileWorks asks for a destination folder (see Single-Pane Mode).

Every copy and move job runs through a queue. Packing, deleting and custom tools use it too. FileWorks processes one job at a time while the others wait. The queue appears at the bottom of the right panel — or the only panel in single-pane mode. Each card shows a progress bar, the current item, the transfer speed, the estimated time remaining and a Cancel button.

If a card says Preparing …, FileWorks is still fetching the files from the sender — from the Photos app, for instance. Cancelling stops that, and anything that could not be loaded is named on the card. If it says Reading archive, see Why Some Archives Take Longer.

The queue appears automatically when a job takes more than a moment and disappears after a successful run. Jobs that finish with errors remain until you clear them with Clean Up or the × on the card. The same applies to a cancelled job for which FileWorks had to preserve a previous version: the card remains visible while it shows where that version was saved. Use the Transfers button to show the queue manually.

If the volume fills up during a job, FileWorks stops instead of letting every remaining item fail for the same reason. Whatever was transferred stays; the message names the cause once rather than a hundred times.

When the destination already contains an item with the same name, a conflict dialog appears. It shows both items side by side, including their sizes, dates and a "Newer" hint. Below them, you can choose how to proceed:

The first row is preselected, so ⏎ keeps both items. Hold ⌘ to display a number beside each option; ⌘ + 1 through ⌘ + 5 select an option directly. The numbers vary because Merge appears only for folder conflicts.

Tick Apply to all further conflicts and your choice holds for the whole job — separately for file and for folder conflicts.

Your choice applies to the state shown in the dialog. During a large job, another app — a sync service, for example — may change the destination before FileWorks carries out that choice. If this happens, FileWorks does not replace the changed item. Instead, that item fails with a message, and the other app’s version remains untouched. The same protection applies if a new folder appears at the destination after you made your choice: FileWorks does not silently merge your files into it. Both cases appear in the job’s error list.

When moving, FileWorks deletes an original only after confirming two things: the source is unchanged, and the new copy is still at the destination. If another app removes the copy in the meantime, the original remains in place and FileWorks reports the problem.

If FileWorks has to undo a folder replacement, it removes only the folder it placed at the destination. If another item has appeared there in the meantime, that item remains untouched; FileWorks restores the previous folder beside it instead.

As in Finder, renaming can also be started with the mouse: click an item, wait a moment, then click it a second time.

"Slow" only describes how it feels. These are two separate clicks in the same spot: the first does not open the input field, but the second does. The gap must exceed the interval set for a double-click in your system settings — otherwise it is a double-click, and that opens the folder. FileWorks reads that interval from the system settings, so a faster double-click setting means a shorter wait here. The upper limit is two and a half seconds: wait longer and the next click starts a new click sequence.

Nothing happens if you move the mouse while doing it — then you are dragging, and dragging is not clicking. Nor does the click that switches to the other panel trigger it: it makes that side active, no more. Otherwise switching sides would repeatedly trigger renaming by accident, since something is usually selected over there already.

In the icon view you need a little more patience than in the list. The grid only decides that a click was a single click once it is certain no second one follows.

To give many files new names at once, select them and open Multi-Rename … (⌘ + ⇧ + R). The dialog continuously previews the resulting names. It also checks for duplicate target names, clashes with existing files and invalid names.

F8 (or the Trash button) removes the marked items — or the selection, if you have marked nothing. Whether they go to the Trash or vanish straight away, and whether FileWorks asks first, you set under Settings  General → Deleting. On drives without a Trash (some SMB servers), FileWorks offers to delete permanently instead.

In the context menu you swap the two: hold ⌥ and the entry changes. If your default is the Trash it now reads Delete Permanently — otherwise the other way round. It happens live, while the menu is open.

The Create Link submenu (Actions menu or context menu) makes:

An alias still finds its target after you move or rename it, and it works across drives. FileWorks creates symbolic links within the same folder as relative links, so they survive when the whole folder moves.

FileWorks uses the normal clipboard — compatible with Finder in both directions:

In the context menu the first command reads Copy to Clipboard, spelled out in full. That clearly distinguishes it from Copy to "…", which sends the files straight to the other panel.

Drag items from a list into Finder or into the other panel. Dropping copies by default; hold ⌥ and it moves instead. Drop something into a panel and it lands in that panel’s current folder. Drop it straight onto a folder row and it lands in that folder.

Drag something out of an open archive and a card appears in the queue — with progress and a Cancel button. Finder picks the target name: if a folder of the same name is already there, it puts yours next to it (“Folder 2”) instead of asking. If you cancel, FileWorks removes the half-extracted folder again — but only as long as the folder FileWorks created is still there. If another program has replaced it with a different one in the meantime, that one is left alone.

The Drop Shelf at the top of the sidebar is a holding area. Drag files onto it, or select them and press ⌘ + ⇧ + D (Add to Drop Shelf, also in the context menu). That way you collect items across several folders and drag them into a destination together — into Finder or into a panel.

Add something while you have hidden the sidebar and FileWorks shows it, so you see the result. If it is only collapsed because the window is too narrow, it stays collapsed and appears as soon as the window is wide enough (see When the Window Gets Narrow). The list button in the shelf header holds the per-item actions and the option Keep items after dragging out. That one helps when the same collection has to go to several destinations in turn.

Many programs offer a fixed choice for creating a file: an empty text document, a spreadsheet, perhaps a presentation. FileWorks does not come with such a list. Instead you put your templates into a templates folder, and every file in it appears in the New File menu. So you decide what is on offer.

When several apps match, FileWorks presents them in a chooser. The file type’s default app appears separately at the top, even if you have not registered it as an editor. It is often the app you want.

The dialog works entirely without the mouse:

The dialog leaves out programs that are no longer on the machine. They could not be launched anyway, and would only shift the numbers of the remaining rows.

Sometimes you want to open a file somewhere else just this once — that HTML document in a text editor rather than the browser. For that, the context menu of a single file offers Open With. It lists every app that can handle this file type:

The list comes from macOS itself — the same one the Finder shows. There is nothing to set up: install a new app and it appears on its own.

The quickest way is the context menu. Right-click one or more items and open the Tags submenu. It lists the seven system colours and every tag you already use, each with a check mark. A click toggles the tag on the selected items:

Finder behaves exactly the same way. The coloured dot beside each entry shows the colour.

Clicking a checked tag removes that tag from the selected items, but only that one tag. In a folder with many different tags, you would have to find and untick each one separately.

For that, the bottom of the Tags submenu holds Remove Tags. It strips every tag from the selected items at once. Since this cannot be undone, FileWorks asks first and shows the number of selected items.

Only items that actually carry tags are changed — files without tags are skipped. Afterwards the status line says how many items were really cleared, or No tags found if there was nothing to do. Your tag list stays as it is: the tags go from the files, not from the sidebar.

New Tag … — in the Tags submenu of the context menu or via Add Tag in the inspector — opens a small dialog. Type a name, optionally pick a colour (the first swatch, a crossed-out circle, means "no colour") and press Assign Tag. The tag lands on the selected items and moves into your tag list, so it shows up in the sidebar and in future menus.

With exactly one item selected, the inspector (⌥ + ⌘ + I) shows that file’s tags in the Tags section. They appear as small chips that you can click to remove. Add Tag attaches a system tag or an existing tag; New Tag … creates a new one. Take the last chip away and the file carries no tags at all. See Viewing File Information in the Inspector.

In the list view, small coloured dots sit next to the name of every tagged file — one dot per colour, slightly overlapping, as in Finder. Hover over the file to see the tag names. (The icon grid stays deliberately tidy and shows no dots.)

Every tag you use appears in the Tags section of the sidebar (which stays hidden until you have at least one). Each row shows colour and name. The section is collapsible like the others; see The Sidebar.

The list is a convenient index, not the tag itself. Remove from Sidebar (context menu) takes only the entry out of the list. The files keep their tag, and the entry returns as soon as FileWorks encounters the tag again.

Click a tag in the sidebar (or Find Tagged Files in its context menu), and FileWorks searches system-wide for every file with that tag — via Spotlight. The hits stream into the active panel, just like a file search (see Searching), with a Location column, and the status bar shows Tag "…": N items. For a search result, Go to Enclosing Folder opens its actual location. Navigate away and the tag search ends.

Tag changes in FileWorks appear immediately. Changes made elsewhere — in Finder or another app — are picked up by FileWorks the next time you open the folder (navigate away and back). To refresh everything at once, press ⌥ + ⌘ + R (Refresh).

A small icon appears at the right of the name column — but only when there is something to say:

Files that are fully downloaded, and files outside iCloud altogether, show no icon. The list therefore highlights only files that are not yet stored locally. Hover over an icon for a short explanation.

Select one or more items, then right-click the selection to choose an action:

Both actions work on the entire selection and skip any items they do not apply to.

For a single item, the inspector (⌥ + ⌘ + I) also has an iCloud section with the same Download Now / Remove Download button.

You do not have to download a file before copying or moving it. When a job needs a cloud-only file, FileWorks fetches its contents as part of that job. The copy is therefore complete, never an empty placeholder.

This works with any provider — iCloud, Dropbox, OneDrive or Google Drive — because it uses the macOS File Provider framework. For iCloud you see a cancellable "Downloading …" step; other providers download quietly in the background. See The Transfer Queue.

Double-click a .zip, .7z, .tar.*, .rar or .iso file and it opens like a folder; FileWorks supports additional formats as well. The path bar leads you through the levels. You cannot write into an archive; on the right of the status bar, the archive pill takes the place of the free space (see Reading Archive Status in the Archive Pill).

When copying items out, FileWorks preserves the permissions stored in the archive: a file that only you could read remains private, and an executable script remains executable. An archive cannot, however, grant broader access than macOS normally gives a new file. A file stored as writable by everyone is therefore extracted as writable only by you. The command-line tool tar behaves in the same way.

FileWorks discards inappropriate permissions, such as those that would run a file under another user’s identity. Files, folders and links also retain the modification date stored in the archive rather than receiving the extraction time.

While FileWorks is filling a folder, only you can access it. The folder receives the archived permissions only after its contents are complete. If you cancel, folders already created remain protected in this way.

If one of these folders is moved and replaced while extraction is in progress, FileWorks leaves the replacement untouched. When extracting into an existing folder, FileWorks also preserves that folder’s permissions and modification date.

If you downloaded the archive from the internet, it carries macOS’s quarantine flag. FileWorks passes it on to everything you take out — including files you open straight from the archive. macOS therefore checks an app or installer package from a downloaded archive when you first open it, just as if you had extracted the archive in Finder. Nothing that comes out of an archive you created yourself gets the flag.

Not every drive supports the quarantine flag. If it cannot be set, FileWorks still extracts the items. The queue card then remains visible and shows in orange how many items have no quarantine flag; Details … lists them individually. macOS will not perform its usual first-open check on those items.

A stricter rule applies when you open a file directly from an archive: if FileWorks cannot set the quarantine flag, it does not open the file.

If a .tar holds a hard link (two names, one content), you get the content, not an empty file. If such a reference points nowhere, FileWorks says so instead of quietly delivering nothing.

If a single file fails while you drag to Finder — because the password is missing, say — FileWorks removes it instead of leaving it empty or half written. Whatever has already arrived stays.

If the archive file changes while you are inside it — because you replace it or another program rewrites it — FileWorks reads it again by itself. If an operation is running on the old state at that moment, it reports The archive was changed after it was opened — open it again and repeat the action for the remaining entries. That way, parts of two different archives never get mixed.

You can turn browsing off entirely under Settings  General → Archives — then a double-click opens the archive with its default app.

When a panel is inside an archive, the right side of the status bar shows a pill with the archive’s name instead of the free space. Normally it is grey and unobtrusive. It only takes on colour when there is something to know:

In the inactive panel the pill stays grey; the symbols stay the same.

Click the pill to see details about the archive:

With .zip everything is quick: each file sits there on its own, and FileWorks jumps straight to the one you need.

With .7z, .tar.gz and their relatives it is different. These formats compress the files as one piece, often the whole archive as a single connected stream. That saves space, but it has a consequence: to reach a file in the middle, everything before it has to be unpacked first. There is no shortcut — every other program has to do the same.

An example from practice: a 4.8 GB 7z archive. The folder Sourcecode inside it is tiny at 88 MB, but sits behind 4.7 GB of other data. A good minute passes before the first file appears; after that, all files are there within seconds.

So you are not left guessing during that time, the card in the queue shows Reading archive along with how far FileWorks has come in the archive file. The number keeps growing — the application is not stuck, it is reading.

That it stays at this one minute is down to reading ahead: when copying to a panel, FileWorks works folder by folder, but the archive delivers the files in its own order. Whatever passes by and will be needed shortly, FileWorks briefly sets aside instead of reading from the start again later. That takes some free space at the destination, 1 GB at most. If space is tight, FileWorks does without it: the operation takes longer but succeeds — room for your files always comes first.

The same applies when you drag several entries to Finder at once: FileWorks reads the archive for all of them together instead of unpacking it from the start for each entry.

Mark items and choose Pack … (Actions menu or context menu):

Clicking Pack closes the dialog, and the job carries on in the transfer queue — like a copy or a move. So you can keep working while it packs. The card shows progress, speed and a Cancel button; cancelling leaves no half-written archive behind.

If FileWorks is to remove the originals afterwards, you can follow the three steps there as well: packing, checking, removing.

An archive format does not carry everything attached to a file: Finder tags, Finder comments, resource forks and access control lists stay behind. FileWorks does not pass over that — it tells you which items are in the archive without their extra data, and blocks removing those originals. They are packed all the same; a part of them is simply missing.

If there is anything to report, the card stays put and Details … opens the full view. It keeps three easily confused things apart: items that were skipped and are not in the archive at all; items that are in it without their extra data; and rescued previous versions, whose location you need to know. If everything went smoothly the card disappears — the finished archive is then selected in the panel.

An archive can become damaged without you noticing: a transfer may be interrupted, a drive may deteriorate or a copy may arrive incomplete. The file is still there and its size may look plausible; the damage might become apparent only when you extract it, perhaps years later.

Mark an archive (or several) and choose Verify Archive … from the context menu or via Actions  Verify Archive …. FileWorks reads every entry once in full without writing the contents anywhere. The only question is whether all the data can be read without errors. Nothing is extracted, but verification takes as long as a full extraction.

For a single archive the result sits right in the header; for several you get a list with one row per archive. FileWorks names every entry that failed; Copy Report puts the list on the clipboard.

When you open or extract an encrypted archive, FileWorks asks for the password. Mistype it and it asks again. A password is remembered for that archive only, and only for the current session — FileWorks never writes it to disk.

This applies to ZIP archives, whether encrypted with the classic scheme or with AES. FileWorks cannot decrypt password-protected 7z and RAR archives — the macOS archive component FileWorks builds on does not support it. FileWorks then does not ask for the password at all but tells you to open the archive with another app, such as Keka. If the file names are encrypted too, the archive cannot be opened at all; otherwise you see its contents but cannot take anything out. The archive pill then turns red, with Encryption not supported among the findings. In this case FileWorks creates nothing at the destination — no empty files and no empty folders.

If you dismiss the prompt, FileWorks won’t ask again during that same operation: on a job covering a hundred entries you don’t want to be asked a hundred times. The next action brings the question back — leaving the archive and opening it again, pressing Space again, or starting a transfer.

The dialog first asks what you want to find out. A checksum is not the goal; it is the means of answering a question. The selected job determines which columns the table shows and which actions are available afterwards.

The preselected job depends on your selection: one file selects the expected-value check, several files select checksum computation, and marked folders select the folder comparison. If the clipboard holds something that looks like a checksum, the expected-value check takes priority — and the value is already in the field. That is exactly the flow “copied the value from the website, marked the file, opened the dialog”.

Next to Start you set the algorithm. Changing it costs nothing there; later it would mean recomputing. For the two jobs with a reference the picker is disabled, because there the reference decides the algorithm itself.

In the working view the top row names the running job — and, for comparisons, which criteria FileWorks uses to match files. Change Job … takes you back to the selection without losing the values already computed.

Choose the algorithm at the top right. For everyday use, pick SHA-256: it is today’s standard, and websites usually quote exactly that value.

MD5 and SHA-1 are legacy algorithms with known collision weaknesses: an attacker can deliberately construct different files with the same value. You can still use them with old checksum lists, but not for security-sensitive verification.

The ⓘ beside the menu explains each algorithm in a sentence. Values from different algorithms cannot be compared, so switching triggers a recalculation — but only for values still missing for the new algorithm. Values once computed are kept per algorithm, so switching back costs nothing.

There is no separate job for this — duplicates are detected automatically during Compute checksums. FileWorks simply groups the computed values without reading any additional files.

As soon as several files share a value, their contents are identical — no matter what they are called. FileWorks collects them into groups and gives each one a number and a colour.

A click on the # column header brings the groups together. With a few dozen files the colour is enough; with several hundred, sorting is the real gain, because related files would otherwise sit far apart.

For tidying up, the context menu offers Select duplicates, keep first. FileWorks leaves one file per group untouched and marks all the others. Move to Trash then does the rest. Should you select a complete group by hand, FileWorks asks first — otherwise that content would be gone for good.

Reputable providers state the expected checksum alongside their files. Rather than comparing 64 characters by eye, paste the value into the field above the list. It appears only in the Check against an expected value job — in the others there would be nothing for it to match.

The field is deliberately tolerant: it picks the value out of whatever you paste. Whether you copy the bare value, the whole line a3f9… ubuntu.iso from a checksum file, or something like SHA256: a3f9… — it finds it.

Better still: if the length of the pasted value matches a different algorithm, FileWorks switches by itself. Paste a 64-character value while MD5 is selected and it moves to SHA-256 on its own.

While a check is running, the duplicate-group colours are switched off and only the matches turn green. Two sets of colour coding at once would be ambiguous. Clear the field and the groups return.

This answers the question "Is my backup complete and intact?" Select the files or folders you want to check, then choose the Compare with a folder job in the initial step. FileWorks offers the opposite panel as the destination — that is what two panels are for. You can also pick any other folder.

FileWorks matches by relative path — the job row says so too. Your selection Pictures with the file 2024/holiday.jpg is therefore matched to <destination>/2024/holiday.jpg. A file of the same name elsewhere in the destination does not count as a match; the two features below exist for exactly that case.

Every row then gets a verdict:

Below the list stands the tally — how many are identical, differing, unclear or missing. The Only differences tick hides everything that matched: with 500 files you want to see the three problem cases, not 497 ticks.

The coloured counters below the list double as selection aids: a click on “39 missing” marks exactly those rows. The same commands live in the context menu under Select.

The dialog lets you act on the results as well as view them. Right-click a selection — or use the buttons at the bottom left:

Select → All missing followed by Copy to destination brings an incomplete backup up to date in two clicks.

Many downloads come with a file such as SHA256SUMS listing the expected value for each name. FileWorks reads those, and writes them too.

The common formats are supported — with one or two spaces, binary mode with an asterisk, and the BSD form SHA256 (file) = value. Comment lines and lines matching no pattern are passed over: one broken line does not render the rest of the file useless.

For every available algorithm, the same holds: the chance of two different files accidentally sharing a value is so small that it does not happen in practice. "Same checksum" here reliably means "same contents". Only with deliberately constructed files can this be subverted for MD5 and SHA-1 — one more reason to stay with SHA-256 when in doubt.

How many files FileWorks reads at once depends on the drive. On a network share it reads one after another, because they all share the same connection. On the internal SSD it reads several in parallel. During a comparison this applies to each side separately — source and destination usually sit on different drives and do not get in each other’s way.

Folders and packages such as .app or .macvm have no checksum of their own; they are directories. FileWorks therefore breaks them down into their individual files. To know whether a package arrived intact, every file inside it counts anyway.

Very large selections are deliberately reined in. From around 20,000 files the dialog asks whether you really mean that many; beyond 40,000 it declines.

The destination folder of a comparison has its own, much higher limit of 200,000 files. FileWorks builds no sortable table there, only a list of path, size and location — and it reads only what qualifies by path or size. For collections of that size, a purpose-built tool is the better choice.

This distinction is worth knowing, because it explains what works here and what does not.

FileWorks speaks no network protocol of its own. macOS establishes the connection — the same machinery Finder uses for ⌘ + K. The system mounts the share as a drive, just like an external disk. From then on, as far as FileWorks is concerned, it is an ordinary folder.

That is the main advantage: all of FileWorks’s features work on a mounted share. Checksums, archives, thumbnails, search, multi-rename and folder comparisons need no special network mode. Because the share is mounted as a volume, other apps can access it too. You can reach it from any Open dialog and drag files from it into another app.

A dedicated FTP program takes the opposite route. It speaks the protocol itself, shows a listing that exists nowhere outside its own window, and downloads files before you can edit them. In exchange it can do things a mounted drive fundamentally cannot — more on that below.

Which protocols are available is decided by macOS, not by FileWorks:

So you can browse, view and download. Uploading, deleting, renaming and changing permissions will not work — for those you need an FTP program. You can write normally over every other protocol in the table.

A mounted drive behaves differently from your internal disk in a few respects. This applies to every program that works this way — the Finder included:

Let’s start with the simplest case, no script at all. Suppose you always open your images in the same app — say Pixelmator. Here’s how you build yourself a button for it:

Now mark a few images, open the Tools menu — and your new entry opens them all in Pixelmator. That’s it. No $, no quotes, nothing.

Every tool is one of these four kinds. Pick the one that fits your task:

Launch app with selection — the simplest case (the example just now). You pick an app, and the tool opens the marked files in it. Nothing more: no arguments, no output, no script. A fixed "Open With …" as a button.

Run program / script — here a program or a small script of yours runs, and you decide which files and values it gets. This is the choice as soon as a ready-made program (such as sips, ffmpeg, jq) or your own script should do the work.

Run shell command — for quick commands, just like on the command line. A tool of this kind runs a command in the shell (zsh), on one line or several, with its full set of features: pipes (|), chaining (&&), redirections. Ideal for trying something out quickly.

Run shortcut — starts a shortcut from the macOS Shortcuts app and hands it the marked files (see Using Shortcuts from the Shortcuts App). Ideal when you have already built your automation there.

If you are just starting out, stick to the first kind as long as it meets your needs. We explain the others step by step, with examples you can follow.

A tool works with the files you have just marked (the coloured pills). If you have marked nothing, it uses the current selection — the highlighted files. In this chapter, we call this the tool’s working set.

The difference between selection and marks is described in the chapter "Selecting Files". For now this is enough: mark the files the tool should work with, then run it.

A tool has to know what to work on. That is what placeholders are for — short tokens that FileWorks replaces with the real values when it runs. The most important one is {paths}: it stands for "the paths of all marked files".

For example, the program wc counts lines. If you enter the following shell command

and mark three text files, FileWorks turns it into this when you run it:

So wc gets the three files and counts their lines. You yourself only type {paths} — FileWorks fills in the rest.

You don’t have to memorise the placeholders. In the tool editor there is a glossary of all of them. Click one and it goes into the field you last typed in: into the command at the insertion point, into the output file name at the end. Hovering shows you what it will insert.

The colours in the command field show what FileWorks makes of it:

Point at a grey or red spot and FileWorks tells you why.

These are the placeholders:

Singular or plural? This is the one stumbling block, and it is quickly explained:

Rule of thumb: the plural placeholders ({paths}, {names}) become one value per file, not one long piece of text. Mark three files and your program really gets three separate entries.

Sometimes a tool should work a little differently each time. Instead of building a separate tool for every variant, you let FileWorks ask when it starts.

For this you write, at the spot where the value should go, a question in curly braces with a question mark: {?Your question}. When it runs, an input field with exactly that label appears, and what you type is inserted.

For example, to shrink images to a maximum edge length of your choice, enter these arguments for Apple’s sips program:

Run the tool and FileWorks asks: "Longest edge in pixels". If you type, say, 1200, the image is reduced so its longest edge is 1200 pixels, then saved as …-small.jpg next to the original. A single tool for every size — instead of one tool per size.

A few things worth knowing:

So far, tools have done something with files (opened them or counted their lines). It gets really handy when a tool transforms files — and the result lands straight in the right place. That is exactly what the Input and Output settings are for.

The idea is simple. Many programs read something in, change it and write it out again. FileWorks feeds your files in at the front and catches the result at the back:

Input decides how the file reaches the program:

Output decides what happens to the result:

Two examples make it concrete:

Make JSON readable. JSON files are often a single long line. The program jq formats them nicely. As a tool:

Mark a .json file and run the tool to format it in place.

Make a sorted copy. The same with sort, but Output → Write to a new file with {stem}.sorted.{ext}. You get a sorted copy next to the original, and the original stays untouched.

When a task outgrows a one-liner, write it as a small script — in zsh, Python, or whatever you are comfortable with — and add it as a tool of the Run program / script kind. Two things are essential for a new script to run. Missing either one is a common reason why nothing seems to happen at first:

A few more things that make scripts predictable:

This tool creates a timestamped backup copy of every marked file in a Backups subfolder — handy before you try something risky. Save the text as ~/bin/fw-backup.sh:

And here is how you set it up:

Each run drops the copies into Backups/ and briefly shows a notification with the count. The notification is the visible result here, since the script itself prints nothing.

The same idea in Python: write a manifest.csv into the folder, listing the marked files with their names, sizes and modification dates. Save the text as ~/bin/fw-manifest.py:

Set it up as above (chmod +x ~/bin/fw-manifest.py, Program = the script, Arguments = {paths}, once with all). When it runs, manifest.csv appears in the list — the file is the result. The shebang #!/usr/bin/env python3 finds Python 3 (on macOS via Apple’s "Command Line Tools", which the system offers to install on the first run).

Three complete tools to copy. Every setting not mentioned stays at its default.

Mark any number of .json files and run the tool with one click to format each file in place. The file-type filter keeps the button greyed out unless JSON is selected. "Once per item" gives you a progress bar. And a broken file is simply skipped with an error, while the others go through cleanly.

Mark thirty photos, run it, type the size once — and you get thirty -small copies next to the originals. Need a different size? Run it again and enter another value; no settings need to change.

Mark files, click, paste anywhere — one path per line. No script, no extra program.

A tool meant only for images should not look clickable while you have a text file marked. The Available setting decides when a tool is active:

Always — usable no matter what is marked. Right for tools that work on a folder ({dir}, {target}) or need no file at all — "git status here", "show disk usage".

When something is selected — greyed out until at least one file is marked or selected. Right for anything that mentions {path}, {paths} …

For certain file types — active only when every marked file carries one of the extensions you list. Right for format-specific tools — an image shrinker, a JSON formatter.

The extension list accepts several formats, such as jpg, png, heic, .JPG;PNG and jpg png. Commas, semicolons or spaces separate extensions; the dot is optional, and case does not matter.

If a button is greyed out, hovering tells you why — "Shrink images — only for: jpg, png" or "select at least one file".

The context menu applies the same filter, only more strictly: what does not fit is not shown at all. Right-click a PDF and, under Tools, you see only the tools that can do something with a PDF. If none fit, the Tools entry is missing entirely.

In the action toolbar the buttons stay put and merely grey out. That way they don’t jump around with every new selection. In the empty area of a panel (right-click beside the files) you get the tools set to Available: Always — the ones that need no selection anyway.

Two things override every filter:

Every tool appears at the bottom of the window, in the same queue as the copy and move jobs — including one with "Output → Discard" that runs in the background:

If something went wrong, a Details … button appears on the card. It shows the full output: the program’s message, the error code and — with "once per item" — which file caused the error. The short version is already on the card itself. The bottom of the window shows how the run ended: "Finished" in green, "Cancelled" without a warning colour, a failure in red — with the exit code if exactly one run failed, otherwise as "Done, N errors".

Tools of the "Run program / script" and "Run shell command" kinds carry an icon on their button. Click the icon field — a gallery opens, sorted by theme (files, media, network, security …). One click is enough. (A "launch app" tool simply shows the app’s icon.)

Below it, a field accepts any SF Symbol name, including the thousands of symbols not shown in the gallery.

If you have already built your workflows in the macOS Shortcuts app, there is no need to rebuild them for FileWorks. A tool of the kind Run shortcut starts an existing shortcut and passes the marked files to it as input.

Setting it up takes seconds:

The circular-arrow button next to the list re-reads it — handy when you have just created a new shortcut while FileWorks was already running. If the list cannot be loaded — say, because the Shortcuts app does not respond — the reason appears in red below it; FileWorks waits at most ten seconds.

Under Run you decide, as always, whether the shortcut gets all marked files at once or starts once per file. Which is right depends on the shortcut: one that combines several images into a single PDF wants them together; one that shrinks an image works better individually.

Under Output you have two choices:

The file-writing outputs of the other tool kinds ("write to a new file", "replace the source file") are deliberately absent here. A shortcut does not return its result this way — all you would get is an empty file.

As the number of tools grows, you can organise them into groups such as "Image editing", "Development" or "Text editors".

To create a group, simply assign a tool to it: select a tool, type a name into the Group field and press ⏎. The group now exists, with the tool in it. For a second tool you don’t type the name again — the small arrow next to the field offers every group you have already used.

Tools without a group are perfectly fine. They gather under Ungrouped at the very bottom, and if you never assign a group, the list looks just as it always did.

In the list you can then:

This order is not just decoration: it also determines the order of the tools in the action toolbar and in the menus. So whatever you need daily belongs at the top.

In the menu bar and the context menu, each group becomes a submenu. Ungrouped tools appear below those submenus. The context menu also omits any group that contains no tool suitable for the file you clicked, so it never presents an empty submenu.

The panel action toolbar shows the groups in two places: in the Tools button’s menu each group becomes a submenu, and in the quick access below it a divider separates one group from the next. Which tools end up in the quick access is your choice per tool, via In the panel’s quick access; the button’s menu holds all of them anyway.

For reference — what you can set per tool:

File names come from the file system, not from you — and a file may perfectly legally be called $(rm -rf ~).txt. If FileWorks simply pasted such a name as text into your shell command, merely clicking a tool could cause havoc.

That is why FileWorks never pastes a value into your command as text. Each placeholder is replaced by a reference to a shell parameter ("$1", "$2", …), and the actual values are handed to the shell separately, as arguments. The shell fills them in but never looks at the result again for $(…), backticks and the like — so a value stays a value. Your command itself — pipes, &&, loops, redirections — stays untouched. These lines all do exactly what they look like, safely:

You therefore do not need to quote placeholders to protect spaces or special characters: FileWorks passes every item as a separate value.

FileWorks makes the shell safer. But drop a value straight into the source of another language — a Python snippet in a here-document, say — and a name containing a quote can throw that language off. FileWorks cannot sanitise Python code you assemble yourself.

The fix is the same idea one level down. Let the other language receive the value through its own arguments or standard input, instead of writing it into its code:

Internally, each placeholder becomes a positional shell parameter such as "$1" or "$2", in the order in which it appears. The other language receives the expanded value as an argument, not as source code.

Even more convenient: the common single values are available as environment variables you can read from any language — without them ever being able to turn into code:

For example, use os.environ["FW_PATH"] in Python or "$FW_DIR" in the shell to read a value. In the tool editor, the variables are listed below the placeholders in the glossary. For shell commands, a click inserts them with quotes ("$FW_PATH"); for programs and scripts they are for reference only, because your script reads them itself. (Lists like "all paths" are deliberately available only as {paths}, not as a variable: a file name may itself contain a newline, so newlines cannot reliably separate file names.)

An absolute guarantee would need either no free shell mode at all, or strong isolation of tools. FileWorks deliberately offers the free shell, and hands values to it safely. What the tool then does with them is up to the tool’s author.

A command that deliberately re-interprets its arguments turns the value back into code — and lifts the protection. This concerns constructs like:

Such patterns are the tool author’s responsibility. As long as you use placeholders simply as values ({path}, "$1", "$FW_PATH") and do not explicitly run them as code, they remain data rather than commands.

The largest section, divided into:

Rules that tint files by their extension. Each rule has a name, a colour, a list of extensions and a switch. Drag to reorder — the first matching rule wins. FileWorks comes with sensible defaults (Images, Videos, Audio, Archives, Documents, Code).

The saved file masks: name, group, pattern and the folder button. For details on what they do and where to use them, see Saved Patterns.

The folders in the Favorites section of the sidebar. Use the + button to add folders; you can also reorder or remove entries here. Missing folders are shown dimmed.

The apps for Edit (F3) — see Editing and Opening Files. With the + button you add an app and type the extensions it handles (comma-separated). An empty list means: the app matches every file.

The templates folder for New File and the list of templates — see New Files from Templates. At the top sits the folder with Show in Panel and Choose …. Below it you drag the templates into the order you want, enter descriptions and mark, in the Default column, the template for ⇧ + F7 and ⌥ + ⌘ + N. There is no adding or removing here: the folder decides which templates exist.

The editor for your own tools — see Custom Tools. On the left sits the list of your tools, arranged by group; drag to reorder and regroup, use + and − to add and remove. On the right sits the editor for the selected one.

Which fields it shows depends on the Type. A "launch app with selection" tool needs only a handful of entries. A script tool adds arguments, input and output, and the placeholder overview.

The remembered network servers from the sidebar. Passwords are never stored here — that is the macOS keychain’s job. For supported protocols and the differences when using network drives, see Which Protocols You Can Use.

Three buttons sit at the bottom of the sidebar.

Export … writes all settings to a JSON file: colour rules, patterns, favourites, editors, templates, tools, network servers, columns, key assignments and search defaults. Not included are the open tabs and the window layout — that is the session, not the configuration. For the templates, the folder path, the order and the descriptions go along, but not the template files themselves.

Import … reads such a file back in. It is the quick way to set up a second Mac.

FileWorks runs the moment you start it — there is nothing to set up. Your data stays where it belongs: with you.

Apple has notarised FileWorks after automatically checking it for known malware.

We take care with FileWorks. Even so, there are a few points you need to know:

No warranty. You get the software as it is. We promise no particular qualities, neither expressly nor by implication. That includes whether FileWorks suits any particular purpose.

Liability. Authors, copyright holders and developers are not liable for damage arising from the use of FileWorks, on whatever legal grounds.

What is up to you.

What we cannot promise.

By using FileWorks, you accept these terms. If you do not, please do not use the software.