FileWorks — User Manual

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

A small detail that saves a lot of time: when you go up a level, the folder you came from is selected again straight away. So you can just keep hopping with the arrow keys.

The path bar shows the current location as a row of clickable folders. A click on one jumps straight there. 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 — a quick jump into another folder alongside, without the detour up and back down.

With ⌘ + ⇧ + G you type a path directly. The field understands absolute paths, ~ for your Home folder, and paths relative to the current folder. As you type, it suggests matching subfolders: ↑ / ↓ selects, ⇥ completes, ↩ opens, esc cancels.

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 favorites, with every attached drive below them; wherever you currently are carries a tick.

The real gain is the keyboard: just start typing. With every character the list narrows to the matching entries, and the first hit is selected right away. In practice that means:

The matching is forgiving: it ignores capitalisation and accents alike. So grosse finds a folder called Größe, and doc is enough for Documents.

For drives, a slim bar shows how full they are, with the free space beside it. When it gets tight the bar turns orange, and red on an almost full drive — so you can see whether anything still fits there before you even jump.

The same overview — plus eject buttons — is in the Volumes section of the sidebar. Which folders appear as favorites you decide there as well (a folder’s context menu: Add to Favorites).

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 you can sort via the column headers. The icon grid can do everything you expect: drag a selection rectangle from an empty area, ⌘-click and ⇧-click, ⌥-click to mark, type to jump (type-ahead), and arrow-key navigation in all four directions.

A click on a column header sorts by it, another reverses the direction. The same fields are in the Sort menu: Name, Extension, Size, Modified and Kind. With Sort folders first enabled (the default), folders always come before files, whatever the sort field.

Which columns you see is set under Settings  General → Columns: Extension (as its own column — the name is then shown without the extension), 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 briefly into a cache. If that takes a moment (large archives), a progress bar with a Cancel button appears.

You turn the inspector on with ⌥ + ⌘ + I. It shows the details of the single selected item in the active panel:

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

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.

And that is exactly what makes them so useful: almost all file commands — Copy, Move, Duplicate, Delete, Edit, Pack, Multi-Rename, Create Link, Add to Drop Shelf and your own tools — act on the marks, when there are any, otherwise on the selection. So you calmly mark a batch and then work on it, without fear that a stray click undoes everything. The status bar shows it: "N of M marked".

Clicking selects; ⌘-click adds or removes single items; ⇧-click selects a range. In the icon grid you can also drag a rectangle from an empty spot (with ⌘ or ⇧ to add to the existing selection).

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. 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 first clears the marks, then the selection.

The star of keyboard marking is ⇧ + Space: it marks the item under the cursor and moves down one row. Pressed repeatedly, you mark a whole run in one flowing motion. (Plain Space stays Quick Look, as in Finder.) If you have just selected a range — say with ⇧ + ↓ — then ⇧ + Space folds that whole range into the marks and frees the cursor, so you can build the next block somewhere else.

These commands live in the Actions menu and all produce marks — so their result is safe from a stray click:

The mask field at the bottom left (focus it with ⌘ + F) marks files by a pattern, live as you type:

Because the mask marks rather than selects, the matched set stays put when you click into the list afterwards. By default only files are marked; to include matching folders, enable Settings  General → Select by Mask → Include folders. ↩ hands focus to the list, esc clears the field.

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: one after another, the rest waiting in order. It docks at the bottom of the right (or only) panel and shows, per job, a progress bar, the current item, the speed and the estimated time remaining — plus a Cancel button.

The dock appears on its own once a job takes a little longer, and disappears again after an error-free finish. Jobs that ended with errors stay put until you clear them (the Clean Up button or the × on the card). To show the queue by hand, use the Transfers button.

When a job meets a matching name at the destination, a conflict dialog appears. It puts both items side by side — size, date and a "Newer" hint — and lists your options below, each with a short explanation:

The first row is preselected: ⏎ keeps both. Hold ⌘ and every row shows its number; ⌘ + 1 to ⌘ + 5 pick one straight away. Which number belongs to which option depends on the case — Merge appears for folders only and shifts the following entries down by one.

The Apply to all further conflicts switch remembers your choice for the rest of the job — separately for file and folder conflicts.

To give many files new names at once, select them and open Multi-Rename … (⌘ + ⇧ + R). The dialog renames by a pattern — with a live preview of every result and a check that catches duplicate targets, clashes and invalid names, blocking the rename until everything is clean.

