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

The only part I never enjoyed was managing the library on the go.

If you’re building a similar setup, these posts might help:

• My Synology Setup
• Configuring Tailscale Subnet Routing to Access Docker Containers by LAN IP
• Setting Up Caddy as a Reverse Proxy on Synology NAS

The Fix

Use Ruddarr.

My initial plan was to check what clients already exist, decide I don’t like any of them, and build something for myself over a weekend.

That plan lasted maybe five minutes.

Ruddarr has pretty much everything I want from a mobile companion app. Browsing feels native, adding new movies and TV shows is fast, and the whole experience is vastly better than using the stock Sonarr and Radarr web UIs on iPhone.

The fact that it’s open source is the cherry on top. The app itself is free, setup takes minutes, and if your instances are already reachable from your phone there’s really no reason not to give it a try.

That’s it. I thought I’d share. If I had known there was a Sonarr and Radarr client that matched my setup this well, I would have been using it from day one.

Alternative

If you want one app that supports more of your self-hosted stack, Helmarr is worth a look too. Ruddarr is still the better fit for me, but Helmarr goes beyond just Sonarr and Radarr.

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.

Typical failure logs look like this:

[VPN] Creating interface [wg0-fix].
RTNETLINK answers: Not supported

Or later during firewall setup:

Error: Could not process rule: Not supported
add table inet hotio

The Fix

Pin the image to the last known working WireGuard build from the TRaSH-Guides PR #222:

services:
  qbittorrent:
    image: ghcr.io/hotio/qbittorrent:release-e799f87

Tradeoffs of pinning an old image:

• No security or feature updates.
• Potential breakage when VPN providers change endpoints or auth flows.
• You’re stuck on older qBittorrent/libtorrent versions.
• This is a temporary workaround, not a real fix.

Long term, move the VPN to a dedicated container (for example, gluetun with OpenVPN) and run qBittorrent without VPN logic inside its container. That keeps your NAS kernel limitations out of the qBittorrent image and avoids the nftables requirement.

Resources

• TRaSH-Guides Synology Templates PR #222
• gluetun
• hotio qBittorrent container docs

If you’re interested, check out how to set up qBittorrent with PIA on Synology, verify your qBittorrent VPN IP, or add a reverse proxy to your Synology setup:

• Setting Up qBittorrent with Private Internet Access (PIA) VPN on Synology NAS
• Verifying VPN Status for Docker qBittorrent on Synology
• Setting Up Caddy as a Reverse Proxy on Synology NAS

⚠️ 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

Instant Platinum is an unofficial client for Fitness Platinum. The audience is tiny: a gym franchise in Kraków and Katowice, Poland. That’s fine. This is mostly for me.

I can’t stand the official app. It’s not terrible, but it’s bloated with things I don’t care about: booking classes, managing goals, shopping (??). I just want to see my entry QR code as soon as I open the app. Today it takes three taps. Not awful, but not great.

So I built my own thing. Enter Instant Platinum: the app figures out which club you’re near and pops up the right QR code instantly. No clicks required. Works on iOS and watchOS.

Open, scan, done.

It took two evenings to put together. I’ll probably never “earn back” the time I spent, but I’ll happily trade those hours for fewer moments of frustration.

Since the initial release, it’s morphed into a fun little hobby project. I recently shipped Platinum Pulse, which I plan to plug in to show historical occupancy inside Instant Platinum. Next up: widgets and shortcuts so the code is ready before I even think about opening the app.

If you by any chance go to Fitness Platinum, go ahead and try it!

Platinum Pulse is a web app that aggregates live occupancy data for Fitness Platinum clubs.

Small disclaimer: the audience here is tiny. Fitness Platinum is a gym franchise in Kraków and Katowice, Poland.

I recently built a tiny iOS app to instantly generate the gym QR codes I need. “Doesn’t your gym have an official iOS app?” It does. It’s just bloated with things I don’t use: booking classes, setting goals, shopping (why?), and it takes way too many taps to reach the only feature I care about.

All I ever wanted was: show me my QR code with as few clicks as possible. Bonus: show it on my Apple Watch. There’s no official watch app, so I spent an evening hacking my own. I called it Instant Platinum: an iOS/watchOS app that pops up the right club’s QR code based on location. Zero taps. I’ve been using it for weeks and love it.

Then I wanted more. Specifically, historical occupancy: handy when visiting new clubs or hitting my usual one at odd hours. PerfectGym’s API exposes live occupancy, but I couldn’t find any route to historical data. Enter Platinum Pulse.

It runs on my Synology, polls live occupancy, and stores it so I can see trends over time. Now I can make a quick, data-driven call about which gym to choose on any given day.

It turned into a fun little project. It’s the first thing I’ve built purely for myself that I actually use IRL; until now, most of my tinkering lived in dev tools and shell scripts. I learned a few new tricks. Fun times!

In this short tutorial, we’ll set up monitoring using a self-hosted instance of Changedetection.io to solve this problem.

Prerequisites

• Changedetection.io set up and running (setup guide)
• Sockpuppetbrowser configured to enable the Playwright Chromium/JavaScript fetch method (most careers sites require JS)
  • The setup guide linked above covers this.

Setup

Add the company’s careers page and click Edit > Watch.

In the Request tab, change the Fetch method to Playwright Chromium/JavaScript. While not all sites require this, most modern careers pages need JavaScript to load properly.

Go to the Filters & Triggers tab and find Keyword triggers – Trigger/wait for text. Add keywords for the roles you’re interested in. Here are the ones I use:

Apple Engineer
Apple Developer
Apple Programmer
iOS Engineer
iOS Developer
iOS Programmer
Mobile Engineer
Mobile Developer
Mobile Programmer

Save the watch. For additional companies, clone this watch and update the URL.

Notifications

Go to Settings -> Notifications and configure your preferred notification method. Changedetection.io supports 80+ options.

I went with Telegram: it’s straightforward to set up and requires no maintenance.

Resources

• Changedetection.io + Chrome Synology Setup with Docker Compose
• Changedetection.io

At the end of this article you’ll be able to add posts to your website and manage existing ones using a Decap admin panel on your website.

Prerequisites

• Your website is built using Hugo
• Your website is hosted using CloudFlare pages
• You have a GitHub account (we’ll use it for OAuth authentication)

How

Creating an OAuth App in GitHub

1. Go to Developer Settings
2. OAuth Apps
3. New OAuth App
4. Fill out application name, Homepage URL and Authorization callback URL as follows

5. Register application
6. Generate a new client secret (we’ll need it in a moment)

CloudFlare

1. Open your CloudFlare dashboard
2. Compute (workers)
3. Workers and Pages
4. Select the project you want to set up your CMS for and open settings
5. Go to Variables and secrets and select Add
6. Add the following two secrets

GITHUB_CLIENT_SECRET: <secret that you've copied in step 6 above>
GITHUB_CLIENT_ID: <Client ID from the OAuth app you've created before>

Adding Decap to your site

1. Copy functions directory from this project to the root of your website
2. Copy static directory from this project to the root of your website
3. Configure /static/admin/config.yml so that it works for your site. Here’s how this config file looks for this site:

backend:
  name: github
  repo: bkunat/kunat.dev
  branch: main
  base_url: https://kunat.dev
  auth_endpoint: /api/auth

media_folder: "content/notes/images"
public_folder: "/notes/images"

collections:
  - name: "notes"
    label: "Notes"
    folder: "content/notes"
    create: true
    slug: "{{slug}}"
    editor:
      preview: false
    fields:
      - { label: "Title", name: "title", widget: "string" }
      - { label: "Publish Date", name: "date", widget: "datetime", date_format: "YYYY-MM-DD", time_format: "HH:mm:ss", format: "YYYY-MM-DDTHH:mm:ss+02:00" }
      - { label: "Draft", name: "draft", widget: "boolean", default: true }
      - { label: "Tags", name: "tags", widget: "list", allow_add: true, collapsed: false, field: { label: "Tag", name: "tag", widget: "string" } }
      - { label: "Body", name: "body", widget: "markdown" }

4. Open yoursite.com/admin and log in using your GitHub account

Success

After a successful login here’s how your site should look like:

Recently a non-technical friend asked me to create a site for him. He didn’t have any special requirements so to save time I just cloned this site. The final missing piece was adding a CMS that would allow him to easily add new content to the site.

I was so positively surprised by the Decap experience that I ended up adding it for myself. Till now I managed all of my content manually with git. That remains my default way to manage content, but being able to quickly add/edit posts from my iPhone or iPad is a great improvement!

Resources

• ⭐️ GitHub - SubhenduX/decap-cms-cloudflare-pages: Oauth API to run Decap CMS on Cloudflare Pages
• Basic Steps | Decap CMS | Open-Source Content Management System

One feature I missed dearly from Bear Notes was the ability to quickly navigate between notes using up/down arrow keys. This couldn’t be replicated using Obsidian hotkeys or plugins, and other people were missing this feature too.

Turns out Obsidian just added this in version 1.9.10!

The Fix

In Obsidian 1.9.10+ you can navigate through your notes using CMD + up/down arrows.

Make sure the File Explorer view is active, then hold Command/Ctrl while using the arrow keys to browse through files. The file under the cursor will open automatically.

Resources

• Obsidian 1.9.10 Changelog
• Reddit discussion about missing arrow key navigation
• Kepano’s announcement

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

Seeing a red dot with “401 unauthorized” status for Plex in your Homarr dashboard, even though your Plex server runs perfectly fine? The issue is likely your URL format.

Instead of using the standard IP:PORT format like other containers, Plex requires the full web interface path.

The Fix

Change your Plex internal address from:

192.168.1.100:32400

To:

192.168.1.100:32400/web/index.html#!/

Why This Path is Required

Plex’s web interface uses a single-page application architecture with hash-based routing. The /web/index.html#!/ path serves as the entry point to the bundled Plex Web App. This specific URL structure is how Plex handles authentication and routing for external integrations like Homarr.

Unlike other services that expose simple API endpoints at their base URL, Plex requires access through its web application interface to properly authenticate and respond to status checks.

• Homarr Plex 401 Discussion
• Plex Media Server URL Commands | Plex Support

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

When I was away from home, even though I could reach my Synology via Tailscale address or Magic DNS, trying to access something like 192.168.1.144:7878 for Radarr would just time out.

That’s where Tailscale’s subnet routers come in. This feature allows you to access all devices on your home network—including your Docker containers—using their actual LAN IP addresses.

