I built PhotoSorter for myself a few months ago because I needed a faster way to clean up folders full of random images.

By “photo library” I mean photos managed by Photos on macOS, Google Photos, or any other actual photo management app. PhotoSorter is for everything outside of that. Screenshots, saved memes, random images from Downloads, and all the other stuff that somehow piles up on disk.

It does one thing: you point it at a folder, create a few categories, and sort images one by one using keyboard shortcuts.

Each shortcut moves the current image into its matching category folder and advances to the next one. That’s it.

Why

Every few months I need to declutter my Desktop and Downloads folders from all kinds of random files, most of which are screenshots.

I’m a hoarder. I don’t delete stuff. I just put things away for later in case I ever need them.

Why shouldn’t I. Storage is effectively free. At least it felt that way back in 2023 when I was setting up my NAS.

Technically I could add all those images to my photo library and let Photos sort them for me, but I prefer to keep them separate.

First, I like to keep my photo library clean. Adding hundreds of random screenshots is the opposite of that.

Second, while doing the quarterly image sorting, I often find stuff where some action is required: schedule an appointment, follow up with someone, create a Jira ticket, whatever. Most of it is just screenshots of tweets tho.

Before PhotoSorter I did this manually by dragging and dropping images into different folders. At some point I tried using macOS tags in Finder, but those don’t support keyboard shortcuts either. Both solutions required way too much mouse movement.

I couldn’t find a good existing solution for this exact problem, so I built PhotoSorter.

There are probably a dozen people around the world who need this kind of tool, but I wanted to share it nonetheless. I’ve been using it for a while now and it has already saved me a lot of time.

Resources

• PhotoSorter on GitHub

I used this convert.py script:

#!/usr/bin/env python3
import subprocess
from pathlib import Path

def convert_pdf_to_markdown(pdf_file: str) -> None:
    pdf_path = Path(pdf_file).expanduser().resolve()
    if not pdf_path.exists():
        raise FileNotFoundError(f"PDF not found: {pdf_path}")

    root_dir = pdf_path.parent
    venv_dir = root_dir / ".venv"
    output_dir = root_dir / "output"
    python_bin = venv_dir / "bin" / "python"
    pip_bin = venv_dir / "bin" / "pip"
    marker_bin = venv_dir / "bin" / "marker_single"

    def run(cmd: list[str]) -> None:
        print("+", " ".join(str(c) for c in cmd))
        subprocess.run(cmd, check=True)

    if not python_bin.exists():
        run(["python3", "-m", "venv", str(venv_dir)])

    if not marker_bin.exists():
        run([str(pip_bin), "install", "marker-pdf"])

    output_dir.mkdir(parents=True, exist_ok=True)
    run(
        [
            str(marker_bin),
            str(pdf_path),
            "--output_format",
            "markdown",
            "--output_dir",
            str(output_dir),
        ]
    )


if __name__ == "__main__":
    convert_pdf_to_markdown("path/to/the/pdf/you/want/to/convert.pdf")

Then run:

cd path/to/the/folder/with/convert.py
chmod +x convert.py
./convert.py

Output goes to:

path/to/the/pdf/folder/output/<pdf-name>/<pdf-name>.md

First run will be slower because it creates .venv, installs marker-pdf, and downloads model files.

⚠️ Disclaimer: This guide is for educational purposes. Bypassing corporate security controls may violate your company’s IT policies. Use responsibly and at your own risk.

First, confirm the block and grab the real IP from an external resolver:

# What your system resolves (potentially filtered)
dig +short example.com

# What the real IP should be (Cloudflare DNS)
dig +short example.com @1.1.1.1

If the IPs differ, the domain is being filtered.

The Fix

Option 1: /etc/hosts (recommended)

Requires admin access. This bypasses DNS for all apps.

1. Get the real IP:

   dig +short store.steampowered.com @1.1.1.1
   

2. Add the mapping:

   sudo nano /etc/hosts
   

   Example entry:

   23.197.161.221 store.steampowered.com
   

3. Verify:

   ping -c 1 store.steampowered.com
   

Option 2: Proxyman DNS spoofing

Useful if you want a toggle and do not want to touch system files. Only works for traffic routed through Proxyman.

1. Open Proxyman and go to Tools → DNS Settings.
2. Add a custom mapping with the real IP.
3. Enable the mapping and ensure Proxyman is capturing traffic.
4. Test in your browser.

Why This Works

Cisco Umbrella intercepts DNS on port 53 (often via a local proxy like: /opt/cisco/secureclient/bin/dnscryptproxy --listenPort=53 --listenAddress=127.0.0.1).

Both methods avoid that lookup: /etc/hosts is checked before DNS, and Proxyman can rewrite DNS answers before they hit the network.

Troubleshooting

• Confirm Umbrella is running: ps aux | grep -i umbrella.

• Check your hosts entry: grep -n "steam" /etc/hosts.

