Migration Assistant handles more than the app bundle. Apple says it can transfer apps, user accounts, documents, files, privacy and security settings, and system and network settings. It can transfer directly from the old Mac or from a Time Machine backup.

Back up the old Mac before starting, and do not erase it until the new copy has been checked.

Prepare the old and new Macs

I do this before opening Migration Assistant:

1. Install available macOS updates on both Macs.
2. Update important apps, unless the developer requires a particular version for migration.
3. Finish app imports, database repairs, and sync activity.
4. Use the app’s export or backup command when it has one.
5. Run a Time Machine backup and wait for it to complete.
6. Record where irreplaceable documents are stored and whether they are local, in iCloud, or in another service.
7. Keep licence keys, purchase records, and vendor sign-in details available without placing passwords in an unencrypted note.

For a manual inventory, I check where the app stores its data and settings. I use the separate backup and restore checklist before changing any app-managed files.

Use Migration Assistant for the main transfer

On a current version of macOS:

1. Open System Settings → General → Transfer or Reset.
2. Click Open Migration Assistant.
3. On the new Mac, choose to transfer from a Mac, Time Machine backup, or startup disk.
4. Follow the matching instructions on the old Mac or connect the backup.
5. Select the user account and the applications, files, and settings that need to move.
6. Let the transfer finish and read the migration summary for anything that could not be transferred.

Apple’s Transfer your information to Mac from another computer or device guide lists the current choices and preparation steps.

Apple also warns that incompatible apps, or apps with newer versions already installed, may not transfer or may not be usable. I treat Migration Assistant as the broad transfer, not proof that every app is ready.

Reinstall apps from the right source when needed

If an app did not transfer or does not open, I download a compatible version from the Mac App Store, the developer, or the service where I originally obtained it.

The App Store and direct-download editions of an app can use different bundle identifiers, containers, licences, or features. Even when their names and icons match, I do not copy one edition’s container over the other unless the developer documents that migration.

Mac App Store apps use App Sandbox. Direct-download apps may be sandboxed or may use traditional locations such as ~/Library/Application Support and ~/Library/Preferences. Related extensions can also store shared data in ~/Library/Group Containers.

Let cloud data and local data finish separately

After signing in to the same Apple Account, I check System Settings → my name → iCloud. Apple says apps enabled there can store and sync their information through iCloud.

I give the app time to finish downloading or indexing before deciding that data is missing. iCloud Drive may keep an item in iCloud without a full local download when Optimize Mac Storage is enabled. Finder’s Download Now command downloads a selected cloud-only item.

App-specific accounts need the same care. A database may sync from the vendor after sign-in, while plug-ins, local presets, downloads, or unsynced records still need the old Mac or backup.

I do not mix a manual restore into an active sync until the app developer’s instructions explain which copy wins. A stale local database can overwrite newer cloud data, or the service can replace the local restore.

Check passwords and licences

Apple says Setup Assistant transfers keychains automatically during migration. Local Items and iCloud Keychain passwords are not files to copy manually; they become available on the new Mac by signing in to the same Apple Account and enabling Passwords and Keychain sync.

Apple documents the distinction in Copy keychains to another Mac.

An app licence is a separate question. Migration Assistant does not promise that every vendor activation, Mac App Store receipt, subscription session, or machine-bound licence will remain valid. I open the app’s purchase or licence documentation and sign in, restore purchases, deactivate the old Mac, or activate the new one as required.

I never copy authentication tokens or random Keychain databases into an app container to avoid signing in.

Use a manual restore only for a known gap

If Migration Assistant and the app’s own sync or import leave known data behind, I restore that specific data from the backup.

I make a backup of the new Mac’s current app data first, quit the app and its helpers, and restore only known app-owned folders to their documented locations. I do not replace the whole ~/Library, another app’s group container, or every file containing the developer’s name.

On macOS 15 and later, app data and group containers can have additional System Integrity Protection. A permission prompt or an app that rejects a copied container can be expected protection, not evidence that repeatedly changing ownership or permissions is safe.