What We’re Solving

We want to access our Docker containers using their LAN IP addresses consistently, regardless of whether we’re connected to our home network or accessing remotely through Tailscale.

Prerequisites

• Tailscale already set up on your machine. You can use this guide to set it up.

Setting Up Subnet Routing

Step 1: Configure Your Synology as a Subnet Router

First, you’ll need to SSH into your Synology. Once you’re connected, run this command:

sudo tailscale up --advertise-routes=192.168.1.0/24 --advertise-exit-node --reset

Important: Make sure to replace 192.168.1.0/24 with the correct subnet for your network. In my case, my Synology has the IP address 192.168.1.144, so I use 192.168.1.0/24. You can find your network’s subnet by checking your router’s configuration or running ip route on your Synology.

Step 2: Enable Subnet Routing in Tailscale Admin Console

The command above advertises your local network routes to Tailscale, but you need to explicitly enable them in the admin console:

1. Go to the Tailscale admin console at https://login.tailscale.com/admin/machines
2. Find your Synology device in the machines list
3. Click on the device and select “Edit route settings”
4. In the “Subnet routers” section, check the box next to your advertised route (e.g., 192.168.1.0/24)

Testing Your Setup

With that configuration complete, you should now be able to access all your Docker containers using their LAN IP addresses, regardless of whether you’re connected to your home network or not.

For example, if you have a container running on 192.168.1.144:7878, you can access it from anywhere by simply navigating to that address in your browser while connected to Tailscale.

Taking It Further: Reverse Proxy Setup

You can make this setup even more elegant by implementing a reverse proxy. This allows you to access your services using clean subdomains like radarr.kunat.dev instead of remembering IP addresses and port numbers. You can read more about it here.

Resources

• Tailscale documentation on subnet routers
• How To Install And Configure Tailscale On Your Synology Nas
• Setting Up Caddy as a Reverse Proxy on Synology NAS

What’s Caddy?

Caddy is a modern, open-source web server that excels at reverse proxying. It’s lightweight, easy to configure, and handles HTTPS automatically. What sets it apart is its human-readable configuration format and automatic certificate management capabilities.

Why I Chose Caddy Over Synology’s Built-in Solution

Synology does include a reverse proxy feature, but it has some limitations:

Platform Agnostic: Caddy runs in Docker, which means it’s not tied to Synology’s ecosystem. If I ever migrate to a different NAS or server setup, my configuration comes with me.

File-Based Configuration: This is the big one for me. Synology’s reverse proxy requires you to configure each service through their GUI interface. When you’re running more than a few containers, this becomes time-consuming. With Caddy, I can define all my services in a single configuration file that’s easy to version control and backup.

Better HTTPS Handling: Caddy’s automatic HTTPS capabilities are far superior to what Synology offers out of the box. We won’t use those, but I listed it for completeness’ sake.

Goals

Access your Docker containers using clean subdomains instead of remembering port numbers. Instead of typing 192.168.1.100:9696 to reach Prowlarr, you’ll use prowlarr.yourdomain.com.

Prerequisites

Before we dive in, you’ll need a few things in place:

Docker Setup: I’m assuming you have Docker set up and running using the Trash Guides. This isn’t strictly required, but I’ll assume your directory structure and permissions match what’s described in their guide.

Cloudflare Domain Management: This guide assumes your domain is managed through Cloudflare’s dashboard. The DNS records must have the proxy status enabled (orange cloud icon). This is crucial for the HTTPS setup we’ll implement later.

Local DNS Server: You’ll need to be running your own DNS server like AdGuard Home or Pi-hole. This is required to add a wildcard DNS rewrite rule that points *.yourdomain.com to your Synology’s IP address.

Setup

Adding Caddy to Your Docker Compose

First, let’s add Caddy to your existing docker-compose.yml file. Here’s the configuration I use:

  caddy:
    container_name: caddy
    image: caddy:latest
    restart: unless-stopped
    network_mode: host
    environment:
      - TZ=${TZ}
    volumes:
      - /volume1/docker/appdata/caddy/Caddyfile:/etc/caddy/Caddyfile:ro
      - /volume1/docker/appdata/caddy/data:/data
      - /volume1/docker/appdata/caddy/config:/config
      - /volume1/docker/appdata/caddy/certs:/caddy/certs:ro

Creating the Folder Structure

In your appdata directory (/volume1/docker/appdata), create the necessary Caddy directories:

mkdir -p caddy/{certs,config,data} && touch caddy/Caddyfile

This creates the directory structure that Caddy needs, including directories for certificates, configuration, and data storage, plus the main Caddyfile.

Freeing Up Ports 443 and 80

Here’s something that caught me off guard: Synology automatically binds to ports 443 and 80 even if you’re not using their built-in reverse proxy. Since Caddy needs these ports to handle HTTPS and HTTP traffic, we need to free them up.

sed -i -e 's/80/82/' -e 's/443/444/' /usr/syno/share/nginx/server.mustache /usr/syno/share/nginx/DSM.mustache /usr/syno/share/nginx/WWWService.mustache

synosystemctl restart nginx

I set up a boot script to handle this automatically on each reboot (Control Panel -> Task Scheduler). While I’ve found that this override typically persists between reboots, there’s no harm in ensuring it runs at startup. System updates might reset these settings to their defaults, and I’d rather be safe than sorry.

Setting Up HTTPS (Optional but Recommended)

HTTPS isn’t technically required for local-only access, but it eliminates browser warnings. However, there’s an important caveat with Caddy’s automatic HTTPS feature.

Why Caddy’s Built-in Auto HTTPS Won’t Work: Caddy’s automatic HTTPS uses Let’s Encrypt, which requires ACME challenges to verify domain ownership. These challenges need your server to be accessible from the internet. If your containers are only accessible through Tailscale or similar private networks (like mine), the ACME validation will fail.

The Solution: Cloudflare Origin CA Certificates: Since I use Tailscale to access my containers outside my home network, I opted for Cloudflare’s Origin CA certificates. These certificates are valid for 15 years and don’t require internet accessibility for validation.

Generating Cloudflare Origin Certificates

Your domain needs to be using Cloudflare for this to work. Navigate to the Cloudflare Origin CA dashboard and generate a wildcard certificate for your domain. See Cloudflare Docs for step-by-step instructions.

Save the public and private keys to these files:

• cert.pem (public key)
• key.pem (private key)

Move both files to your caddy/certs directory.

Adding the Certificate to Your Devices

To eliminate browser security warnings, you’ll need to add the public certificate (cert.pem) to your device’s trusted certificate store. On macOS, this means adding it to your keychain and marking it as trusted. You’ll need to repeat this process for each device you want to use to access your containers.

Setting Proper Permissions

Following the Trash Guides approach, set the correct permissions for the docker user:

sudo chown -R docker:users /volume1/docker/appdata/caddy
sudo chmod -R a=,a+rX,u+w,g+w /volume1/docker/appdata/caddy

Configuring the Caddyfile

Here’s a sample Caddyfile configuration. This is where the magic happens:

# Global options
{
	# Disable automatic HTTPS since we're using Cloudflare Origin CA certs
	auto_https off
}

# Prowlarr
prowlarr.kunat.dev {
	reverse_proxy localhost:9696
	tls /caddy/certs/cert.pem /caddy/certs/key.pem
}

# Plex
plex.kunat.dev {
	reverse_proxy localhost:32400
	tls /caddy/certs/cert.pem /caddy/certs/key.pem
}

# AdGuard
adguard.kunat.dev {
	reverse_proxy localhost:3000
	tls /caddy/certs/cert.pem /caddy/certs/key.pem
}

# Synology Dashboard (HTTPS backend)
synology.kunat.dev {
	reverse_proxy https://localhost:5001 {
		transport http {
			tls_insecure_skip_verify
		}
	}
	tls /caddy/certs/cert.pem /caddy/certs/key.pem
}

# Homarr
homarr.kunat.dev {
	reverse_proxy localhost:7575
	tls /caddy/certs/cert.pem /caddy/certs/key.pem
}

Each service follows the same pattern: define the subdomain, specify the reverse proxy target (localhost:port), and point to our TLS certificates.

Running Caddy

Start Caddy with:

sudo docker-compose up -d caddy

If everything is configured correctly, you should see logs similar to these:

caddy  | {"level":"warn","ts":1752004979.244892,"msg":"failed to set GOMAXPROCS","error":"open /sys/fs/cgroup/cpu/cpu.cfs_quota_us: no such file or directory"}
caddy  | {"level":"info","ts":1752004979.2452004,"msg":"GOMEMLIMIT is updated","package":"github.com/KimMachineGun/automemlimit/memlimit","GOMEMLIMIT":18851998924,"previous":9223372036854775807}
caddy  | {"level":"info","ts":1752004979.2452545,"msg":"using config from file","file":"/etc/caddy/Caddyfile"}
caddy  | {"level":"info","ts":1752004979.247973,"msg":"adapted config to JSON","adapter":"caddyfile"}
caddy  | {"level":"info","ts":1752004979.2502022,"logger":"admin","msg":"admin endpoint started","address":"localhost:2019","enforce_origin":false,"origins":["//localhost:2019","//[::1]:2019","//127.0.0.1:2019"]}
caddy  | {"level":"info","ts":1752004979.2507207,"logger":"tls.cache.maintenance","msg":"started background certificate maintenance","cache":"0xc00079c480"}
caddy  | {"level":"warn","ts":1752004979.2785668,"logger":"tls","msg":"stapling OCSP","error":"no OCSP stapling for [cloudflare origin certificate *.kunat.dev]: no URL to issuing certificate"}
caddy  | {"level":"info","ts":1752004979.278835,"logger":"http.auto_https","msg":"automatic HTTPS is completely disabled for server","server_name":"srv0"}
caddy  | {"level":"info","ts":1752004979.2799113,"logger":"http","msg":"enabling HTTP/3 listener","addr":":443"}
caddy  | {"level":"info","ts":1752004979.2799726,"msg":"failed to sufficiently increase receive buffer size (was: 208 kiB, wanted: 7168 kiB, got: 416 kiB). See https://github.com/quic-go/quic-go/wiki/UDP-Buffer-Sizes for details."}
caddy  | {"level":"info","ts":1752004979.2800903,"logger":"http.log","msg":"server running","name":"srv0","protocols":["h1","h2","h3"]}
caddy  | {"level":"info","ts":1752004979.280308,"msg":"autosaved config (load with --resume flag)","file":"/config/caddy/autosave.json"}
caddy  | {"level":"info","ts":1752004979.2811198,"msg":"serving initial configuration"}
caddy  | {"level":"info","ts":1752004979.38889,"logger":"tls","msg":"finished cleaning storage units"}