• Test a direct IP mapping with curl:

  curl -I https://store.steampowered.com --resolve "store.steampowered.com:443:23.197.161.221"
  

• Flush DNS cache if needed:

  sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder
  

Resources

• Cisco Umbrella documentation
• Cloudflare 1.1.1.1 DNS
• Proxyman DNS Mapping

My first two suspects in these situations are always Xcode junk or a full Trash.

I opened OmniDiskSweeper and started scanning. I love it because there is no visual fluff. You scan, you delete, you move on. I cleaned up old runtimes, old Xcodes, and VM images. That saved ~70 GB.

The mystery was not solved though. macOS Settings still showed ~300 GB of “System Data.” OmniDiskSweeper did not show it.

Next up I tried CleanMyMac X. I usually prefer OmniDiskSweeper, but I was out of ideas. It found some big caches, but nothing close to 300 GB.

So I kept googling and landed on DaisyDisk. It was blazing fast. I also do not hate the UI, but I do not love it either. It is definitely original.

DaisyDisk solved the mystery tho: all that “System Data” was Time Machine local snapshots.

It clicked. A few weeks earlier I had re-set up my Time Machine backup to a remote drive. The backup started failing, I missed it, and the snapshots kept piling up.

I deleted the local snapshots and freed ~300 GB.

Remove local snapshots

I followed this thread:

How to delete all local TimeMachine snapshots

The commands I used:

tmutil listlocalsnapshots /
sudo tmutil deletelocalsnapshots <snapshot-id>

If you want to delete all of them, the thread includes a one-liner. I didn’t need anything local, so I wiped everything and got my disk space back.

A dependency mirror refers to an alternate source location which exactly replicates the contents of the original source. [1]

I often end up in the same situation: I need to tweak an internal package that a project depends on. The usual options are:

• Drag and drop the repo into Xcode (Xcode replaces the remote dependency with the local copy)
• Change Package.swift to a local path dependency

Both work, but I prefer a CLI-only workflow. Turns out SPM has a cleaner alternative: dependency mirroring!

Set a Mirror

Point the remote URL to a local repo:

swift package config set-mirror --original "THE_ORIGINAL_URL" --mirror "LOCAL_PATH"

# Example
# swift package config set-mirror --original "https://github.com/apple/swift-argument-parser" \
#   --mirror "/Users/user/Developer/swift-argument-parser"

To confirm:

swift package config get-mirror --original "https://github.com/apple/swift-argument-parser"

Important Notes

• A mirror only changes where SPM fetches the repo from. It still resolves a version, branch, or revision.
• If you want local edits to show up, you must commit them in the mirrored repo.
• Use a branch or revision in Package.swift:

dependencies: [
    .package(url: "https://github.com/apple/swift-argument-parser", branch: "main"),
]

• Mirrors are matched by the exact URL string. If your dependency uses the .git suffix, set a mirror for that URL too.

Remove the Mirror

Once you are done, remove it:

swift package config unset-mirror --original https://github.com/apple/swift-argument-parser

If you added a .git mirror, remove that one as well.

Closing Thoughts

Mirrors are not a drop-in replacement for local path dependencies. You still need to commit changes, but in return you get a clean, repeatable CLI workflow that works across projects without touching Xcode.

Resources

• [1] swift-evolution/proposals/0219-package-manager-dependency-mirroring.md at main - swiftlang/swift-evolution

Need your Alfred snippets on iPhone and iPad? Alfred Snippet Converter now supports zip archives, drag & drop, and batch conversion of multiple collections.

What’s New

Zip Archive Support - Convert collections directly after exporting from Alfred without manual extraction.

Drag & Drop - Simply drag your collection files onto the app window.

Batch Processing - Convert all your Alfred snippet collections in one operation.

The tool converts Alfred snippets into macOS text replacements, which sync across all your Apple devices via iCloud. Read the full setup guide in Alfred Snippets on iOS.

Resources

• Download Alfred Snippet Converter

This happens because macOS has “Press and Hold” enabled by default, which interferes with Vim’s key repeat functionality.

The Fix

Run this command in Terminal to disable Press and Hold specifically for Cursor:

defaults write com.todesktop.230313mzl4w4u92 ApplePressAndHoldEnabled -bool false

Restart Cursor for the changes to take effect.

Finding Your Bundle ID

If the command above doesn’t work (Cursor updates might change the bundle ID), you can find the correct identifier:

1. Right-click on Cursor in Applications
2. Select “Show Package Contents”
3. Open Contents/Info.plist
4. Look for the CFBundleIdentifier value

Replace the bundle ID in the command with your specific identifier.

Resources

• How do I press and hold a key and have it repeat in vscode? | Stack Overflow

Assumptions