If the old and new app versions use different database formats or sandbox entitlements, I stop and use the developer’s supported import or migration path.

Verify the transfer before erasing the old Mac

I open every app that holds data I cannot recreate and check:

• old and recent documents or records
• attachments, media, and linked folders
• search, tags, templates, presets, and plug-ins
• preferences that change storage locations or exports
• cloud and app-account sync status
• passwords, certificates, and connected services
• licence, subscription, and purchase status

I also restart the new Mac and open the important apps again. That catches helpers, mounted folders, permissions, and credentials that worked only during the first session.

Once the new Mac has passed those checks, I run its own full backup. I keep the old Mac or its independent backup until I have used the migrated apps long enough to know that no local-only history or attachment is missing.

I use the app’s own export first, Time Machine for the broad backup, and a manual copy only when I know which files the app owns.

Make a backup before changing or restoring anything. Keep the original backup unchanged until the app opens and the important data has been checked.

Record what has to come back

Before making a manual backup, I write down:

• the app name and version
• whether it came from the Mac App Store, the developer, or another service
• the folders containing documents I created
• the app-owned support, preference, container, and app-group folders
• whether the app syncs through iCloud or its own account
• how the app’s licence or subscription is restored

The companion guide to where Mac apps store their data and settings explains the common Library locations. I do not include a folder merely because its name resembles the app. Developer names, bundle identifiers, shared frameworks, and app groups can overlap.

Prefer an app-provided export

If the app offers Export, Back Up, or Archive, I use it and read the vendor’s restore instructions at the same time. An export can preserve relationships between records that are spread across several internal files.

I inspect what the export includes. Some apps export content but omit preferences, attachments, plug-ins, accounts, or history. I keep the original documents and the broader Mac backup as well.

Use Time Machine for the broad backup

Apple says Time Machine backs up files including apps, photos, email, and documents, and can restore files to the same or a different Mac. I connect the backup disk, choose Back Up Now from the Time Machine menu, and wait until the menu reports that the backup is done.

I also open System Settings → General → Time Machine → Options and check the exclusion list. Apple notes that excluded items are not copied to the backup disk, and in rare cases third-party software can mark its files so Time Machine does not back them up.

The current steps are in Apple’s Back up your Mac with Time Machine and If Time Machine doesn’t back up certain files guides.

A Time Machine backup is my safety net. I still use an app export when the app provides one because the export is easier to inspect and may be more portable across app versions.

Make a manual copy only after identifying the files

For an app without an export, I use Finder to copy the known files and folders to a dated backup folder on separate storage.

1. Save work, finish any in-progress import or sync, and quit the app.
2. Quit its menu bar item and helper if the app provides a documented way to do so.
3. Copy the documents I created.
4. Copy the app-owned support, preferences, container, and app-group folders that its documentation identifies.
5. Keep the folder structure in the backup notes so I know each original location.
6. Record the app version, download source, and restore instructions beside the files.

I copy rather than move. I do not remove the originals to prove that the backup works.

Sandbox and app-group containers may be protected. A copy can require authorization, and another app or a different build of the same app may not be entitled to use the restored container. The appearance of a complete copy does not prove that macOS or the app will accept it later.

I usually leave caches and saved window state out of a focused manual backup. I include them only when the app’s documentation says they contain something that cannot be recreated.

Treat synced data as a separate copy

Apple says data for an app enabled in iCloud is stored in iCloud and kept in sync across devices. Sync can bring data to a replacement installation, but sync also propagates changes and deletions.

I check System Settings → my name → iCloud to see which apps use iCloud. For ordinary files in iCloud Drive, I use Download Now in Finder when an item is stored only in iCloud and I need a local copy. Apple documents this in Work with folders and files in iCloud Drive.

I do not overwrite local or cloud-backed data until I understand which copy the app treats as current. When the vendor specifies a sign-in or restore order, I follow it.

Restore without replacing good data

For a small restore, I start with the app’s supported import command. For an item in Time Machine, Apple says to open the Finder window for the item’s original location, open Time Machine, select the item or version, and click Restore. The item returns to its original location.