The key things to look for are “server running” and “serving initial configuration” messages. These indicate that Caddy has successfully started and is ready to handle requests.

Now try accessing one of your Docker containers using its subdomain. If everything is working correctly, you should be able to reach your services through clean URLs like https://prowlarr.yourdomain.com.

Troubleshooting

Clean Your DNS Cache: If you’re having trouble accessing your services after setup, try clearing your DNS cache. On macOS, run:

sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder

Check Your Wildcard DNS: Make sure your local DNS server (AdGuard Home or Pi-hole) has the wildcard rewrite rule in place. Without *.yourdomain.com -> your_synology_ip, your subdomains won’t resolve locally.

Verify Certificate Trust: If you’re seeing browser security warnings, double-check that you’ve properly installed and trusted the Cloudflare Origin CA certificate on your client devices.

Resources

• Free 80,443 Ports - 3os
• Caddy Documentation
• Cloudflare Origin CA Documentation

Conclusion

Setting up Caddy as a reverse proxy on Synology has been a game-changer for my homelab. The ability to access all my services through clean subdomains makes everything feel more professional and easier to remember. While the initial setup requires some work, especially with the certificate configuration, the long-term benefits are worth it.

Update 14/07/25: If you want to access your Docker containers using their LAN IP addresses consistently, regardless of whether we’re connected to our home network or accessing remotely through Tailscale check out this aritcle on Tailscale subnet routers.

$ pod install

❌ ArgumentError - [Xcodeproj] Unable to find compatibility version string for object version `70`.

At the time, I updated CocoaPods to the latest version, confirmed my project format was set to the latest Xcode version (16.3), and tried again. When the issue persisted, I assumed CocoaPods was incompatible with buildable folders and that I would need to migrate to Swift Package Manager (SPM) to use them. This conclusion seemed to be confirmed by several closed GitHub issues where the suggested workaround was to manually convert folders back to groups.

However, it turns out you don’t have to wait to use Xcode’s buildable folders with CocoaPods! The solution is surprisingly simple: set the Project Format in your project’s settings to Xcode 16.0. Any other selection will trigger the Xcodeproj error.

With that single change, you can start taking full advantage of Xcode’s buildable folders in your CocoaPods projects!

References

• Xcodeproj PR #985
• CocoaPods Issue #12671

MeTube is a web GUI for youtube-dl, a command-line tool for downloading videos from YouTube and several hundred other sites.

My goal for this project was to set up automation for downloading YouTube videos directly to my Plex library.

The primary reason is that I can’t trust myself with YouTube Shorts. Once I open YouTube, I’m likely to spend at least a few minutes browsing through them. The simplest solution was to add friction to the process: I removed the YouTube app from all my devices and blocked the domain using my local DNS server.

This worked like a charm. Now, I only visit YouTube every few days to add content that interests me to my Plex library.

You can read more about setting up your own DNS server here.

Prerequisites

• ‼️ Docker must be installed and set up on your system by following the TrashGuides setup for Synology.

This guide assumes you have configured common environment variables like PUID, PGID, TZ, DOCKERSTORAGEDIR, and DOCKERCONFDIR as outlined in the TrashGuides.

Installation Steps

1. Create Required Directories

First, we need to create folders for MeTube’s configuration and downloads. One folder will store MeTube’s application data, and the other will be the destination for your downloaded videos.

SSH into your Synology NAS and execute the following commands:

The commands below assume you’ve followed the linked guide exactly. Adjust paths like /volume1/data/media/youtube and /volume1/docker/appdata/metube if your storage volume or directory structure differs.

• Folder for video downloads (e.g., your Plex library):

  sudo mkdir -p /volume1/data/media/youtube
  

• Folder for the MeTube container’s configuration:

  sudo mkdir -p /volume1/docker/appdata/metube
  

2. Set Permissions

Next, execute the following commands via SSH to configure the correct permissions for the newly created directories:

sudo chown -R docker:users /volume1/data/media/youtube /volume1/docker/appdata/metube
sudo chmod -R a=,a+rX,u+w,g+w /volume1/data/media/youtube /volume1/docker/appdata/metube

This command ensures the docker user has the necessary ownership and read/write permissions.

3. Configure Docker Compose

Append the following service configuration to your main docker-compose.yml file. If you followed the TrashGuides setup, this file is located at /volume1/docker/.

services:
  metube:
    container_name: metube
    image: ghcr.io/alexta69/metube:latest
    restart: unless-stopped
    logging:
      driver: json-file
      options:
        max-file: ${DOCKERLOGGING_MAXFILE:-10}
        max-size: ${DOCKERLOGGING_MAXSIZE:-200m}
    ports:
      - "8081:8081"
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - TZ=${TZ}
      - UMASK=002
      - DOWNLOAD_DIR=/downloads
      - AUDIO_DOWNLOAD_DIR=/downloads
      - STATE_DIR=/config/.metube
      - TEMP_DIR=/downloads/.temp
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - ${DOCKERSTORAGEDIR}/media/youtube:/downloads
      - ${DOCKERCONFDIR}/metube:/config

Note on Environment Variables and Volumes:

• ${DOCKERSTORAGEDIR}/media/youtube maps your Synology’s media download folder to the /downloads directory inside the container. Ensure DOCKERSTORAGEDIR is correctly defined (e.g., DOCKERSTORAGEDIR=/volume1/data).
• ${DOCKERCONFDIR}/metube maps your Synology’s MeTube appdata folder to the /config directory inside the container. Ensure DOCKERCONFDIR is correctly defined (e.g., DOCKERCONFDIR=/volume1/docker/appdata).

4. Start the Container

Navigate to the directory containing your docker-compose.yml file via SSH and run the following command:

docker compose up -d metube

The container will now download the image and start. You can then access the MeTube web interface by navigating to http://<your-synology-ip>:8081 in a web browser.

Check out MeTube’s README for a handy iOS shortcut that allows you share video URLs without opening MeTube!

Troubleshooting

• Port Conflicts: If port 8081 is already in use, change the host port in the ports section of your docker-compose.yml. For example, to use port 8082, modify the line to - "8082:8081".
• Permission Issues: If MeTube reports that it cannot write to the download or config directories, double-check the permissions set in Step 2. Also, verify that the PUID and PGID environment variables correspond to a user with write access to those folders.
• Container Logs: If the container fails to start or you encounter other issues, check its logs with this command:

  docker compose logs metube
  

Resources

• MeTube GitHub Repository
• TrashGuides for Synology Docker Setup

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

Note: This article was originally published 05/2025. Last update 08/2025. Changes:

• Added sockpuppetbrowser to enable Playwright Chromium/Javascript fetch method

Changedetection.io is a powerful open-source tool that monitors websites for changes. It’s incredibly useful for tracking updates on pages that don’t offer their own notification systems. This guide will walk you through setting it up on your Synology NAS using Docker Compose.

Prerequisites

• Docker installed on your system by following the TrashGuides setup for Synology.

Installation

Append this configuration to your docker-compose.yml file. If you’ve followed the guide mentioned above, this file should be located in your Docker application data directory (e.g., /volume1/docker/appdata).

This configuration sets up a changedetection container along with sockpuppetbrowser, which enables you to use the Playwright Chromium/Javascript fetch method. It’s handy in cases where a site requires JavaScript to load. It’s still best to use Basic fast Plaintext/HTTP Client as the default for your change detection watch entries.

  changedetection:
    image: lscr.io/linuxserver/changedetection.io:latest
    container_name: changedetection
    restart: unless-stopped
    logging:
      driver: json-file
      options:
        max-file: ${DOCKERLOGGING_MAXFILE}
        max-size: ${DOCKERLOGGING_MAXSIZE}
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - TZ=${TZ}
      - PLAYWRIGHT_DRIVER_URL=ws://browser-sockpuppet-chrome:3000
    volumes:
      - ${DOCKERCONFDIR}/changedetection:/config
    ports:
      - 5555:5000
    depends_on:
      - browser-sockpuppet-chrome

  browser-sockpuppet-chrome:
    hostname: browser-sockpuppet-chrome
    image: dgtlmoon/sockpuppetbrowser:latest
    container_name: browser-sockpuppet-chrome
    cap_add:
      - SYS_ADMIN
    restart: unless-stopped
    logging:
      driver: json-file
      options:
        max-file: ${DOCKERLOGGING_MAXFILE}
        max-size: ${DOCKERLOGGING_MAXSIZE}
    environment:
      - SCREEN_WIDTH=1920
      - SCREEN_HEIGHT=1024
      - SCREEN_DEPTH=16
      - MAX_CONCURRENT_CHROME_PROCESSES=10

Note on Environment Variables:

• The PUID, PGID, and TZ environment variables above are set consistently with your other containers.

Start the container by running this command in the directory containing your docker-compose.yml file:

docker compose up -d

This command launches Changedetection.io in detached mode, meaning it runs in the background. You should then be able to access it by navigating to http://<your-synology-ip>:5000 in your web browser.

Troubleshooting

If you encounter issues accessing Changedetection.io, try running the container without the -d flag (e.g., docker compose up) to view the live logs directly.

During my initial setup, I discovered that the default host port (5000) was already in use on my Synology. You can resolve such a port conflict by updating the host port (the first number in the ports section) like so:

ports:
  - NEW_PORT:5000 # Example: 5001:5000

The Container Port (the right-hand side of the colon, e.g., 5000 in NEW_PORT:5000) is the port that the application inside the Docker container is programmed to listen on. The Changedetection.io application is configured by its developers to listen on port 5000 within its isolated container environment. Changing this internal container port would require modifying the application’s internal configuration, which is generally more complex and unnecessary for resolving a host port conflict.

Resources

• Changedetection.io GitHub Repository (includes documentation)
• LinuxServer.io Changedetection.io on Docker Hub

Before you start, you should have qBittorrent up and running using this guide.

Implementation

If you’ve used the guide linked above, the qBittorrent container is already running. There are two configuration files that we’ll need to edit: .env and docker-compose.yml.

.env