• Since this was an internal package, I did not need to maintain CocoaPods support. The goal was to replace it entirely with SPM. It is certainly possible to keep both, but that would require some additional work.
• The project I was working on is considered legacy; no one has touched it in about six years. Once this task is complete, I hope no one will need to update it for another half-dozen years. This allowed me to take some shortcuts, like integrating a third-party dependency directly into the codebase instead of spending time updating it to the latest version.
• All internal dependencies of your framework already support SPM.

With that said, let’s get started.

How?

I’ll assume your framework has no internal dependencies that require the same SPM treatment. If it does, start with the bottom-most dependency and work your way up.

External Dependencies

The first step is to update all external dependencies to use SPM.

In my case, one of the dependencies was PromiseKit, which was stuck six major versions behind the latest release. Since the project was considered legacy and no further development was planned, I decided to cut some corners.

Instead of spending time updating PromiseKit from version 1 through 7, I opted to add SPM support to the version my project was currently using. This approach required significantly less work and proved to be the right choice.

Removing the Old Dependency Manager

With all dependencies migrated to SPM, you should now be able to remove the old dependency manager from your project.

Adding a Swift Package Manifest

Next, initialize a new Swift package in your project’s root directory:

swift package init

This will create a Package.swift file. Here is a basic configuration:

// swift-tools-version: 6.1
import PackageDescription

let package = Package(
    name: "MyPackage",
    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]),
    ],
    targets: [
        .target(
            name: "MyPackage"),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]
        ),
    ]
)

Move your project’s source files to Sources/MyPackage and try to build the project. You will likely encounter one of the following errors:

SomeHeaderFile.h:19:9 'AnotherHeaderFile.h' file not found

or

public headers ("include") directory path for 'MyPackage' is invalid or not contained in the target

These errors indicate that the compiler cannot locate your project’s header files. By default, SPM looks for public headers in an include directory.

Create an include directory inside Sources/MyPackage and move all of your project’s public headers there.

If this structure doesn’t suit your project, you can define a custom path for your public headers by specifying publicHeadersPath in your Package.swift:

    targets: [
        .target(
            name: "MyPackage",
            publicHeadersPath: "some/custom/path"
        ),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]
        ),
    ]

How do I locate my project’s public headers?

Your project most likely had an Xcode project file (.xcproj) before you started adding SPM support. You can find a list of your public headers in the “Build Phases” tab, under the “Headers” section.

After correctly configuring the public header files, your project might build. If it still doesn’t, you may have other header files that need to be discoverable. If that’s the case, you’ll need to add search paths for your private header files using headerSearchPath in your cSettings:

.target(
    name: "MyPackage",
    cSettings: [
        .headerSearchPath("Payments"),
        .headerSearchPath("Payments/ApplePayPaymentsService"),
        .headerSearchPath("Transactions/Components")
    ]),

It’s up to you whether you want to group all private header files in a single directory (.headerSearchPath("Path/To/My/Private/Headers")) or add all existing directories one by one using their current locations as I did in the snippet above.

With that done, you should now be able to build your project.

Troubleshooting

In my case, after migrating all dependencies to SPM and adding the package manifest, I was able to delete the Xcode project file entirely. If that is not the case for you, you might encounter additional issues.

One common problem is the error fatal error: framework '<some_framework>' not found when trying to import an SPM dependency into an Objective-C codebase in a project managed via an Xcode project file (.xcproj).

In this situation, you may need to experiment with your project settings. This thread on the Apple Developer Forums is an good starting point.

Conclusion

Once these steps are completed, you should be able to build your project. If you add your new package as a dependency via SPM, you can import it like any other Swift package. The same rules apply.

Swift:

import MyPackage

Objective-C:

@import MyPackage;

Resources

What helped me the most was looking at examples of existing Objective-C projects with SPM support. The following repositories are worth exploring:

• PSPDFKit/PDFXKit: A drop-in replacement for Apple’s PDFKit, powered by the PSPDFKit framework.
• AliSoftware/OHHTTPStubs: A library to easily stub your network requests.
• Mantle/Mantle: Model framework for Cocoa and Cocoa Touch

It looks like Objective-C is still an option in the default iOS project template. You can access it after setting the Interface to “Storyboard”. I hadn’t realized these dropdown menus were interconnected.

All credit goes to Douglas for spotting this!

tl;dr use macOS → Application → Game or Command Line Tool

Recently I wanted to refresh my memory on Objective-C. My first thought was to open Xcode, create a new project with language set to Objective-C and play with it. To my surprise, none of the iOS Application project templates allow you to select any other language than Swift.

I (mistakenly) assumed that Apple must have removed Objective-C from all templates altogether. I ended up searching for some open-source Objective-C project that I could use as a starting point.

Later on I learned that Objective-C language options are still alive and well in some templates for macOS.

In this article, I’ll show you how to access a web page’s content, alter it using JavaScript, and display it using your Safari extension’s UI. Specifically, I’ll demonstrate how to display an article’s content in a popover.