Before restoring app-managed files:

1. Confirm that the backup predates the loss or bad change.
2. Make another copy of the current files, even if they look broken.
3. Install a compatible app version from the original source.
4. Quit the app and its documented helpers.
5. Restore only the files or folders whose ownership and original locations are known.
6. Open the app and inspect the data before reconnecting a sync service or making more changes, when the vendor’s instructions allow that order.

Apple’s current item-restore steps are in Restore items backed up with Time Machine on Mac.

If the app reports an incompatible database, missing account, damaged library, or permission error, I stop. I keep the current data and backup instead of repeatedly replacing files. The app developer is in the best position to explain its database versions, repair tools, and container entitlements.

Check more than the launch screen

After restoring, I check:

• several old and recent records or documents
• attachments and linked files
• search, tags, presets, and plug-ins that matter
• preferences that affect where data is written
• account sign-in and sync status
• licence or subscription status

Passwords and licences can be stored in Keychain or validated by a server. They may need a separate sign-in or activation even when local data restores correctly.

I keep the dated backup until the restored app has been used normally and another full backup has completed. For a replacement computer, I use Migration Assistant first, then verify the app’s settings and local data on the new Mac.

I check the app’s own backup or migration documentation first. When the app does not document its storage, these are the places I inspect before changing anything.

Quit the app and make a backup before moving, replacing, or deleting its files. Quit any menu bar item or helper belonging to the app too. A file that looks disposable may be the only copy of a database, licence record, or unsynced work.

Start with files you chose

Documents that I create and save are not necessarily inside the app’s private data folder. They may be in:

• Documents, Desktop, Downloads, or another folder I selected
• iCloud Drive or another sync service
• a folder managed by the app
• removable or network storage

The app’s File → Open Recent menu and its settings can help identify these locations. I also check whether the app has an Export, Backup, Open Data Folder, or Reveal in Finder command. An app-provided export is usually a better backup than guessing which internal files belong together.

Files in iCloud need separate attention. Apple says an app can store and sync its information through iCloud when that app is enabled under System Settings → your name → iCloud. A synced copy is not the same as a versioned backup: a deletion or bad edit may sync too.

Open your hidden Library folder

Most local support files are under the Library folder in my home folder:

~/Library

The tilde means the current user’s home folder. Apple hides this Library folder in Finder.

To open it, switch to Finder, hold Option, and choose Go → Library. I can also choose Go → Go to Folder, enter ~/Library, and press Return. Apple documents both methods in Go directly to a specific folder on Mac.

There are also /Library and /System/Library folders. Those have different jobs. I do not move or delete files there while looking for one user’s app settings.

Check the standard Library locations

An app can use more than one of these folders, and the folder name may be the app name, developer name, or bundle identifier such as com.example.AppName.

Application Support

~/Library/Application Support/

This is the first place I check for durable local data managed by a non-sandboxed app: databases, indexes, templates, plug-ins, downloaded components, and other files the app needs to operate.

Apple’s file-system guidance assigns app-created support and configuration files to Application Support. The contents are app-specific, so I do not assume a folder is safe to remove just because its name is unfamiliar.

Preferences

~/Library/Preferences/

Preferences commonly appear as property-list files with a .plist extension. The filename often uses the app’s bundle identifier.

A preferences file may contain window choices and settings, but it is rarely the app’s complete data. macOS also manages preferences while apps run, so I quit the app before copying a known preference file. I do not edit a plist merely to see what happens.

Containers

~/Library/Containers/

Sandboxed apps use app containers. Apple says macOS creates a container in ~/Library/Containers when a sandboxed app first launches. Inside it, the app gets container-specific versions of familiar locations such as Library, Application Support, Preferences, and Caches.

App Sandbox is required for apps submitted to the Mac App Store. A directly downloaded app can also use App Sandbox, while another direct-download app may use the traditional Library locations. That is why the download source alone does not tell me exactly where an app stores everything.

Apple explains the container model in Accessing files from the macOS App Sandbox and Protecting user data with App Sandbox.