Make sure the LAN_NETWORK variable is set properly. If you haven’t modified it after the initial setup, it should be set to 192.168.x.0/24. Update it so that your Synology’s LAN IP is within the address range. Example: since my Synology’s LAN IP address is 192.168.1.110, I’ve replaced x with 1: 192.168.1.0/24.

Set VPN_ENABLED to true

Set VPN_PROVIDER to pia

Hotio’s qBittorrent image also supports Proton VPN out of the box. You should be able to use it with any provider that supports the WireGuard protocol.

If you’re using PIA or Proton, set PORT_FORWARD to true.

Add the following variables:

VPN_PIA_USER=YOUR_PIA_USERNAME
VPN_PIA_PASS=YOUR_PIA_PASSWORD
VPN_PIA_PREFERRED_REGION=belgium # optional

Since port forwarding is disabled in some of the regions supported by PIA VPN, you might want to also set VPN_PIA_PREFERRED_REGION. You can see all available regions in docker/appdata/qbittorrent/wireguard/pia-regions.json. This file will be created the first time you run the container after setting your PIA username and password.

docker-compose.yml

Uncomment the devices section in qbittorrent:

devices:
  - /dev/net/tun:/dev/net/tun

Add the following variables to the environment section:

VPN_PIA_USER=${VPN_PIA_USER}
VPN_PIA_PASS=${VPN_PIA_PASS}
VPN_PIA_PREFERRED_REGION=${VPN_PIA_PREFERRED_REGION}

Here’s how your qBittorrent container definition should look:

qbittorrent:
  container_name: qbittorrent
  image: hotio/qbittorrent:latest
  restart: unless-stopped
  logging:
    driver: json-file
    options:
      max-file: ${DOCKERLOGGING_MAXFILE}
      max-size: ${DOCKERLOGGING_MAXSIZE}
  labels:
    - org.hotio.pullio.update=${PULLIO_UPDATE}
    - org.hotio.pullio.notify=${PULLIO_NOTIFY}
    - org.hotio.pullio.discord.webhook=${PULLIO_DISCORD_WEBHOOK}
  ports:
    - ${QBITTORRENT_WEBUI_PORT}:${QBITTORRENT_WEBUI_PORT}
    - ${QBITTORRENT_PRIVOXY_PORT}:${QBITTORRENT_PRIVOXY_PORT}
  cap_add:
    - NET_ADMIN
  devices:                              
    - /dev/net/tun:/dev/net/tun         
  sysctls:
    - net.ipv4.conf.all.src_valid_mark=1
    - net.ipv6.conf.all.disable_ipv6=1  
  environment:
    - PUID=${PUID}
    - PGID=${PGID}
    - TZ=${TZ}
    - UMASK=002
    - VPN_ENABLED=${VPN_ENABLED}
    - VPN_FIREWALL_TYPE=legacy
    - VPN_PROVIDER=${VPN_PROVIDER}
    - VPN_LAN_NETWORK=${LAN_NETWORK}
    - VPN_CONF=wg0-fix
    - VPN_AUTO_PORT_FORWARD=${PORT_FORWARD}
    - VPN_PIA_USER=${VPN_PIA_USER}
    - VPN_PIA_PASS=${VPN_PIA_PASS}
    - VPN_PIA_PREFERRED_REGION=${VPN_PIA_PREFERRED_REGION}
    - VPN_HEALTHCHECK_ENABLED=false
    - PRIVOXY_ENABLED=${QBITTORRENT_ENABLE_PRIVOXY}
    - WEBUI_PORTS=${QBITTORRENT_WEBUI_PORT}/tcp,${QBITTORRENT_WEBUI_PORT}/udp 
  dns:
    - 1.1.1.1
    - 8.8.8.8
  volumes:
    - /etc/localtime:/etc/localtime:ro
    - ${DOCKERCONFDIR}/qbittorrent:/config:rw
    - ${DOCKERSTORAGEDIR}/torrents:/data/torrents:rw

Setting up tun service

/dev/net/tun is a kernel module that provides a network tunnel interface. On Synology NAS systems, it’s used by VPN applications and other networking tools like qBittorrent with VPN functionality.

Installing the Tun Service for Synology and VPN

Testing Changes

With everything done, you need to try running the container with the latest changes: sudo docker-compose up --force-recreate qbittorrent

Here’s a sample output from a successful startup:

qbittorrent  | s6-rc: info: service init-wireguard successfully started
qbittorrent  | s6-rc: info: service service-qbittorrent: starting
qbittorrent  | s6-rc: info: service service-pia: starting
qbittorrent  | s6-rc: info: service service-forwarder: starting
qbittorrent  | s6-rc: info: service service-qbittorrent successfully started
qbittorrent  | s6-rc: info: service service-pia successfully started
qbittorrent  | s6-rc: info: service service-forwarder successfully started
qbittorrent  | s6-rc: info: service legacy-services: starting
qbittorrent  | [INF] [2025-04-12 20:23:44] [PIA] Fetching new forwarded port...
qbittorrent  | s6-rc: info: service legacy-services successfully started
qbittorrent  | [INF] [2025-04-12 20:23:44] [PIA] Forwarded port will expire at [2025-06-14T06:23:44.166007524Z].
qbittorrent  | 
qbittorrent  | *** Legal Notice ***
qbittorrent  | qBittorrent is a file sharing program. When you run a torrent, its data will be made available to others by means of upload. Any content you share is your sole responsibility.
qbittorrent  | 
qbittorrent  | If you have read the legal notice, you can use command line option `--confirm-legal-notice` to suppress this message.
qbittorrent  | 
qbittorrent  | WebUI will be started shortly after internal preparations. Please wait...
qbittorrent  | 
qbittorrent  | [INF] [2025-04-12 20:23:54] [VPN] Forwarded port is [REDACTED].
qbittorrent  | 
qbittorrent  | ******** Information ********
qbittorrent  | To control qBittorrent, access the WebUI at: http://localhost:8080
qbittorrent  | 
qbittorrent  | [INF] [2025-04-12 20:24:04] [QBITTORRENT] Updated forwarded port to [REDACTED].

Troubleshooting

The only issue I’ve encountered was with the /dev/net/tun module. It had overly restrictive permission settings:

ls -al /dev/net/tun
# Overly restrictive; should return `crw-rw---- root root`
crw------- 1 root root 10, 200 Feb 13 02:14 /dev/net/tun

The qBittorrent container needs at least 660 permission. You can fix that by executing:

sudo chmod 660 /dev/net/tun  # Allow root group access

Verifying VPN Works

To verify that the qBittorrent container is hidden behind a VPN, you can use IP/DNS Detect (Torrent Address detection).

Resources

• hotio/qbittorrent

Recently, however, I needed to brush up on Objective-C for a job I was interviewing for.

Below is a list of strategies that helped me quickly get back up to speed with Objective-C in about 6–8 hours. The list is fairly comprehensive—it should refresh your memory and might even teach you something new. That said, if you’re completely new to the language, YMMV.

Language Fundamentals: Objective-C for Swift Developers by Paul Hudson

I can’t recommend this book enough. It’s only 150 pages long and covers a wide range of language features and quirks you’ve likely forgotten—block syntax, anyone?

One tip: have a playground project open in Xcode while you read. If you’re not sure how to create an Objective-C project in Xcode 16, use this guide.

LeetCode Challenges

LeetCode doesn’t support Objective-C directly in its web interface, but that’s not an issue in the age of LLMs!

Since my goal was to refresh my knowledge of basic language features, I focused primarily on easy challenges. By “basic language features,” I mean working with strings, arrays, and simple data structures.