F8 (or the Trash button) removes the selection. Whether items go to the Trash or are deleted permanently — 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 can swap the two: hold ⌥ and the entry changes — if your default is the Trash it becomes Delete Permanently, otherwise the other way round. The swap happens live while the menu is open.

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

Aliases survive their target being moved or renamed, and work across drives. Symbolic links in the same folder are created relative, so they survive moving the whole folder.

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

In the context menu the first command is called Copy to Clipboard — spelled out, so it is clearly distinct from Copy to "…", which transfers the files straight to the other panel.

Drag items from a list into Finder or into the other panel. Dropping copies by default; with ⌥ held it moves. Drag 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.

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) — to collect them across several folders, then drag them all together into a destination (Finder or a panel).

If the sidebar is hidden when you add something, it opens briefly so you see the result. Via the list button in the shelf header you reach per-item actions and the option Keep items after dragging out — handy when the same collection should go to several destinations in turn.

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 selection:

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

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 as small chips to click away. Add Tag attaches a system or existing tag, New Tag … creates a new one. Remove the last chip and the file’s tags are gone entirely. See The Inspector (File Info).

In the list view, small coloured dots sit next to the name of every tagged file — one dot per colour, slightly overlapping, like in Finder. Hover 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 just a convenient index, not the tag itself: Remove from Sidebar (context menu) only takes the entry out of the list — the files keep their tag, and the entry comes back as soon as FileWorks sees 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. From a hit, Go to Enclosing Folder jumps to the real location. Navigate away and the tag search ends.

Tags you change in FileWorks are there right away. Tags changed elsewhere — in Finder or another app — FileWorks picks up automatically the next time you enter the folder (once away and back is enough). To re-read everywhere 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 that are not in iCloud at all, show no icon — so the list stays quiet and only flags what is not yet local. Hover the icon for a short explanation.

Right-click one or more items for the matching action:

Both actions work on a whole selection and skip whatever 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 first to copy or move it: when a job needs a cloud-only file, FileWorks downloads its contents automatically as part of the job — so the copy is complete, never a hollow placeholder. This works with any provider (iCloud, Dropbox, OneDrive, Google Drive), because it relies on the system’s own file-provider mechanism. 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, .iso (and more) to *go in, as if it were a folder; the path bar leads you through. A read-only note in the status bar reminds you that archives cannot be written to.

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

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

A progress bar shows the packing; Cancel removes the half-written archive again.

An archive can break quietly: a transfer is cut short, a disk ages, a copy arrives incomplete. You can’t see it from the outside. The file is there, the size looks plausible — and you would notice only when extracting it, possibly years later.

Mark an archive (or several) and choose Verify Archive … from the context menu or via Actions  Verify Archive …. FileWorks then reads every entry once, in full, and throws the data away — the only question is whether it can be read without errors. Nothing is written, but it 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. Entries that failed are named individually; Copy Report puts the list on the clipboard.

When you open or extract an encrypted archive, FileWorks asks for the password and retries if you mistype. Passwords are remembered per archive and only for the current session — they are never written to disk.

The algorithm sits at the top right. For everyday use SHA-256 is the one to pick — it is today’s standard and the value websites usually quote. MD5 and SHA-1 are faster but count as broken: an attacker can construct two different files with the same value. They still serve to verify old checksum lists, but nothing security-related.

The ⓘ beside the menu explains each algorithm in a sentence. Switch algorithms and FileWorks recomputes everything — values from different algorithms cannot be compared.

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: one file from each group is left untouched and all the others are selected. 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, simply paste the value into the field at the top.

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 rest and only the matches are marked green — two colour codings at once would be impossible to tell apart. Clear the field and the groups are back.

This is the answer to "is my backup complete and intact?". Select the files or folders you want to check and choose Compare … in the dialog. FileWorks offers the opposite panel as the destination — that is what two panels are for — or you pick any folder.

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.

Select folders and the comparison reaches across all subfolders. Matching then goes by the path within your selection, not merely by file name. If 2024/Q3/report.pdf sits in the destination as archive/report.pdf, it rightly counts as not present — it is somewhere else, after all.

The dialog does not merely display, you can act straight away. 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 spellings are understood — 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 algorithm on offer the same holds: two files that differ by chance yet share a value are so unlikely 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 are read at once depends on the drive: on a network share one after another, because they all share the same line; on the internal SSD 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 resolves them into their individual files. For the question of whether a package arrived intact, every file inside it is what counts anyway.