Group Containers

~/Library/Group Containers/

An app group lets related apps, extensions, and helper processes share data. A main app can therefore use both its own container and one or more group containers.

On macOS 15 and later, Apple also protects app group containers with System Integrity Protection. Finder may ask for authorization when another app tries to access a protected container. I treat that prompt as a protection boundary, not as a reason to grant broad access without checking the folder owner. Apple describes the current protection in Protecting local app data using containers on macOS.

Caches and saved state

~/Library/Caches/
~/Library/Saved Application State/

Caches should hold data the app can recreate or download. Saved Application State helps macOS restore windows and interface state.

Neither location is where I start when backing up important app data. A badly behaved app can put more in a cache than it should, but the folder name is not proof that its contents are disposable.

Passwords and licences may be elsewhere

Apps can store passwords, tokens, certificates, and other secrets in Keychain rather than in their visible support folder. A licence may be tied to Keychain, an account, a receipt, the Mac App Store, the specific Mac, or a vendor’s server.

I do not copy random Keychain files or credential databases as part of an app-data experiment. For a new Mac, Setup Assistant or Migration Assistant and iCloud Keychain are safer starting points. The app may still require me to sign in or activate the licence again.

One app can have several storage locations

This is the practical checklist I use:

• Find documents and folders I selected in the app.
• Check the app’s export, backup, sync, and migration documentation.
• Check ~/Library/Application Support and ~/Library/Preferences.
• Check ~/Library/Containers and ~/Library/Group Containers.
• Record the app version and whether it came from the App Store or the developer.
• Keep caches, credentials, licences, and cloud data as separate questions.

Apple’s File System Programming Guide explains why apps use different standard locations and why sandboxed paths behave differently.

Finding the folders is only the inventory step. I use that inventory to back up and restore the app’s settings and local data without pretending that one copied folder is a complete backup.

If a Zoom meeting is already over, I do not need another bot joining the next meeting. I need the recording file that Zoom already made, a local transcript, and a way to find the meeting again later.

My workflow is to locate or download the completed Zoom recording, put its files in one folder, then open that folder in MinuteFile for Mac. MinuteFile transcribes the recording on the Mac and keeps the recording and editable transcript together.

Find a Zoom recording saved on your Mac

Zoom computer recordings are stored on the Mac that recorded the meeting. The default folder is:

/Users/your-name/Documents/Zoom

Zoom may be using a different folder. In the Zoom Workplace app, open Settings, choose Recording, then check Local recording storage. Click Open beside the storage location to reveal the folder in Finder.

Zoom also lists computer recordings in the app:

1. Open Home and click Open recordings.
2. In My files → Meeting recordings, choose Computer recordings.
3. Open the menu for the completed meeting and click View file location.

If Zoom shows Convert instead, let it finish converting the recording first. A completed computer recording commonly includes an MP4 video, an M4A audio file, and a chat text file, depending on the meeting and recording settings.

Zoom documents the current steps in Managing computer recordings.

Download a completed Zoom cloud recording

A cloud recording is not on the Mac until it is downloaded.

1. Sign in to the Zoom web portal.
2. Open Recordings & Transcripts, then Cloud recordings.
3. Open the processed recording.
4. Click Download and confirm.

The recording owner or an authorised user must have download access. If the recording is still processing, wait for Zoom to finish before downloading it. Zoom documents the permissions and steps in Managing and sharing cloud recordings.

I put the downloaded files for one meeting in their own folder. Keeping the MP4 or M4A beside any VTT, TXT, or chat files makes the archive easier to inspect later.

Bring the completed recording into MinuteFile

Open MinuteFile and choose either the individual meeting folder or a parent folder containing several completed recordings. For Zoom computer recordings, that parent folder can be ~/Documents/Zoom.

MinuteFile detects recording folders and their audio, video, caption, and chat files. Select the meeting, choose the transcription model and language offered by the app, then start transcription. The first use of a model may download it from its model host.