I definitely didn’t want to spend time solving complex problems like counting islands in a binary matrix (looking at you, “Number of Islands II,” problem #305).

I selected a few easy problems and worked through them in Xcode. Claude was particularly helpful in generating test cases to validate my solutions.

Working with Large Codebases

The final exercise was exploring a larger project written entirely in Objective-C. I started with the App Delegate and used an LLM to answer questions about anything that seemed unclear. I focused on understanding how common patterns were implemented—things like singletons, callback-based APIs, and delegate patterns.

Here are some projects I recommend checking out:

• Adium
• A curated list of awesome iOS ecosystem libraries written in Objective-C

That’s it! I was genuinely surprised by how much fun this process turned out to be—and also by how much I’d forgotten about Objective-C. Hopefully, this time around, the block syntax will stick with me longer!

In Xcode projects, you define supported languages at the project level (not scheme level). Because of this structure, each app variant inherits the same language settings.

My task was to force each app variant to support only the language for the region it was released in. The French app should only support French, no matter what the user’s device language is set to, and so on. This decision was made because large portions of the app are web-based and only supported a single language.

Solution

There are multiple ways to solve this problem. What follows is the approach that worked best for my particular use case, given the project’s current structure:

First, create a build configuration file for each of the schemes and define the LOCALIZATIONS_TO_KEEP variable.

LOCALIZATIONS_TO_KEEP = fr

Then, add a new build phase called “Remove unused localizations.” Remember to position it after the “Copy Bundle Resources” build phase:

echo "Keeping only ${LOCALIZATIONS_TO_KEEP}.lproj"
echo "Application .app path: ${CODESIGNING_FOLDER_PATH}"

# Only search in the main app bundle, excluding 
# Frameworks directory and other dependency folders
find "${CODESIGNING_FOLDER_PATH}" -type d -name "*.lproj" \
  -not -path "*/Frameworks/*" \
  -not -path "*/PlugIns/*" \
  -not -path "*/Watch/*" \
  -not -path "*/SwiftPM/*" \
  | grep -v "${LOCALIZATIONS_TO_KEEP}.lproj" \
  | xargs rm -rf

CODESIGNING_FOLDER_PATH is an environment variable used in Xcode build scripts that represents the path to the app bundle being built. It typically points to the directory where the compiled application and its resources are placed before code signing occurs.

You’ll want to exclude locations where third-party dependencies might be located, because you can’t guarantee that they support the same language you want to force the app to use.

You can verify that the script works by navigating to ${CODESIGNING_FOLDER_PATH} in derived data and checking if the script successfully removed all other localization files.

Alternative Solutions

This issue could be solved by setting CFBundleLocalizations and CFBundleDevelopmentRegion IF my project used separate targets instead of separate schemes for different apps.

Alternatively, I could dynamically select Info.plist files for each of the schemes. I opted against this approach since the project already had build configurations defined for each of the schemes.

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.

Since there’s no straightforward way to disable SwiftLint across all local packages in a project, I decided on the simplest solution: automating the process of temporarily commenting out SwiftLint from the dependencies list.

In my projects, to ensure the SwiftLint plugin is automatically added to all package targets, I append the following code to each Swift package manifest:

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

Here’s the shell script I use to comment out SwiftLint across all packages and create a temporary commit. You can add this to your shell configuration file:

Make sure your git working tree is clean before running this script. Otherwise, it will include your existing changes in the commit.

# .zshrc

# Disable SwiftLint
dsl() {
    find . \( -path '*/.*' -prune \) -o -type f -name "Package.swift" -print | while read -r file; do
        sed -i '' 's|plugins.append(.plugin(name: "SwiftLintBuildToolPlugin", package: "SwiftLintPlugins"))|//plugins.append(.plugin(name: "SwiftLintBuildToolPlugin", package: "SwiftLintPlugins"))|' "$file" && \
        echo "Updated: $file"
    done
    git add -A && git commit -m "temp: disable swiftlint"
}

Prerequisites

• Docker installed on your system (follow this Synology setup guide)

Installation

Append this configuration to your docker-compose.yml file:

  homarr:
      container_name: homarr
      image: ghcr.io/ajnart/homarr:latest
      restart: unless-stopped
      logging:
        driver: json-file
        options:
          max-file: ${DOCKERLOGGING_MAXFILE}
          max-size: ${DOCKERLOGGING_MAXSIZE}
      environment:
        - PUID=${PUID}
        - PGID=${PGID}
        - TZ=${TZ}
      volumes:
        - ${DOCKERCONFDIR}/homarr/configs:/app/data/configs
        - ${DOCKERCONFDIR}/homarr/icons:/app/public/icons
        - ${DOCKERCONFDIR}/homarr/data:/data
      ports:
        - 7575:7575

Start the container by running this command in your docker directory (typically /volume1/docker/appdata):

docker compose up -d

This launches Homarr in detached mode (running in the background).

Resources

• Official Homarr Installation Guide

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

Even with killswitch enabled, I wanted to verify beyond the UI’s “Firewalled” status that my torrent traffic was actually routing through the VPN.

To check this, SSH into your Synology NAS and run:

sudo docker exec qbittorrent curl ifconfig.me

This command retrieves the container’s public IP address. If it matches your VPN IP address rather than your real IP, you’ve confirmed that the container’s traffic is properly routing through the VPN.

• Media Server - My Synology stores and serves my entire collection of movies, TV shows, and music. Using Plex, I can stream this content to any device, creating a personalized Netflix-like experience.
• Usenet / Torrent Client - I have the standard *ARR stack setup for managing my media library. I can’t recommend it enough. This suite of apps is a crown jewel of the entire setup.
• HomeBridge - HomeBridge allows me to integrate non-HomeKit devices into my Apple HomeKit setup.
• Time Machine Backup Destination - My Synology serves as a Time Machine backup destination for all my Macs. This is a major improvement over manually connecting external HDDs.
• DNS Server - I run AdGuard Home on my Synology as a DNS server. Similar to Pi-hole, it blocks ads across all devices on my network. You can read more about it here.
• Personal Cloud Storage - While I use iCloud for critical documents, my Synology acts as a personal cloud for miscellaneous files. It’s a great way to keep less important documents accessible without cluttering my primary cloud storage.

In the following sections, I’ll dive deeper into this setup, providing a high-level overview and sharing useful resources that have helped me create this system.

The Initial Setup

Storage Pools / Shares / Volumes

The first question I asked myself when setting up the system was “What volume structure should I use?” Initially, I aimed for complete separation between documents, media, and backups. This approach would have resulted in a single storage pool with three separate volumes.

However, I learned that creating separate volumes doesn’t offer significant advantages in this case (if any). It doesn’t provide any real security benefits. Instead, having separate shared folders with properly set up permissions is more than sufficient. So, unless you have a compelling reason to do otherwise, you should default to a single storage pool with a single volume.

95% of users should use a single SHR pool, with a single BTRFS volume. If you need something else, you’re an advanced user with an unusual use case (or just a big nerd who likes to tinker, even when it’s slightly harmful).

Some people make multiple pools for different RAID levels for different uses, or making a separate pool with surveillance-class drives for their cameras. IMO, it’s not worth that level of control, but it’s available. You must make separate pools for HDDs and SSDs.

There’s even less reason to use multiple volumes on the same pool. All of the backup, permissions, quota, etc. management is done at the shared folder level, so there just isn’t much benefit to multiple volumes, unless you’re hitting the 108TB limit and are forced to.

From the synology community on Reddit

Access Control

All of my shared folders use the default permissions, except for docker. The permissions for this directory are described in detail here. The gist of this setup is that the “docker” user has full access to the “docker” shared folder and nothing else. All other users can access anything except the docker folder.

I have three accounts in total:

• An admin account that I only use when I need to make changes to Synology.
• My personal account, which I use day-to-day. All of my client devices use it to access documents, media, and backups.
• The docker account I mentioned earlier.

Setting up Time Machine

Use this video and you should be good to go.

Docker

I started my Docker setup with this guide as part of setting up the *ARR stack. It goes into detail on how to set it up from the ground up. Once you’re done, it should be fairly easy to build on top of it.

I still haven’t gotten around to setting up automation for updating the containers, so I can’t speak on pullio, the solution suggested in the guide above.

Remote Access

With the initial setup done, it’s time to decide how to access your Synology outside of your home network. In my setup, I wanted to balance security and convenience. That’s why I decided against Synology’s Quick Connect and went with Tailscale. The free tier is more than enough for my needs, and this setup is beautifully simple to configure.

I wrote a separate article on how to set up Plex to work with Tailscale. If you want to learn more about the available options for remote access, this video covers the most popular choices.

Backup

I backup my entire system using the built-in Hyper Backup solution. Here’s a tutorial on how to set it up.

I don’t backup media to save space. In the worst-case scenario of two subsequent disk failures, I’ll still have all of my most important documents intact. The media library should be fairly simple to rebuild.

I have a monthly reminder to connect the external HDD and make a backup. You can configure it so that the external disk will be unmounted when the backup is finished. This makes the process easy and hassle-free. I connect the drive, initiate the backup, and detach it the next morning. You could keep it connected, but I prefer to keep my backup offsite. It’s my final safety net when everything else fails.

Resources

• Practical reasons for having multiple storage pools and volumes : r/synology
• Setting up AdGuard Home on Synology NAS with Tailscale | kunat.dev
• Synology - TRaSH Guides
• How to Backup MacOS to Synology NAS using Time Machine (easy) - YouTube
• Secure Remote Access to Your Synology Plex Server via Tailscale | kunat.dev
• The Complete Guide to Remotely Access Synology NAS - All 5 Options Explained - YouTube
• Do this FIRST - How to Backup Synology NAS to USB Hard Drive (Hyperbackup) - YouTube

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

In this guide, I’ll walk you through the steps to set up AdGuard Home (AGH) as a Docker container on a Synology NAS. This setup will allow you to use AGH both inside and outside of your home network.

AdGuard Home is a network-wide DNS server that blocks ads and trackers for all devices on your network. It filters unwanted content before it reaches your devices, eliminating the need for individual ad blockers. With customizable rules and open-source flexibility, it offers comprehensive protection and can be installed on various platforms, including Raspberry Pi.

Prerequisites

• Basic Docker setup running on your Synology NAS (users, permissions, folders)
  • I highly recommend following the Synology | TRaSH Guides

The following steps assume you have a setup similar (ideally identical) to the one from the article linked above. The most important aspects are user permissions and folder structure.

Configuration

.env:

## Edit/update your settings that will be used for your docker-compose
## This will only work if you follow exactly the path structure in the Guide!
COMPOSE_PROJECT_NAME=trash-guides

## Global Settings
# Change "/volume1/docker/appdata" to your config path
DOCKERCONFDIR=/volume1/docker/appdata
# Change "/volume1/data" to your library + torrent/usenet downloads path
DOCKERSTORAGEDIR=/volume1/data
# Find your PUID/PGID through SSH, run in terminal: id $user
# Change $user to the user you created if needed
PUID=XXXX
PGID=YYY

# Other app-specific settings and variables
# ...

This setup doesn’t use any environment variables specific to AGH. The key thing is to set PUID and PGID correctly.

docker-compose.yml:

version: "3.2"
services:
  adguardhome:
    image: adguard/adguardhome:latest
    container_name: adguardhome
    network_mode: host
    volumes:
      - ${DOCKERCONFDIR}/adguardhome/work:/opt/adguardhome/work
      - ${DOCKERCONFDIR}/adguardhome/conf:/opt/adguardhome/conf
    restart: unless-stopped
    environment:
      - PUID=${PUID}
      - PGID=${PGID}
      - TZ=${TZ}

# Other containers
# ...

Folder structure

Initial Setup

After running the container for the first time, complete the initial AGH setup:

1. When asked to choose the network interface for DNS requests, select “All Interfaces”.
2. Switch the Web Interface port to 3000 if it’s not already set.
3. Set credentials for your admin account.

If you encounter issues, refer to this guide.

Local Network Setup

To use AGH as your DNS server:

1. Set it on your router (preferred method).
2. If router modification isn’t possible, set it manually for each device on your home WiFi network. Here’s a guide for iOS.

Use your Synology’s local network IP address. Update your DHCP settings to ensure your Synology’s local IP address doesn’t expire.

With this setup, you’ll see the benefits of AGH whenever you’re connected to your home network.

Remote Setup

To use AGH when not on your home network, there are several options:

• Dynamic DNS (DDNS) and port forwarding
• Setting up a VPN server on your NAS
• Using Cloudflare Tunnel
• Tailscale (the method used in this guide)

Tailscale is a modern, user-friendly virtual private network (VPN) solution that leverages the WireGuard protocol to create secure, peer-to-peer connections between devices. It simplifies network configuration by eliminating the need for traditional VPN servers and complex firewall rules.

To set up Tailscale:

1. Set custom DNS in Tailscale admin panel (your Synology’s tailnet IP address)
2. Enable “override local DNS”
3. Set up Tailscale on all devices you plan to use outside your home network
4. Set up VPN On-Demand

With these steps, your device will automatically connect to your Tailscale mesh network, which will use AGH as a DNS server.

Cleanup

For Safari users: Consider disabling Advanced Tracking and Fingerprinting Protection, as it can override local DNS settings and interfere with AGH. More details on this issue can be found here.

Note: Client names may not resolve properly due to Docker’s host network mode. If you find a solution to this issue, please share!

Resources

• Install Adguard Home on a Raspberry Pi 4 and enable remote access with Tailscale | Senior Project Manager in Toronto, Ontario | Nicolas Louge
• AdGuard Home + Tailscale = Erase Ads on the Go
• AdGuard Home in Container Manager on a Synology NAS

A few weeks back, I set up AdGuard Home on my Synology NAS. I’ve been using it without any issues inside and outside of my home network thanks to Tailscale. There was one issue with this setup though: battery drainage on all of my mobile devices. I noticed that my battery usage went up by 25% on my phone.

From what I could find, the increased battery usage might have been caused by a few factors:

• Constant network connection: Tailscale maintains a persistent VPN connection
• Encryption overhead: The VPN encrypts and decrypts all traffic, which requires additional processing power
• Background processes: Tailscale might be doing some work in the background

To solve this issue, I decided to update my config so that I use VPN only when I’m not on my home network. My ISP-provided router does not allow me to change the default DNS, so my only option was to manually set it for each device.

Tailscale’s VPN On-Demand feature is just the tool for the job. It allows you to connect to your mesh network only when some specific rules are satisfied. For example, with the following configuration, my phone will connect to the VPN only when I’m not connected to my home network.

This setup worked beautifully. The battery issue was gone. Tailscale worked as advertised. I could still access my server from anywhere. The only issue was that AdGuard Home seemed to not work in private Safari tabs.

My first suspect was Private Relay. I toggled it on and off, but it didn’t fix the issue. The second suspect was the “Prevent cross-site tracking” setting. Still nothing. Finally, I found this thread that pointed me in the right direction. Turns out, the issue was caused by the Advanced Tracking and Fingerprinting Protection setting located in Advanced settings. Turning it off fixes the issue instantly.

iOS

macOS

Resources

• iOS 17 private browsing overrides DNS - Apple Community

Prerequisites

• Have a Plex server running as a Docker container using this guide. When you’re done, you should have a docker-compose.yml and a .env file with all your environment variables.
• Have Tailscale set up and running on your Synology. You can use this guide.

Make sure to disable the expiry for the IP address assigned to your Synology NAS in the Tailscale dashboard.

Steps

1. Set PLEX_ADVERTISE_URL (in the .env file) to your Synology IP address in the Tailscale dashboard and your local network IP address:

## PLEX
# ... other keys
PLEX_ADVERTISE_URL="http://ds1512p:32400,http://192.168.0.186:32400"

Remember to include port numbers in both IP addresses!

2. Restart the Plex container using the latest changes:

sudo docker-compose up --force-recreate plex

3. Check if the changes have been applied successfully. “Custom server access URLs” should be set to $PLEX_ADVERTISE_URL.

Summary

That’s it! With the above setup, you should be able to connect to your Plex server from your local network as well as from anywhere, as long as you’re connected to Tailscale.

Resources

• How to run Plex through Tailscale

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.

Ideally, I’d completely delete it from my phone, but I still need it for texting. It’s borderline impossible to convince some of my friends to switch to a different platform. Also, some of Instagram’s messaging features are just nice to have.

Learning from experience, the second-best option in this type of situation is to add friction to the process. Having Reels one click away each time I open the app is way too tempting. Since I’m only ever using it to text people, it would be nice to have it open directly on the Messages screen.

How do I get a complete list of deep links the Instagram iOS app supports?

My initial plan was to jailbreak an iPhone, export the Instagram app, and then use a disassembler like Hopper to inspect the binary. On paper, the binary should contain all the supported deep links. It was only a matter of finding them. And learning how to jailbreak devices. And learning how to work with a disassembler. Seems like a lot of work for a simple shortcut, doesn’t it?

“Why don’t you use /.well-known/apple-app-site-association?” a friend of mine suggested after I shared what I was working on. Even though I was well aware of it, this didn’t come to my mind when looking for solutions.

The /.well-known/apple-app-site-association is a file used in iOS app development to configure Universal Links. Universal Links allow iOS apps to link directly to content within the app using standard HTTPS URLs, providing a seamless user experience by opening the app directly instead of a web page when the app is installed.

This was the perfect tool for the job. After inspecting the file, finding the right deep link was trivial. Long story short, here’s the final shortcut:

Instagram DMs | iCloud Shortcuts

Lesson learned: When something seems like over-engineering, it probably is.

I hope this helps some of you to reduce the number of times you start mindlessly scrolling because you couldn’t resist watching just a few reels before checking your messages!

Resources

• https://www.instagram.com/.well-known/apple-app-site-association
• Supporting associated domains | Apple Developer Documentation

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.

After some exploration and experimentation, I discovered that Hugo automatically generates RSS feeds for each tag. TIL! Here’s how you can access these tag-specific RSS feeds:

• iOS Tag Feed: https://kunat.dev/tags/ios/index.xml
• Swift Tag Feed: https://kunat.dev/tags/swift/index.xml
• Utils Tag Feed: https://kunat.dev/tags/utils/index.xml

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

Last week, I was working on extracting functionality responsible for handling Live Activities into a separate Swift Package Manager (SPM) package. Apple introduced Live Activities with the release of iOS 16.1. My project’s deployment target is currently set to iOS 13. As you can imagine, this feature had lots of #if available checks.

To make my life a bit easier, I’ve decided to set my package’s deployment target to iOS 16.1. On paper, this (in combination with #if canImport()) would allow me to get rid of all the availability checks spread around my codebase.

The Initial Plan

My plan was to do something like the following:

// Package.swift
let package = Package(
    name: "SportsWidgets",
    platforms: [.iOS("16.1")],
    products: [ /*...*/],
    dependencies: [/*...*/],
    targets: [/*...*/])

// MyProject.app
#if canImport(SportsWidgets) 
import SportsWidgets 
#endif

This sadly doesn’t work as Xcode won’t see your package as one of the available packages.

Solution

The workaround is to fork the dependency, lower the deployment target so that it’s less than or equal to your project’s deployment target and manually convert its deployment targets into @available conditions throughout its source files.

Resources

• Using Swift Package with minimum deployment target greater than target project’s
• How does #if canImport(…) determine what can be imported?

NextDNS: The Game Changer

NextDNS turned out to be a game-changer for several reasons. First of all, it’s fairly cheap. The pro plan costs around $2 a month and the free plan is more than enough to try out this product. The setup couldn’t be easier. They offer a few different ways to set it up on all of your devices. The final thing is reliability. I’ve been using NextDNS on all of my personal devices for the past six months without encountering any issues. It almost sounds too good to be true.

For those of you who value community endorsements, NextDNS receive a seal of approval form the HackerNews crowd.

In short, NextDNS ticked all of the boxes for what I had been searching for in a content blocker.

Breaking Bad Habits

While I initially started using NextDNS as an ad blocker, it unexpectedly became a tool to help me break a bad habit. Until recently, I was compulsively browsing websites like LiveLeak just to kill time. It started affecting my productivity. NextDNS came to rescue with its parental control features.

With NextDNS, it’s possible to block specific websites or entire categories of sties, such as Dating or View Streaming. Now, you might wonder why I didn’t simply use Apple’s Screen Time for this purpose. The answer is friction. With Screen Time, it’s only a matter of two clicks before you can extend your limit by 15 minutes or turn it off completely for the day. For this use case, Screen Time is just too easy to disable.

I do use Screen Time for blocking apps. In order to keep myself accountable, I use Streaks App. You can read more about how I use Streaks here.

I’ve added friction to the process by blocking relevant sites, enabling 2FA, and storing recovery codes safely, just out of reach from my desk. It’s simple but effective. Thanks to NextDNS, I’ve successfully conquered a bothersome habit for 138 consecutive days!

Conclusion

NextDNS exceeded my expectations as a content blocker and helped me break a longstanding bad habit. Its affordability, user-friendliness, reliability, and bonus features make it a must-have for improving your online experience and taking control of digital habits. I highly recommend trying NextDNS!

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.

Some test coverage report generation tools do not support “pure” Swift packages. One example is Slather. By pure, I’m referring to packages that contain only the Package.swift file, without any .xcodeproj or .xcworkspace files.

One solution to this problem was to generate a project file for a Swift package on the fly using Fastlane. This solution has one limitation: it’s not possible to generate a project file for a Swift package that contains any resources. When you try doing so, you’ll see Type 'Bundle' has no member “module” error when building.

Solution

What worked was using Fastlane with xcov. Here’s a snippet:

scan(
  package_path: ".",
  # Schemes generated by Xcode have a "-Package" suffix
  scheme: "MyPackage-Package",
  clean: true,
  device: "iPhone 14",
  code_coverage: true,
  result_bundle: true
)
xcov(
  is_swift_package: true
)

Here’s how the xcov output looks like:

+----------------------+--------+
|[32mxcov Coverage Report[0m    |
+----------------------+--------+
| MyPackage            | 13.75% |
| MyPackageTestUtils   | 0.00%  |
| MyPackageTests       | 22.12% |
| Average Coverage     | 11.96% |
+----------------------+--------+

The final piece of the puzzle is displaying the test coverage on the MR page like so:

In order to do that, we’ll need a regex to parse output from xcov. In this case we’re only interested in getting the percentage right beside “MyPackgae”. Here’s a snippet from the .gitlab-ci.yml file:

unit_test:
  stage: tests
  script:
    - bundle exec fastlane unit_test
  coverage: '/\|\s+MyPackage\s+\|\s+\d+\.\d+\%\s+\|/'

Resources

• Support for SPM package projects in fastlane scan
• Code coverage for Swift Packages with Fastlane
• Support for SPM package projects in fastlane scan
• Code coverage | GitLab Docs

What came to my rescue was the Banker on Wheels blog. I did not find any other resource that came even close to this one. It was a one-stop shop for my use case. In less than a month, I’ve collected more than enough knowledge to create a portfolio based on my current needs and risk profile.

What worked for me was starting with the Portfolio Construction Investing Guide and reading all the linked materials. It took me about 20 hours to empty my reading list. After that, I was set on my goals and expectations for my portfolio.

Portfolio Breakdown

You can see my portfolio breakdown below. Keep in mind that my current investment horizon is 7+ years.

Resources

• ⭐️ Banker on Wheels
• /r/Bogleheads/
• Trackinsight - ETF screening and comparison tool
• ChatGPT

I can’t explain how helpful ChatGPT was for me over the past month. Discovering a new domain can be intimidating. The vast array of unfamiliar terms, tools, and acronyms can quickly accumulate, making it challenging to navigate through the intricacies of a new field. ChatGPT has made this experience a slightly smoother journey.

tl;dr

Goal: maximize returns while spending the least possible amount of time managing the investment portfolio.

Problem: My knowledge of this topic is very basic. The fact that most resources are aimed at US-based investors does not help.

Solution: Banker on Wheels

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!

Development Assets in Xcode that allow developers to provide test data to use within SwiftUI previews and other code during development. Assets marked for development will only be included in debug builds and removed once you create an archive of your app. This solution is preferred to having larger assets in the production binary size. Developers can add different types of data as Development Assets, such as JSON files for mocked network requests, images to use in SwiftUI previews, Core Data sample databases, and Swift files representing mocked or sample data. Swift files are added differently because they use the dead code stripper to avoid the compiler from failing during archiving.

To define development assets through the XcodeGen config file, use DEVELOPMENT_ASSET_PATHS:

name: MySampleApp
options:
  bundleId: com.example.MySampleApp
  deploymentTarget: 14.0
  organizationName: Example, Inc.
  developmentLanguage: swift
  useTabs: true
  indentWidth: 4
  tabWidth: 4
  swiftVersion: 5.5
  carthageBuildPath: Carthage/Build/iOS

targets:
  - name: MySampleApp
    type: application
    platform: iOS
    deploymentTarget: 14.0
    sources: 
      - path: MySampleApp
    settings:
      ENABLE_BITCODE: NO
      SWIFT_OPTIMIZATION_LEVEL: -Onone
      SWIFT_ACTIVE_COMPILATION_CONDITIONS: DEBUG
      DEVELOPMENT_ASSET_PATHS: 
         Dashboard/PreviewAssets
         List/Views/PreviewAssets
// ...

Resources

• Development Assets in Xcode to enrich SwiftUI Previews
• SwiftUI Preview Data

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.

However, after some time, you might encounter problems like increased complexity, difficulty with integration testing, or code duplication. Today we’ll focus on the last one, specifically, testing doubles duplication. Let’s jump in!

Introduction

When saying “module” I’m always referring to a group of related targets. One example would be DomainModels and DomainModelsTests. The DomainModels target stores the implementation, while DomainModelsTests has unit tests code.

In the sample project for this article, we have the DomainModels package with a single module: DomainModels. Apart from that, we have the FeatureModules package with multiple modules. High-level structure of this setup looks like this:

├── DomainModels
│   ├── DomainModels
│   └── DomainModelsTests
└── FeatureModules
    ├── Dashboard
    ├── DashboardTests
    ├── AccountOverview
    └── AccountOverviewTests

All modules in the FeatureModules package depend on the DomainModels module. Because of that, both DashboardTests and AccountOverviewTests will likely have some duplicate testing doubles. This is not ideal.

There are many possible solutions to that problem. The one that I like the most is creating a separate target in the module just for storing all of its testing doubles. Let’s implement it!

Solution

The solution is fairly simple. We’ll just add the third target to the DomainModels module: DomainModelsFakes and move all the testing doubles from feature modules there.

Although the TestingDoubles postfix may be more appropriate for these modules, I prefer the term Fakes as it conveys the same meaning and is shorter. This choice becomes more practical when considering that there will likely be a significant number of these modules.

With this new addition, the DomainModels module consists of three targets:

• DomainModels
• DomainModelsTests
• DomainModelsFakes

Here’s the package definition:

// swift-tools-version: 5.7
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "DomainModels",
    platforms: [.iOS(.v16), .macOS(.v13)],
    products: [
        .library(
            name: "DomainModels",
            targets: ["DomainModels", "DomainModelsFakes"]),
    ],
    dependencies: [],
    targets: [
        .target(
            name: "DomainModels",
            dependencies: []),
        .target(
            name: "DomainModelsFakes",
            dependencies: ["DomainModels"]),
        .testTarget(
            name: "DomainModelsTests",
            dependencies: ["DomainModels", "DomainModelsFakes"]),
    ]
)

The new target DomainModelsFakes depends on the DomainModels target. We also need to add it as a dependency to the test target to use the testing doubles.

With those changes in place, we can now add DomainModelsFakes as a dependency to feature modules testing targets:

// swift-tools-version: 5.7
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "FeatureModules",
    platforms: [.iOS(.v16), .macOS(.v13)],
    products: [
        .library(
            name: "FeatureModules",
            targets: ["Dashboard", "AccountOverview"]),
    ],
    dependencies: [
        .package(path: "../DomainModels"),
    ],
    targets: [
        .target(
            name: "Dashboard",
            dependencies: [
                .product(name: "DomainModels", package: "DomainModels"),
            ]),
        .testTarget(
            name: "DashboardTests",
            dependencies: [
                "Dashboard",
                .product(name: "DomainModelsFakes", package: "DomainModels"),
          ]),
        .target(
            name: "AccountOverview",
            dependencies: [
                .product(name: "DomainModels", package: "DomainModels"),
            ]),
        .testTarget(
            name: "AccountOverviewTests",
            dependencies: [
                "AccountOverview",
                .product(name: "DomainModelsFakes", package: "DomainModels"),
          ]),
    ]
)

Conclusion

As our project grows, we may encounter problems such as code duplication, which can lead to increased complexity and difficulty with integration testing. In this article, we focused on the issue of testing doubles duplication and provided a solution to address it by creating a separate target in the module to store all testing doubles. By implementing this solution, we can reduce code duplication and improve the maintainability of our codebase. Do let me know if there are any other solutions worth trying out!

Resources

• “Fewer, Smarter, Faster: Scaling Testing @Spotify” by Vivian Santos & Sami Bouchebaba This talk is the where I’ve found this idea. See the video around 12:00 minute mark.
• TestDouble

The book has changed the way I think about technical debt and how to communicate it upwards. It provides sound advice on various topics, including how to fight tech debt, schedule maintenance work, and communicate with stakeholders. I have not come across any other book that provides this much credible advice on the topic of technical debt without exclusively catering to a particular audience.

Takeaways

Fixing the wrong thing is bad, but leaving an unfinished attempt at fixing it is worse. Incomplete initiatives lead to confusing, poorly documented, and difficult-to-maintain systems. If you’re intervening early enough that the team hasn’t made significant changes yet, it’s advisable to halt their efforts.

Occasional outages and system issues, particularly if they’re resolved quickly and efficiently, can actually increase user trust and confidence.

Future-proofing systems doesn’t entail building them to avoid the need for redesigns or migrations, as that’s impossible. Instead, it means constructing and, more importantly, maintaining systems to prevent lengthy modernization projects that disrupt normal operations. The key to future-proofing is to make migrations and redesigns routine tasks that don’t require a significant effort.

The more often engineers perform a task, the better they become at it, and the more likely they are to remember that they need to do it and plan accordingly.

It’s not necessary to design for scale until you have the scale you need.

We are more productive when we can devote more time to work tasks. When we finish work tasks, any leftover time can be devoted to reducing our technical debt.

Legacy systems may seem like dead-end work to many software engineers, but the truth is that systems that aren’t used get shut down. Working on legacy systems is vital because they control millions of people’s lives in countless ways. It’s not janitorial work, but rather that of a battlefield surgeon. It has been an immense privilege to work among them.

Assumptions

Before we get started, let’s make a few assumptions about your project and its structure:

• You’re working on a project where modularization is done using SPM.
• You have an SPM package that depends on other packages.

Here’s how my project structure looks like:

Connecting Internal Dependencies

To connect the internal dependencies in your Package.swift file, you need to specify the dependencies for your package and the dependencies for your targets. Here’s an example Package.swift file that configures the FeatureModules package with its internal dependencies:

// swift-tools-version: 5.7
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "FeatureModules",
    platforms: [.iOS(.v16), .macOS(.v13)],
    products: [
        .library(
            name: "FeatureModules",
            targets: ["Dashboard"]),
    ],
    dependencies: [
        // Dependencies declare other packages that this package depends on.
        // .package(url: /* package url */, from: "1.0.0"),
        .package(path: "../DomainModels"),
        .package(path: "../Resources"),
        .package(path: "../Shared"),
        .package(path: "../Storage"),
    ],
    targets: [
        .target(
            name: "Dashboard",
            dependencies: [
                .product(name: "DomainModels", package: "DomainModels"),
                .product(name: "Resources", package: "Resources"),
                .product(name: "Shared", package: "Shared"),
            ]),
        .testTarget(
            name: "DashboardTests",
            dependencies: [
                "Dashboard",
                .product(name: "Storage", package: "Storage"),
          ]),
    ]
)

Conclusion

Connecting internal dependencies in Swift Package Manager is a crucial step when working on modularized projects. By properly configuring the Package.swift file and specifying the dependencies, you can ensure that your code compiles and runs without any issues. Remember to use the .product declaration when specifying dependencies in your target, and to make sure that the package paths are correctly set in the Package.swift file. By following these steps, you can maintain a well-organized project structure and increase code reusability across your codebase.

Resources

• Episode #171: Modularization: Part 1 | Point-Free
• Episode #172: Modularization: Part 2 | Point-Free
• Modularize an iOS App With SPM | Better Programming

As a Mac user, I have always felt secure knowing that my data is protected with APFS encryption. However, that sense of security was shattered when I was unable to mount a disk and Disk Utility reported it as corrupted. I couldn’t use Disk Utility’s First Aid as it failed to repair the disk. Here is the story of how I recovered a corrupted encrypted APFS drive.

Trying out Open-Source Solution

I knew about paid solutions for data recovery, but I wanted to try looking for open-source solutions. I found a few candidates, including Afro, a file recovery tool for APFS on GitHub. Unfortunately, none of them worked, and I was left with no viable solution.

Avoiding the $99 fee

There are a handful of apps that can recover files from encrypted APFS drives, but most of them cost around $99. I tried using trials of some of the most popular tools like R-Studio, but I was unable to fit all the files I cared about in the free trial quota.

Solutions

Right when I was about to give up and pay the $99 fee when I accidentally found a solution. Disk Drill is part of Setapp, a subscription-based service that provides access to a collection of curated apps for Mac users. You can sign up for a free week trial and recover all your files using Disk Drill Pro. With Disk Drill, I was able to recover all my files without any issues.

Conclusion

In conclusion, recovering a corrupted encrypted APFS drive can be a daunting task, but there are viable solutions available. While open-source solutions may seem tempting, they may not always work. Paid solutions can be expensive, but Setapp provides a more affordable option with access to a variety of useful apps, including Disk Drill.

tl;dr Sign up for a Setapp and use Disk Drill to recover your files for free.

Before we start, I wanted to mention that I’m deep into the Apple ecosystem. Some of the tools I’ll discuss might be Apple-specific, but I’m sure there are alternatives on other platforms. With that out of our way, let’s jump in!

High-level overview

My productivity system revolves around three key tools: Notes, Reminders, and Streaks. Each of these serves a unique purpose and works together in harmony. In the following sections, I’ll provide a brief overview of each tool and share some of the most effective ways I use them in my workflows.

Reminders

For over a decade, I have relied on Apple’s Reminders app to keep track of my tasks. Although I’ve been curious about Todoist, I have yet to find a compelling reason to switch. In my Reminders workflow, I organize my tasks into four distinct lists:

I use four lists to group my TODO items:

• General: This serves as the default list for all new reminders, many of which are created by Siri. I make sure that every item on this list is immediately actionable.
• Remember: I use this list to store all items scheduled for the future that are not yet actionable. By keeping these items separate from my immediate to-do list, I can maintain a clear mind and focus on the tasks at hand.
• Work: This list is a duplicate of the Remember list but exclusively for work-related tasks. I use it to manage my 9-5 job responsibilities.
• Scheduled: This list contains all recurring reminders, such as daily, weekly, or yearly tasks. By keeping them in a separate list, I can easily track their progress and ensure that they are completed on time.

Shortcuts

Linking my reminders to Shortcuts has vastly improved my day-to-day experience with the Reminders app. This integration allows for triggering shortcuts using URL schemas on iOS, iPadOS, and macOS (watchOS is not currently supported). You can learn more about it here . There are several instances where Shortcuts integration perfectly fits my workflow. Here are a few examples:

• One of my daily reminders is to measure my weight in the morning. The linked Shortcut logs a sample for the Health app and marks the appropriate task in the Streaks app (more on that in the next section). The use-case is simple and saves me a few clicks every day.
• Last year, I made meditation a daily habit. In this case, the shortcut starts a 20-minute timer, sets my Focus Mode to Do Not Disturb, and opens my daily session in my meditation app. Currently, I am using Waking Up , but all other major meditation apps also support shortcuts to some extent. Again, this shortcut is simple and saves me a few clicks. Starting my mindfulness session is always one click away! All other use cases follow the same pattern. As of now, I have eight recurring reminders that have a linked shortcut. Give it a try, it’s amazing!

Siri

Siri might not be the smartest voice assistant, but she does a great job scheduling reminders.

For me, there’s almost no time where I don’t wear my AirPods, or there is not HomePods around. Siri is available to me all the time. That’s why I started making a good use out of her.

There are a few most common scenarios

• Adding unscheduled things, like groceries: I often notice that I’m running low on something while cooking. The easiest solution is to ask Siri to create reminder for me.

“Hey Siri, remind me to buy cereal.”

• Adding scheduled items that need to be taken care of this day:

“Hey Siri, remind me to order X in 1 minute.” This way, when I’m back at my desk, I have my TODOs list ready.

Streaks

Streaks app is one of my favorite pieces of software I use daily. It’s my first step when creating new habits, breaking bad ones or maintaining the good ones.

Streaks is the to-do list that helps you form good habits. Every day you complete a task, your streak is extended.

Most times, I maintain 12-18 habits. What I found to work the best is to keep a list of 12 TODOs and 6 TODONTs max. Anything else than that feels overwhelming. The time to complete for each streak varies. The shortest ones (e.g. “Take Meds”) take a few seconds, while others (e.g. “Practice LeetCode Challenges”) take up to 45 mins.

Notes

Notes are the final piece of the puzzle for me. I use them to store everything that doesn’t fit into Reminders or Streaks. I use them for daily plannings, weekly retorts, planning projects, storing information about things, and many others. In the following sections I’ll describe some of my most common use cases.

I won’t cover my high level system for organizing notes in this article. Maybe next time! I’ll say that I follow the PARA methodology. You can learn more about it in the Building a Second Brain book.

App

I’ve been a Bear Notes user for about three years. It’s not perfect, but it gets the job done. Despite its quirks, I enjoy using it. If Was I starting today, I’d consider using Obsidian. It has some features I miss in Bear Notes, but it’s still far from getting me to move all my notes there.

Notion was never an option for me because of the proprietary file format. I like to keep my notes in Markdown.

Daily TODOs

That’s how I start my day. I have a note titled “✅ TODO ✅” where I put all my TODOs for the day. I usually split them into two sections: work-related and everything else. Here’s an example day:

## 16/02/2023
::Finished writing My Productivity Setup:: // 1-line summary of the day
// First section: work-related tasks
- [ ] Follow up with sam about missing translations
- [ ] Review open PRs

// Second section: everything else
- [ ] Finish writing My Productivity Setup
- [ ] Pay bills

Backlog

For tasks that do not have a specific deadline, I maintain a separate note titled “Task Backlog.” It contains two sections where I group all the tasks that I might consider doing in the future. From past experience, I know that many of these tasks remain incomplete. To avoid clutter, I purge this list every few months.

Retros

A few years ago, I began conducting yearly retrospectives where I would summarize the past year in a few paragraphs. These retrospectives helped me identify my biggest accomplishments, failures, and overall reflections on the past year. I found them to be a great way to assess my progress towards achieving my goals. However, I realized that more frequent retrospectives might be beneficial. With a yearly schedule, I often forgot about the goals I had set for myself. To address this, I now conduct weekly retrospectives that take no more than 15 minutes each Sunday. Here’s the note template that I use:

# 2023 7/52 // year and week number

## Top Priority
* 

### Success factors
* 

## Biggest Wins
* 

## Last Week Reflection
* 

Top Priority

Your weekly goal can be anything you want it to be. It can be a system or a specific objective. The only requirement is that it needs to be achievable within a week. If a given task cannot be completed within a week, I try to break it down into smaller assignments. Here are a couple of examples from previous weeks:

• Dedicate four hours to a side-project
• Write a book review for TITLE
• Learn a new skill or take an online course

The possibilities are endless.

Success Factors

ChatGPT:

Success factors are the key elements or variables that contribute to achieving a desired outcome or goal. These factors can be internal or external to an individual, organization, or project, and may vary depending on the context and the specific goals being pursued.

Biggest Wins

As the name suggests, this section is dedicated to listing my most significant achievements from the past week.

Last Week Reflection

This section serves as a catch-all for my thoughts and experiences over the past week. I typically spend a few minutes jotting down everything that has been on my mind and then expand on those ideas. Personally, I find this exercise to be quite therapeutic.

Resources

• Building a Second Brain book

Conclusion

That’s it! That’s the high level overview of my productivity setup.

I’m currently developing a chat-based app that requires the implementation of coping messages. Essentially, when a user long-presses a message bubble, an edit menu will appear with the option to “Copy.” This feature is a common element across most chat applications.

For the purpose of this article, let’s assume that all message bubbles are constructed using a subclass of UITextView called MessageTextView. To make the “Copy” option appear on a long-press gesture, we’ll first need to add the appropriate gesture recognizer:

let textView = MessageTextView()
let longPressGesture = UILongPressGestureRecognizer(
    target: self, 
    action: #selector(handleLongPressGesture(recognizer:)))
textView.addGestureRecognizer(longPressGesture)

@objc
func handleLongPressGesture(recognizer: UIGestureRecognizer) {}

Next, we’ll move on to the second step, which involves implementing the handleLongPressGesture method:

// 1
guard recognizer.state == .began,
      let recognizerView = recognizer.view,
      let superview = recognizerView.superview else { return }
// 2
textView?.becomeFirstResponder()
// 3
UIMenuController.shared.showMenu(from: superview, rect: recognizerView.frame)

Let’s now break down the steps necessary to implement this feature:

1. First, we need to obtain the recognizerView and its parent view from the recognizer. We’ll need both of these to properly position the edit menu on the screen.
2. Next, we’ll make the edit menu the first responder to ensure that it appears on the screen.
3. Finally, we’ll show the menu.

Note that at this point, all available options will be displayed, so we still need to filter out any unnecessary edit menu options. To do this, we’ll need to override two methods in our MessageTextView:

override public func canPerformAction(
    _ action: Selector, 
    withSender sender: Any?) -> Bool {
    // 1
    action == #selector(copy(_:))
}

@objc
override public func copy(_ sender: Any?) {
    // 2
    UIPasteboard.general.string = text
}

1. We filter out all other options, except for “copy”.
2. As per Apple’s documentation:

UIKit calls this method when the user selects the Copy command from an editing menu. Your implementation should write the selected content to the pasteboard without removing the selection from your interface.

At first glance, it may seem like we’ve completed the implementation of this feature. However, there’s one more detail that we need to address. Currently, if the keyboard is visible on the screen, the edit menu will be displayed in the wrong location. This occurs because we’re calling showMenu(from:rect:) while the keyboard is still visible. Once the keyboard hides, the layout of the conversation view (i.e. the screen where all the messages are displayed) will likely change.

Handling keyboard events

One solution to present the edit menu without hiding the keyboard is by using the UIResponder.next property, as described in this article. However, in my case, this is not feasible due to the modular architecture of the app I’m working on. The message composer (the view where the user composes a message) and conversation view (the view where all the message bubbles are displayed) are separate modules, and iOS doesn’t provide an easy way to obtain a reference to the current first responder.

Therefore, I found that the best solution for this scenario is to listen for the UIResponder.keyboardDidHideNotification and update the edit menu accordingly. To implement this in MessageTextView:

// Text view subclass
NotificationCenter.default.addObserver(
    self,
    selector: #selector(handleKeyboardDidHideNotification(notification:)),
    name: UIResponder.keyboardDidHideNotification,
    object: nil)

@objc
fileprivate func handleKeyboardDidHideNotification(notification: Notification) {
     UIMenuController.shared.update()
}

Conclusion

That’s it! The edit menu will update its position when keyboard hides.

Notes

• UIMenuController has been deprecated in iOS 16. See UIEditMenuInteraction.
• Remember to check out Using the UIMenuController and Manipulating the Responder Chain

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