I often use Large Language Models (LLMs) to summarize articles when I’m unsure if they’re worth reading. Without the extension we’re about to build, I’d need to manually trigger Safari’s reader mode (⌘ + ⇧ + R), copy all content, and paste it into Claude or ChatGPT. This extension is a handy tool that reduces friction!

Start by creating a new project using the “Safari App Extension” template, or add a Safari Extension target to your project. When prompted, set type to Safari App Extension (the default at the time of writing).

After the initial setup is complete, follow this guide to modify the template so that you can use SwiftUI to build the UI. Follow all the instructions except for one: do not delete script.js. We’ll need it to capture the web page’s content.

Once that’s done, we’ll proceed to get the current web page’s content, modify it to extract the article content, and display it. You can check out the complete sample project here.

1. Getting Active Safari Page (getActiveSafariPage)

let page = try await getActiveSafariPage()

• Uses Safari’s extension API to retrieve the current window, tab, and page
• Returns a SFSafariPage object representing the active browser page

2. Requesting Content (requestAndReceiveContent)

page.dispatchMessageToScript(
    withName: SafariExtensionMessage.Name.getContent.rawValue,
    userInfo: nil)

• Sends a “getContent” message to the injected content script

3. Content Script Processing (script.js)

function getPageContent() {
    // Tries to extract content in this order:
    // 1. Structured article data (JSON-LD)
    // 2. Article elements with specific selectors
    // 3. Fallback to body text
    
    const content = {
        title: document.title,
        body: getReaderContent().trim()
    };
    
    safari.extension.dispatchMessage("pageContent", { content });
}

4. Message Handling (SafariExtensionHandler)

case .pageContent:
    NotificationCenter.default.post(
        name: NSNotification.Name(SafariExtensionMessage.Notification.messageReceived.rawValue),
        object: nil,
        userInfo: userInfo
    )

• Receives the content message from the script
• Posts it to NotificationCenter

5. Content Reception (PopoverViewModel)

for await notification in NotificationCenter.default
    .notifications(named: NSNotification.Name(SafariExtensionMessage.Notification.messageReceived.rawValue))
    .compactMap({ notification in
        // Converts notification data to WebPageContent
    })

• Listens for the notification with the page content
• Converts the received data into a WebPageContent struct
• Returns the structured content to be displayed in the popover

Resources

• How to build a Safari extension with SwiftUI
• SafariReaderModeSample | GitHub

Everything changed when I discovered Karabiner Elements’ ability to create distinct mappings for different key events, such as short presses and long presses. The setup I’m about to share lets you launch any mapped app by pressing caps lock plus a specific letter. The best part? You don’t lose the caps lock functionality—it still works as normal when pressed on its own.

Prerequisites

This setup uses two tools: Karabiner Elements for setting up a hyper key binding and Hammerspoon for setting up the key mapping for specific apps. There’s a multitude of solutions to this problem, but I’ve found this one to work for me. It’s fairly simple and easy to set up in minutes.

1. Install Karabiner Elements
2. Install Hammerspoon

Setting up Karabiner Elements

Navigate to the Complex Modifications tab and install this rule. This rule maps the caps lock key to hyper or escape when pressed. You can modify it to your liking.

Setting up Hammerspoon

Paste the below into your Hammerspoon config and reload it.

hs.loadSpoon("AppLauncher")

local hyper = {"control", "option", "cmd", "shift"}

spoon.AppLauncher.modifiers = hyper
spoon.AppLauncher:bindHotkeys(
   {
    c = "Terminal",
    x = "Xcode",
    f = "Firefox",
    s = "Slack",
    m = "Music",
    v = "Visual Studio Code",
    t = "Tower",
    p = "Proxyman",
    o = "Obsidian",
    // ...
  }
)

This config uses the AppLauncher spoon to set up hotkeys for specific apps. You can adjust them to your liking.

Notes

Single Tool for the Job

I know it is technically possible to achieve the same result using Hammerspoon alone, but it didn’t seem like the right tool for the job to me. If that’s not an issue for you, you might want to use this as your starting point:

local hyper = {"ctrl", "alt", "cmd", "shift"}
local sendEscape = false
local lastMods = {}

-- Function to check if only caps lock was pressed
local function onlyCapsWasPressed()
    for k, v in pairs(lastMods) do
        if v then return false end
    end
    return true
end

-- Create and start the eventtap
eventtap = hs.eventtap.new({hs.eventtap.event.types.flagsChanged, hs.eventtap.event.types.keyDown, hs.eventtap.event.types.keyUp}, function(event)
    local newMods = event:getFlags()
    
    if event:getKeyCode() == 57 then -- Caps Lock key
        -- Check if fn is pressed
        if newMods.fn then
            -- Allow normal caps lock behavior when fn is pressed
            return false
        end

        -- On key down
        if not lastMods.capslock and newMods.capslock then
            sendEscape = onlyCapsWasPressed()
            -- Set Hyper key
            hs.eventtap.keyStroke(hyper, "")
            return true
        -- On key up
        elseif lastMods.capslock and not newMods.capslock then
            if sendEscape then
                hs.eventtap.keyStroke({}, "escape")
            end
            return true
        end
    end
    lastMods = newMods
    return false
end)
eventtap:start()