Once the required model is installed, MinuteFile runs transcription on the Mac. The recording and transcript are not uploaded to a MotionObj cloud transcription service.

MinuteFile starts after the recording exists. It does not capture the live Zoom meeting, join as a bot, or create a cloud summary.

If the recording does not appear

Two checks cover most missing Zoom recordings.

Check whether Zoom finished the recording

A computer recording may still need conversion after the meeting ends. Open Computer recordings in Zoom and click Convert if that action is shown. Import the recording after Zoom finishes conversion and opens the recording location.

For a cloud recording, check that Zoom has finished processing it and that the recording owner allows downloads. A shared playback link does not always include permission to download the files.

Keep each downloaded meeting in one folder

MinuteFile treats a folder as the meeting record. Keep the recording media and any matching caption, transcript, or chat files together. If a cloud download places several files loose in Downloads, move the files for that meeting into one folder before importing it.

When both audio and video are present, MinuteFile chooses a usable transcription source from the files it detects. There is no need to extract audio from the MP4 first. Keeping the original files also means I can open the source recording again while reviewing the transcript.

Use an existing Zoom transcript when you already have one

MinuteFile 0.1.6 can also turn an existing VTT, SRT, or TXT transcript into the editable archive transcript without transcribing the audio again.

Keep the transcript file in the meeting folder, select the recording in MinuteFile, then choose the existing transcript. MinuteFile keeps a copy of the source as a Supporting File and labels it as not generated by MinuteFile. Recognised VTT or SRT timestamps remain connected to local playback; plain TXT stays editable and searchable but cannot provide timestamp seeking that was not in the source.

Review the transcript and keep the meeting searchable

Transcription is not the last step. I play the local recording against the transcript, correct text and speaker labels, and add bookmarks to moments I need to revisit. Transcripts and speaker labels can contain errors, so I review anything I plan to publish or treat as a record.

MinuteFile keeps saved transcripts in a searchable archive on the Mac. I can search across meetings, jump from timestamps to local playback, and export TXT, Markdown, or HTML copies.

I keep the original Zoom folder and exported transcripts backed up separately. I also make sure I am allowed to keep and process the recording; the local workflow does not change recording consent or access rules.

The app still uses the network for optional model downloads, signed update checks and downloads, and Stripe checkout. MinuteFile’s privacy page describes those boundaries.

I test for that before using a regex on untrusted or large input.

The pattern I watch for

The classic problem is nested repetition:

^(a+)+$

The pattern looks small. It can get expensive on input that almost matches:

aaaaaaaaaaaaaaaaaaaaaaaaaaaaa!

The engine tries many ways to split the a characters across the nested groups before it gives up.

I do not need a benchmark for every regex. I do need to pause when I see repetition inside repetition, especially if the input can be long.

Make the regex more specific

The first fix is usually to make the pattern less vague.

Instead of:

^(.+)+$

I look for something closer to the input I expect:

^[A-Za-z0-9_-]+$

Instead of matching “anything”, match the characters that are valid.

Use anchors when the whole string should match

If the whole string must match, I anchor it:

^[A-Z]+-[0-9]+$

Without anchors, the engine can search around inside a string. That may be correct. It may also be unnecessary work.

Test with bad input

I test with:

• valid short input
• valid long input
• invalid input that fails quickly
• invalid input that almost matches
• empty input

The fourth case matters. Many slow regex problems show up when the input is almost valid.

Keep the target engine in mind

Regex performance depends on the engine. JavaScript, Swift, Ruby, nginx, grep, and sed do not all behave the same way.

I use Regex for macOS for the first pass. It is useful for building the expression and checking matches. If the pattern will run in a server, CLI tool, or app hot path, I also test it where it will run.

A small timing check

For a quick command-line check, I use the target language and a sample input.

Ruby example:

require "benchmark"

pattern = /\A[A-Za-z0-9_-]+\z/
input = "a" * 10_000

puts Benchmark.measure {
  1_000.times { pattern.match?(input) }
}

The script is a cheap way to catch obviously bad patterns. I still test the final code path if the regex matters.