Very large selections are deliberately reined in: from around 20,000 files the dialog asks whether you really mean that many, and beyond 40,000 it declines. For holdings of that size a purpose-built tool is the better choice.

When several programs match, FileWorks lays them out for you to pick from. Set apart at the very top sits the file type’s default app — even if you never registered it as an editor. In practice it is what people mean most often.

The dialog works entirely without the mouse:

Programs that are no longer on the machine are not listed at all. 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.

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 one-liners on the command line. A tool of this kind runs a single line through the shell (zsh), with everything that belongs to it: 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 is enough. The others we explain step by step — with examples to build yourself.

A tool works with the files you have just marked (the coloured pills). If you have marked nothing, it takes the current selection — that is, the row under the cursor. This set we simply call the tool’s working set in this chapter.

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".

An example. The program wc counts lines. If you enter as a 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 is inserted where you last typed. Hovering shows you what it will insert.

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.

An example: shrinking images to a width you choose. As arguments you enter (using Apple’s sips program):

Run the tool and FileWorks asks: "Longest edge in pixels". You type, say, 1200, and the image is shrunk to 1200 pixels and 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:

Up to here tools have done something (opened files, counted). 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 behind it is simple: many programs read something in, change it and write it out again. FileWorks can feed your files in at the front and receive 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 click, and it is nicely formatted 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, you 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 matter so that a fresh script runs at all. They are the most common reason nothing seems to happen at first:

A few more things that make scripts predictable:

This tool makes a timestamped backup copy of every marked file into 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, because the script itself prints nothing.)

The same idea in Python: write a manifest.csv into the folder, listing the marked files with name, size and modification date. Save 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 you are offered to install the first time).

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

Mark any number of .json files, one click, and each is rewritten formatted. The file-type filter makes sure the button only lights up for JSON; "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. A different size? Just run it again with another answer, nothing 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 is forgiving: jpg, png, heic, .JPG;PNG and jpg png all mean the same (comma, semicolon or space separate, the dot is optional, 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 — and if none fit, the Tools entry is missing entirely. In the action toolbar, by contrast, the buttons stay where they are and are merely greyed out, so 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 that waits for its program (that is, anything except "Output → Discard") appears at the bottom of the window, in the same dock as the copy and move jobs:

If something went wrong, the card grows a Details … button. It shows the full output: the program’s message, the error code and — with "once per item" — which file it choked on. The short version is already on the card itself.

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, for the thousands not 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.

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.

Over the years they add up. Ten tools are still manageable, thirty are not. So you can sort them into groups — "Image editing", "Development", "Text editors", whatever suits you.

A group comes into being simply by you assigning 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 top, 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, with the ungrouped tools above them. In the context menu the availability check comes on top: if not a single tool in a group suits the file you clicked, the group isn’t shown at all — so you are never presented with an empty submenu.

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 $(…), back-ticks 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:

That is exactly why you never quote placeholders yourself: FileWorks does it for you.

FileWorks makes the shell safer. But if you drop a value straight into the source of another language — say a Python snippet in a here-document — then a name with a quote in it could 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:

Every placeholder is available as "$1", "$2", … in the order it appears.

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:

So os.environ["FW_PATH"] in Python or "$FW_DIR" in the shell both work. (Lists like "all paths" exist deliberately only as {paths}, not as a variable: a file name may contain a newline, which no single variable could separate safely.)

An absolute guarantee would only be possible without a free shell mode, or with 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, you are on the safe side.

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 folders in the Favorites section of the sidebar. With the + button you add folders, here you reorder or remove them. 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 editor for your own tools — see Custom Tools. On the left the list of your tools, arranged by group (drag to reorder and regroup, + and − to add and remove); on the right the editor for the selected one. Which fields the editor shows depends on the Type: a "launch app with selection" tool needs only a handful of entries, while a script tool additionally gets 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.

We developed FileWorks as a commercial application designed to provide a seamless, ready-to-use experience right out of the box. Our focus lies on both functionality and data protection.

FileWorks is built with your privacy as a top priority. Your personal data and information remain under your control at all times:

While we strive to provide a secure and reliable application, please note:

By using FileWorks, you acknowledge and agree to these terms and limitations. If you do not agree with these terms, please do not use the software.