Running out of Keys

Ideally, I’d want this setup to support two-letter combinations, but I couldn’t find a straightforward solution. One idea would be to completely ditch the AppLauncher and use something like the following:

local hyper = {"cmd", "alt", "ctrl", "shift"}

local appShortcuts = {
    te = "Terminal",
    to = "Tower"
}

local lastKeyPress = nil
local lastKeyPressTime = 0

hs.hotkey.bind(hyper, "t", function()
    local now = hs.timer.secondsSinceEpoch()
    if lastKeyPress and (now - lastKeyPressTime) < 0.5 then
        local combo = "t" .. lastKeyPress
        if appShortcuts[combo] then
            hs.application.launchOrFocus(appShortcuts[combo])
        end
        lastKeyPress = nil
    else
        lastKeyPress = "t"
    end
    lastKeyPressTime = now
end)

for k, _ in pairs(appShortcuts) do
    local secondKey = string.sub(k, 2, 2)
    hs.hotkey.bind(hyper, secondKey, function()
        local now = hs.timer.secondsSinceEpoch()
        if lastKeyPress and (now - lastKeyPressTime) < 0.5 then
            local combo = lastKeyPress .. secondKey
            if appShortcuts[combo] then
                hs.application.launchOrFocus(appShortcuts[combo])
            end
        end
        lastKeyPress = nil
    end)
end

Missing package product `PACKAGE_NAME`

The issue often occurs when the package you’re trying to add is already open in Xcode. To resolve:

1. Close the package in Xcode.
2. Close your main project.
3. Reopen your main project.

I’m not sure what might be causing this issue or why reopening the project is required (a clean build won’t do).

To learn more about local Swift packages read Working with Local Swift Packages.

Last month, I once again switched my default web browser to Safari. It has its quirks, but I missed it in a weird way.

I initially switched to Firefox because of its stellar support for vim keybindings and some other extensions I started to enjoy. Even with all those improvements, I began to miss some niceties that Safari has built-in.

With my current setup, I still use Firefox for some websites. Some sites are just hard to use without uBlock Origin. None of Safari’s content blockers match its performance.

I learned to live with all of Safari’s shortcomings, but there is one UX issue that keeps me up at night: The Safari window always gets closed when you close the last tab (⌘ + w). As of macOS 14, there seems to be no way to change this default behavior without introducing some other issues.

What irks me even more is that this behavior does not exist on iPadOS. On iPads, the ⌘ + w shortcut closes the open window only if the current window has a single empty tab. In all other cases, the Safari window will remain open.

What I’ve found recently is that this behavior is different for tab groups. When you close the last tab in a Safari tab group, the window will remain open. Since then, I created my “main” tab group:

This solution has the nice benefit of keeping all your current tabs in sync across all your devices. I know that by default you can still access all your open tabs from any device, but it was always an extra hassle for me to go through the “From <device_name>” section.

This setup requires me to frequently switch between multiple projects. Just a few days ago, I was working on the login flow. This involved modifying two Swift packages and one Xcode project.

Remembering whether a given project is a Swift package, a workspace (.xcworkspace), or a standard project (.xcodeproj) is exhausting. This adds unnecessary complexity and slows down the workflow. It would be better if we had a single command to open all of them at once. Here’s a script that does just that:

# The osp (Open Swift project) function first attempts to open a Package.swift file in the current directory; if it doesn't exist, it then searches for and opens either a .xcworkspace or a .xcodeproj directory, or outputs an error message if none are found.

osp() {
# Check for Package.swift in the current directory
if [[ -f "Package.swift" ]]; then
open "Package.swift"
return
fi

# Look for .xcworkspace directories in the current directory
local workspace=$(find . -maxdepth 1 -name "*.xcworkspace" -type d | head -n 1)

if [[ -n "$workspace" ]]; then
open "$workspace"
return
fi

# Look for .xcodeproj directories if no .xcworkspace directories were found
local project=$(find . -maxdepth 1 -name "*.xcodeproj" -type d | head -n 1)
if [[ -n "$project" ]]; then
open "$project"
return
fi

# Output error message if neither file type was found
echo "No project or workspace files found"
}

To use it, simply append it to your .zshrc file and run source ~/.zshrc or restart the shell.

Project A
  |
  └──> Swift Package B

To speed up and improve the workflow, you can convert the remote dependency B to a local one. This method works whether Project A is a Swift package or an Xcode project (xcodeproj or xcworkspace).

Xcode Project

In this case, Project A has an Xcode project file.

1. Remove the remote dependency from your project.
2. Re-add it as a local package.

This might seem excessive, as Xcode also supports just dragging and dropping the package into your project, but I’ve found this solution to be flaky. Explicitly removing it works every time, most of the time.