My regex performance checklist

Before I use a regex on large or untrusted input, I check:

• no nested repetition unless I have a good reason
• specific character classes instead of .* everywhere
• anchors when I need a whole-string match
• clear maximum lengths where the app can enforce them
• bad input that almost matches
• the actual engine that will run the regex

If the pattern is hard to reason about, I simplify it or replace it with parsing code.

You can get Regex Tester/Builder on the Mac App Store.

Related: Regex tester for macOS and nginx regex tester.

I still test the regular expression separately first. Then I put it into sed.

Use extended regexes on macOS

On macOS, I usually use sed -E:

sed -E 's/old/new/g' file.txt

That enables extended regular expressions. It keeps patterns easier to read because I do not need to escape common grouping and alternation syntax as much.

Example input:

AUTH-1284 fixed
REGEX-42 needs review
BILLING-9001 shipped

Pattern:

([A-Z]+)-([0-9]+)

Replacement:

\1 ticket \2

sed command:

sed -E 's/([A-Z]+)-([0-9]+)/\1 ticket \2/g' tickets.txt

Result:

AUTH ticket 1284 fixed
REGEX ticket 42 needs review
BILLING ticket 9001 shipped

Test the match and the replacement separately

When I am working on a sed command, I split the problem:

• Test the regex against sample text.
• Check the capture groups.
• Then write the replacement string.

This avoids the usual “why did sed replace the wrong thing?” loop.

Regex for macOS helps with the first two steps. It shows the matches and capture groups while I edit the pattern.

One macOS sed detail to watch: I do not use \b there as a word-boundary shortcut. If I need strict boundaries in sed, I test that exact sed expression instead of assuming it behaves like Swift, JavaScript, or Ruby.

Watch out for shell quoting

The pattern that works in a regex tester may need quoting changes in Terminal.

I normally wrap the sed expression in single quotes:

sed -E 's/foo/bar/g' file.txt

If the replacement needs a literal single quote, I stop and make the command easier to read. Sometimes that means using a small Ruby, Python, or Perl script instead of turning the shell command into punctuation soup.

sed is not a parser

sed is great for line-oriented text changes:

• renaming simple tokens
• changing config values
• cleaning generated output
• quick one-off migrations

It is not what I use for structured formats when a parser is available. For JSON, HTML, XML, and non-trivial CSV, I use a proper parser.

My sed regex checklist

Before I run a destructive command, I check:

• Does the regex match only the lines I want?
• Are capture groups in the right order?
• Does the replacement preserve the parts I need?
• Have I tested on a copy or printed output first?
• Do I need -E?
• Is sed still the right tool?

You can get Regex Tester/Builder on the Mac App Store.

Related: Regex tester for macOS and Swift Regex Builder.

I test the pattern first, then put it into nginx.

nginx regex locations

nginx has a few location forms. The two regex forms I use are:

location ~ ^/articles/(.+)/$ {
    # case-sensitive regex match
}

location ~* \.(png|jpg|jpeg|gif|webp)$ {
    # case-insensitive regex match
}

The important bits:

• ~ is case-sensitive.
• ~* is case-insensitive.
• Captures are available as $1, $2, and so on.
• nginx chooses locations with its own matching rules. Prefix locations matter, and regex locations are tested in order when nginx gets to that step.

That last part is where testing the regex alone is not enough. I still test nginx config with nginx. But testing the expression first catches most of the obvious mistakes.

Test the path, not the full URL

For nginx location blocks, I usually test the path:

/articles/regex-macos-tutorial/
/articles/swift-regex-builder/
/regex/
/images/regex/device.png

Then I write a pattern:

^/articles/([^/]+)/$

This captures:

regex-macos-tutorial
swift-regex-builder

It does not match:

/regex/
/images/regex/device.png

That is the kind of quick check I want before touching a config file.

Test rewrite captures

For a routing rule, I test the capture groups before I write the nginx rule.

Pattern:

^/old/articles/(.+)/$

Replacement target:

/articles/$1/

nginx rule:

rewrite ^/old/articles/(.+)/$ /articles/$1/ permanent;

If the regex tester shows the capture includes a trailing slash I did not expect, I fix it before it becomes a rewrite bug.

Check nginx syntax too

After editing config, I still run:

nginx -t

or, inside Docker:

docker exec nginx nginx -t

The regex tester checks the expression. nginx -t checks whether nginx accepts the config. I want both.

Where Regex for macOS fits

Regex for macOS is useful for the first pass: sample paths on one side, pattern on the other, matches and capture groups visible while I edit.

Then I move the pattern into nginx config and test the config normally.

You can get Regex Tester/Builder on the Mac App Store.

Related: Regex tester for macOS and regex performance tester.

The workflow I use is boring: test the regex, make the capture groups obvious, then move it into Swift.

Swift also has a RegexBuilder DSL for building regular expressions in code. That is useful when I want the expression to read more like Swift. I still start with the plain regex when I am moving between tools, because it is easier to test the same pattern in a Mac app, a shell command, and a code snippet.

Start with the plain regex

Say I want to match a simple issue key:

AUTH-1284
REGEX-42
BILLING-9001

The plain regex is:

\b([A-Z]+)-(\d+)\b

Before I put this in Swift, I want to know two things:

• The full match is the whole issue key.
• Group 1 is the project key, and group 2 is the number.

That is what I test in Regex for macOS. The app lets me keep the sample text and the expression together while I work.

Move it into Swift

In Swift, a raw string keeps the regex readable:

let pattern = #"\b([A-Z]+)-(\d+)\b"#

If I am using NSRegularExpression, the code looks like this:

import Foundation

let text = "Fixed AUTH-1284 and REGEX-42."
let regex = try NSRegularExpression(pattern: #"\b([A-Z]+)-(\d+)\b"#)
let range = NSRange(text.startIndex..<text.endIndex, in: text)

let matches = regex.matches(in: text, range: range)
for match in matches {
    let fullRange = Range(match.range(at: 0), in: text)!
    print(text[fullRange])
}

In production code I would handle failed range conversions instead of force-unwrapping. This example keeps the snippet focused.

If I am building a larger parser in Swift, I would look at RegexBuilder too. For small patterns I expect to copy between Swift, Terminal, nginx notes, or documentation, the plain regex is still the most portable starting point.

That is the distinction I care about: RegexBuilder can make Swift code clearer, but it is not the only place to test the matching rule. I still want sample input, visible captures, and a quick way to catch mistakes before I decide how the final Swift code should look.

Check escaping separately

Escaping is where I make mistakes.

There are a few layers:

• regex escaping
• Swift string escaping
• replacement string escaping, if I am replacing text

Raw strings help:

let emailPattern = #"[\w.%+-]+@[\w.-]+\.[A-Za-z]{2,}"#

That is easier to read than doubling backslashes everywhere.

When I would not use a fancy regex

For simple string work, I do not force everything into a regular expression. If a prefix check, suffix check, split, or parser is clearer, I use that.

Regex is good when the input is text-like and the rule is compact. It gets worse when the input is structured data pretending to be text. HTML, JSON, and CSV usually deserve a parser.

My Swift regex checklist

Before I paste a pattern into Swift, I check:

• sample strings that should match
• sample strings that should not match
• capture group order
• Unicode assumptions
• whether I need multiline or case-insensitive options
• whether a parser would be clearer

If I need to iterate on the pattern, I do it in Regex for macOS first, then copy the result into Swift.

You can get Regex Tester/Builder on the Mac App Store.

My preference on the Mac is simple: test the pattern against real sample text, then copy it into the tool that needs it.

Why use a Mac regex tester

A regular expression is rarely just the pattern. It usually comes with a few details attached:

• sample input
• match options such as case-insensitive or multiline matching
• capture groups
• the replacement string, if I am doing a search-and-replace
• the engine or tool that will run it

That last one matters. A regex that works in JavaScript may need changes before it works in grep, sed, Swift, nginx, or Ruby.

Regex for macOS is useful when I want a focused place to edit the pattern and sample text side by side. I can see the matches, inspect capture groups, and copy the final pattern into code or Terminal.

A small example

Say I want to pull ticket IDs out of text like this:

Fixed AUTH-1284 and REGEX-42.
QA needs to check BILLING-9001.

I would start with:

\b[A-Z]+-\d+\b

That matches:

AUTH-1284
REGEX-42
BILLING-9001

Then I decide whether I need a capture group:

\b([A-Z]+)-(\d+)\b

Now I can inspect the project key and number separately:

• Group 1: AUTH, REGEX, BILLING
• Group 2: 1284, 42, 9001

That is the point of using a tester. I do not want to guess whether group 1 is what I think it is.

Write down the cases before tweaking the regex

The fastest way I know to waste time with regex is to keep changing the pattern without writing down what should match.

I usually make a tiny test set first:

AUTH-1284        yes
REGEX-42         yes
BILLING-9001     yes
AUTH-            no
abc-123          no, if project keys must be uppercase
AUTH-1284-extra  no, if the whole token should match

Then I adjust the expression until the matches line up with those cases.

This is more useful than staring at the regex and trying to reason it out in my head. It also catches the mistakes that do not look like mistakes at first: a missing anchor, a capture group in the wrong place, or a pattern that matches part of a longer token.

Taking it to Terminal

On macOS, I usually start with grep -E when I need extended regular expressions:

grep -E '\b[A-Z]+-[0-9]+\b' tickets.txt

For replacement work, I usually reach for sed -E:

sed -E 's/([A-Z]+)-([0-9]+)/\1 ticket \2/g' tickets.txt

The pattern is close to the one I tested. Shell quoting and the regex engine both matter, so I still check the command before using it on real files. For example, macOS sed does not treat \b as the same word-boundary token that many programming-language regex engines do.

What I check before using a regex

The short checklist:

• Does it match the examples I expect?
• Does it avoid examples I do not want?
• Are the capture groups in the right order?
• Does it still work when the input has multiple lines?
• Do I need a case-insensitive option instead of writing [A-Za-z] everywhere?
• Does the destination tool support the features I used?

Lookahead, lookbehind, and backreferences are useful, but they are also where portability starts to get worse. I use them when the target supports them and keep the pattern simpler when it does not.

When I use Regex for macOS

I use Regex for macOS when I want a native app instead of another browser tab. It does one job: edit and test regular expressions on the Mac.

I mostly want a focused place to work through the pattern, confirm the matches, and copy it into the next thing.

You can get Regex Tester/Builder on the Mac App Store.

Related: Swift Regex Builder, nginx regex tester, and sed regex tester.

This is the third article of a series of articles on reducing disk space usage on your Mac. Read the first post: Reducing Disk Usage on Your Mac by Processing Your Videos and second post: Reducing Disk Usage on Your Mac with OmniDiskSweeper if you haven’t.

In our second article, we talked about running OmniDiskSweeper and manually going through the directories and cleaning those that unnecessarily use up space. There is another utility that helps to reclaim disk space more easily – CleanMyMac.

Note that CleanMyMac is a paid app with a free download.

Running CleanMyMac

Once you launch the app, it’ll give you a couple of options to clean on the left bar. Make sure Automatic Cleanup is selected and click Start Over and then Scan to start.

It should take a few minutes to scan your hard disk/SSD. Once it’s done scanning, it should report how much space it can clean automatically. Careful now, DO NOT click the Clean button. Instead, look at the left bar and click on System Cleanup.

Click on Detail Results and it should show you a detailed breakdown of the items to will be cleaned.

As a good habit, we’ll want to only clean those items that we know will be safe without. I usually uncheck most items, including iOS Photo Cache (careful!) and check items such as iOS Software Updates that I know is safe to remove. Click Clean – it should prompt you for your password – and let it do its job.

Continue on with Large & Old Files as well as Trash Cleanup. Happy cleaning!

Want more articles like this in your inbox? Join our newsletter to receive free email updates, tips and tricks related to iOS & macOS X.