Swift Package

If Project A is a Swift package, you’ll need to convert B’s dependency declaration:

dependencies: [
    .package(url: "https://github.com/TinyCorp/B", exact: "0.52.3"),
    // ...

… into this:

dependencies: [
    .package(path: "path/to/B"),
    // ...

Example: given the following file structure, path is ../B:

.
├── A
│   └── Package.swift (we're here)
└── B
    └── Package.swift

With this setup, you’re now able to edit dependency B directly inside of A. I was genuinely surprised by how well Xcode handles this workflow.

Notes

Make sure the Swift package that you plan to add to your project is not opened in another Xcode window. In some cases, Xcode might fail with a cryptic error when trying to add the local package.

Since then, I’ve had time to refine this project and add some new features. You can download the final Command Line Interface (CLI) or the macOS app from this link.

Next on my list is the complete automation of the process of synchronizing Alfred text snippets with macOS text replacements. I’m not sure if it’s even possible, but there’s only one way to find out. I’m keeping my fingers crossed that it will take me less time than it did before.

For anyone interested, the tool is available here!

TL;DR

package.targets = package.targets.map { target in
    var plugins = target.plugins ?? []
    plugins.append(.plugin(name: "SwiftLintPlugin", package: "SwiftLint"))
    target.plugins = plugins
    return target
}

The Problem

Last month, I was tasked with adding SwiftFormat and SwiftLint to one of the projects my team maintains. The project is medium-sized and uses Swift Package Manager (SPM) for modularization. It has a separate SPM package for each module. For example:

• FeatureModules // Directory
  • Login // Swift Package
  • MyAccount // Swift Package
  • Dashboard // Swift Package
• Core // Directory
  • DomainModels // Swift Package
  • Networking // Swift Package

Each module typically consists of three targets (e.g., Login, LoginTests, LoginTestUtils). The third target’s sole purpose is to avoid duplicating testing doubles. You can read more about it here.

Adding SwiftFormat to the main project and all SPM packages was pretty straightforward. I decided to integrate it at the CI level to ensure all new code changes are properly formatted. Locally, I left this choice up to the maintainers. They can use it through a post-commit git hook or as an Xcode Extension. Depending on your needs, both solutions work great.

Integrating SwiftLint into the base project was also a breeze. What became problematic was integrating it into all the Swift packages. As I mentioned before, we were using a Swift package for each module. As per the documentation:

Due to limitations with Swift Package Manager plugins, this is only recommended for projects that have a SwiftLint configuration in their root directory, as there is currently no way to pass any additional options to the SwiftLint executable.

This limitation would require us to duplicate our SwiftLint config for each package, making future updates to the SwiftLint config error-prone and time-consuming. The same goes for updating the plugin itself.

Looking For a Solution

I had two problems to solve:

1. Automating the updating of the config file(s).
2. Automating the addition of the SwiftLint plugin to all new Swift packages in the future.

The first problem is easily solvable with a simple bash script. It would still require writing documentation, but let’s say I’m okay with the trade-off.

The second problem got me looking at Sourcery. However, this solution seemed like overkill from the beginning. Introducing Sourcery to a project just because of SPM limitations seemed like a bad idea.

Back to square one!

Solution

I started experimenting with the project structure. Instead of creating a new Swift package for each module, I decided to create a single package that worked as a container for all existing modules. Having all the modules defined in a single Package.swift file makes automating the SwiftLint plugin trivial.

// Inject base plugins into each target
package.targets = package.targets.map { target in
    var plugins = target.plugins ?? []
    plugins.append(.plugin(name: "SwiftLintPlugin", package: "SwiftLint"))
    target.plugins = plugins
    return target
}

This approach not only solved all of my problems but also required very little work. It involved merging all package definitions into a single one and moving some files around.

This solution won’t work for larger projects. Since my app had only a handful of modules, it worked wonderfully. If you’re working on a mid-sized project with tens of packages, you might consider grouping your modules into a handful of packages like FeatureModules, Models, etc.

I hope this issue will have been resolved long before we hit the wall due to the growing number of modules!

Resources

• Swifty Stack

I’ve relied on Alfred as my daily driver for boosting productivity for years. However, I didn’t switch from Apple’s Spotlight overnight. It took three attempts before I truly embraced its capabilities. In this article I’ll share my Alfred setup and explain my most frequent workflows. Let’s dive in!

The Initial Setup

I’ve already described the initial setup in detail in New Mac Setup article, so be sure to check it if you’re interested.

Snippets: Efficiency at Its Best

One of my absolute favorite features of Alfred is Snippets. I rely on them extensively, whether it’s for a quick access to emojis, executing frequent commands, or crafting boilerplate messages. Let’s explore those use cases!

Emojis

While there are several popular workflows for emojis, I’ve chosen to create snippets for the ones I use most frequently. It’s a highly efficient approach, and for those less common emojis, we’ll explore workflows later. Curious about using your snippets on mobile devices? Don’t miss my guide on Alfred Snippets on iOS.

Commands

I’ve compiled a set of frequently used commands, primarily for directory navigation and running common scripts. Although these tasks could be handled with shell aliases, I prefer having everything neatly organized within Alfred. This setup has proven to be reliable and convenient. It just works.

Note Taking

Markdown is my go-to format for note-taking, and I’ve leveraged snippets to automate repetitive tasks. Here are some noteworthy examples:

• !cb - Inserts a markdown code block.
• !scb - Inserts a markdown code block with Swift syntax highlighting.
• !ds - Generates a line separator followed by today’s date, perfect for organizing notes.
• !nd - Initiates a new daily entry in my TODOs note.

And More

Snippets also come in handy for quick message replies, composing emails, and inserting code snippets.

Workflows: Unleash Productivity

The most exhilarating aspect of Alfred is its workflows – a feature that can supercharge your productivity. For a deeper dive into workflows, you can explore them further here.

Note Taking

Community-built Alfred workflows have streamlined note-taking with popular apps. Personally, I rely on alfred-bear for Bear Notes (personal notes) and obsidian-alfred for Obsidian (work-related notes).

Ideally, I’d prefer keeping all my notes in a single place. However, Bear Notes restricts data to your Apple ID, making cross-account sharing a challenge. Obsidian, with its raw markdown files, easily accommodates iCloud folder sharing. Initially, I thought about migrating my personal notes to Obsidian, but the recent major release of Bear Notes swayed my decision. With new features, it’s just too good of an app to quit using!

Both workflows offer similar features (Obsidian one is a bit more complex). They both excel at accessing notes and creating new ones on the fly.

Launchers: Ready, Set, Go!

Launchers are my custom workflows that I use to launch a set of apps for a particular activity:

• Development: Launches a suite of essential tools and utilities.
• Writing: Opens a predefined set of notes and tools.
• Investing: Initiates my brokerage account, bank account, and a useful Excel sheet for tracking investments.

While I could manage without these, they reduce friction when switching between tasks, ensuring I’m just a click away from my next endeavor.

Emoji: Beyond Snippets

As previously mentioned, snippets handle the most common emojis, but for the rest, there’s this workflow. It may be a tad slower than snippets, but it’s significantly quicker than macOS’s built-in emoji picker. Give it a try – you won’t want to go back.

Shortcuts: Effortless Automation

Certain tasks are best automated using macOS Shortcuts.app. There’s one problem: there’s no easy way to launch them without clicking through the app. However, this shortcut allows you to initiate them directly from Alfred.

More in Store

Explore these miscellaneous workflows for even more functionality:

• AirPlay Toggle - utility for switching between airplay devices
• LinkClean - tool for removing extraneous information from URLs
• System Settings - utility for opening macOS system settings panes

Wrap Up

That concludes my Alfred setup – a straightforward yet highly efficient automation of my daily tasks (at least the most repetitive ones). While there are a few improvements I’m considering, the core concept will remain unchanged.

This note describes the steps I take when setting up a new Mac. This process could be mostly automated, but I can’t get myself to do it. It takes me around 90 minutes to go through all the steps. Let’s get started!

I. Prerequisite Files to Import

Before diving into installations, I make sure to have these configuration files ready:

• .gitconfig
• .zshrc

II. Software Installation

Apps marked with “🌕” emoji are optional (it depends if it’s a work or a private Mac).

A. Homebrew & Command-Line Tools

1. Install HomeBrew (from Web)
2. Install CLI tools via Brew:

// Set shell to zsh
chsh -s /bin/zsh

brew install zsh-autosuggestions
brew install zsh-syntax-highlighting
brew install pure
brew install jesseduffield/lazygit/lazygit
brew install xcodesorg/made/xcodes

// Optional
brew install rbenv
brew install swiftlint
brew install node

B. App Store Applications

• Pause
• Dynamo
• Pixelmator Pro

C. GUI Applications (from Web)

• Alfred
• Rectangle
• Hammerspoon
• Karabiner-Elements
• Ghostty
• Obsidian
• Toggl
• Ice
• Xcode
• Visual Studio Code
• AppCleaner
• Logi Options+
• Monitor Control
• PDF Expert
• ProxyMan
• BoltAI
• 🌕 OmniDiskSweeper
• 🌕 Monodraw

III. Application Configuration

Now, let’s configure the installed applications.

• Alfred:
  • Disable both shortcuts for Spotlight (Keyboard -> Keyboard Shortcuts … -> Spotlight -> disable both)
  • Import preferences from /Users/$USER/Library/Application Support/Alfred/Alfred.alfredpreferences
  • Set global shortcut (⌘+Space)
  • Enable Clipboard History
  • Enable: Features -> Snippets “Automatically expand snippets by keyword”
  • Enable: Features -> Web Bookmarks -> Safari Bookmarks
• Rectangle:
  • Import config
• Hammerspoon:
  • Import config
  • Install AppLauncher
• Karabiner-Elements:
  • Import config
• Ghostty:
  • Import config
• Obsidian:
  • In order to make git plugin work:
    • git config --global credential.helper osxkeychain
    • git pull
• Visual Studio Code:
  • Log in to sync plugins and preferences
  • Fix holding motion keys not working with vim plugin:
    • defaults write com.microsoft.VSCode ApplePressAndHoldEnabled -bool false
• Logi Options+:
  • Restore from backup
• ProxyMan:
  • Import mapped requests

IV. System Preferences Settings

Let’s tweak the system settings.

• Set desktop background

General

• Set accent color

Language & Region

• Set English (United States) as primary language

I simply can’t stand Trash being called Bin.

Displays

• Adjust display resolution

Desktop & Dock

• Desktop & Dock -> Desktop & Stage Manager -> Click wallpaper to reveal desktop -> Only in Stage Manager

Keyboard

• Keyboard -> Keyboard Navigation -> Enable

This setting enables option selection with the Tab key.

• Keyboard -> Keyboard Shortcuts -> Modifier Keys -> Map Caps Lock to Escape

Trackpad

• Trackpad -> Point & Click -> Tap to click
• Trackpad -> Point & Click -> Tracking Speed (increase)

Sharing

• Change machine’s name

Login Password

• Enable “Use Apple Watch to unlock your applications and your Mac”

Security & Privacy

• Disable “Password Autofill”
• Add fingers to Touch ID

General (System Settings Panel)

• Set Login Items

V. Core macOS Application & Utility Configuration

Archive Utility

• Preferences -> After expanding: move to trash

Messages

• Enable message forwarding on iPhone
• Enable iCloud sync

Dock

• Move to right
• Adjust zoom and size
• Rearrange apps
• Enable “Show Percentage” (Battery settings, if referring to menu bar)

Mail

• Take all accounts online
• Rename and rearrange

Finder

• Rearrange sidebar
• Set “Search the current folder”
• “Show path bar” (it’s in the menu bar)
• Enable “Snap to grid” (right click on empty Desktop, Show View Options -> Sort By -> Snap to Grid)
• Disable “Show warning before removing from iCloud Drive”
• Set Preferences -> General -> New Finder windows show … -> Desktop

Time Machine

• Create backup

Conclusion

That’s it. That’s the entire setup process. I know there are tools to automate ~90% of it. I plan to do it someday. In the meantime, my next project is to automate syncing things like Alfred preferences and system settings across all of my Macs. Fingers crossed, I’ll sit down and do it this summer!

What made this issue especially frustrating was that it didn’t happen every time, and the time it took for the keyboard to reconnect varied widely. It drove me insane.

I’ve been following several threads in r/logitech, reaching out to Logitech support multiple times, and submitting bug reports through the Logi Options+ app. However, none of these attempts at resolution have been successful.

The solution? Purchase the Logi Bolt USB Receiver. It’s disappointing that there are no other options available, and it’s frustrating that Logitech is ignoring the complaints. But unfortunately, that’s the way it is.

There’s one problem. Alfred snippets only work on your Mac. Today we’ll focus on how we can convert them into macOS snippets. That way, you’ll be able to use them across all your Apple devices!

How

Alfred stores snippets as a Zip archive. On macOS, you can open it with the Archive Utility app that’s shipped with the system. After successfully exporting it, you’ll need to convert it from Alfred’s data format to the one used by the system snippets. macOS allows to import keyboard snippets in bulk with Property List format files (plist).

Here’s how Alfred stores snippets:

{
  "alfredsnippet" : {
    "snippet" : "🐛",
    "uid" : "81F59CDA-FD1E-4D71-AB4C-E4C47212023B",
    "name" : "bug",
    "keyword" : "bug"
  }
}

… and here’s how macOS stores snippets:

<dict>
	<key>phrase</key>
	<string>🐛</string>
	<key>shortcut</key>
	<string>:bug</string>
</dict>

Steps

1. Export a snippet collection from Alfred
   • Alfred -> Features -> Snippets -> Collection -> right-click -> Export

macOS does not allow us to group snippets into collections

2. Open the exported file using the Archive Utility app

• right-click -> Open With -> Archive Utility

3. Convert files from Alfred’s format (json) to macOS format (plist)

For this step I use a script written in Swif. You can download it here: bkunat/snippet-converter. Should you decide to use it, please follow instructions in the main.swift file.

4. Import the snippets into /System/Library/PreferencePanes/Keyboard.prefPane

• System Settings -> Keyboard -> Text Replacements -> drag&drop the created plist file

Notes

• All devices need to be signed into a single iCloud account. Otherwise, macOS won’t sync your snippets.
• macOS 13.2
• Alfred 5.0.6