• Watching stock or crypto price dashboards
• Testing local development changes
• Waiting on sneaker or ticket drops
• Refreshing sports scores during a game

Eventually you ask yourself why you’re manually doing this.

Since Safari doesn’t offer a native way to reload a page every X seconds, automatic refresh on macOS, iOS, or iPadOS requires a Safari extension — and this post walks through how to set that up and get pages auto-reloading properly.

The Cleanest Way to Auto-Reload Safari Pages

I built a small Safari extension called Auto Reloader — Page Refresh that does exactly this.

Auto Reloader: Page Refresher App - App Store

It works across:

• macOS
• iOS
• iPadOS

Same extension. Same behavior. Just installed once per device.

How to Auto-Reload a Page in Safari

1. Install the app from the App Store.
2. Open Safari.
3. Go to Settings → Extensions and enable Auto Reloader.
4. Click the extension in the toolbar.
5. Set a refresh interval.

That’s it.

The current tab will reload automatically at your chosen interval.

Who Actually Needs Safari Auto Refresh?

This isn’t a novelty feature. It’s for moments where you’re stuck manually refreshing the same page over and over.

Traders Watching Live Dashboards

Some market pages don’t push updates in real time.
Order books lag. Portfolio pages cache. Charts stall.

So what do you do? You sit there hitting refresh.

Auto Reload keeps the page current without you babysitting it.

Developers Testing Local Changes

If you’re working on:

• localhost
• staging builds
• CSS/layout tweaks
• dashboards that poll instead of push

Sneaker and Ticket Drop Monitoring

Limited drops usually come down to timing.

If a product page does not automatically update inventory or release status, refreshing every few seconds can matter.

Automating that refresh removes one more manual step.

Sports Score Refresh During Games

Some sports sites do not live update without interaction. If you’re watching a score page during a game, automatic refresh keeps it current without touching the screen.

Why Use Safari Instead of Switching Browsers?

You could install a Chrome extension, but if you prefer Safari for:

• Native performance
• Lower battery usage
• iCloud tab sync
• Apple ecosystem integration

It makes more sense to add auto refresh directly to Safari rather than switching browsers just for one feature.

Common Questions

Can I set different refresh intervals?

Yes. You can choose a custom interval for the current tab. For example, you might refresh every 5 seconds for a live dashboard and every 60 seconds for something less time-sensitive.

Does it work per tab?

Yes. The refresh setting applies to the specific tab where you enable it. Other tabs remain unaffected unless you turn it on there as well.

Does it stop when I close the tab?

Yes. Once the tab is closed, refresh stops automatically.

Is my data tracked?

No. The extension does not require accounts, logins, or analytics. It runs locally within Safari.

Does it work on any website?

It works on standard web pages loaded inside Safari. Most dashboards, storefronts, news pages, sports pages, and development environments work as expected.

Will this drain battery?

Because it runs as a lightweight Safari extension and only reloads at the interval you choose, usage depends on how aggressive your refresh timing is. Longer intervals naturally use less battery and network activity.

If you find yourself refreshing the same page more than a few times in a row, that’s usually a sign.

Safari won’t automate it for you.
Auto Reloader will.

Set the interval once. Let it run. Move on.

👉 Download Auto Reloader on the App Store

Originally published at https://digitalbunker.dev on February 27, 2026.

See which branch your simulator is actually running.

Even before AI coding, I’d often have multiple copies of the same project open-using git worktrees or separate clones-to work on different branches in parallel.

Now, with multiple Claude Code sessions running at once, each doing work on a different branch, that setup is even more common.

The result is multiple simulators running at the same time, all looking identical, with no clear way to tell which branch any of them is actually running. SimTag fixes that.

What SimTag Does

SimTag adds a small, unobtrusive overlay to each iOS Simulator window showing the branch that build came from.

That’s it.

When you glance at a simulator, you immediately know what you’re looking at. No more wondering:

• Did I rebuild after switching branches?
• Which Simulator has the auth changes?
• Am I debugging my own work or a coworker’s branch?

If you do any kind of parallel development — worktrees, PR reviews, or AI-assisted coding — this removes a constant source of confusion.

SimTag is especially useful for power users running parallel workflows. If you use git worktrees, multiple clones, or have several AI coding sessions (e.g. Claude, Codex) building to different simulators, you’ll always know which Simulator is running which branch.

But even if your workflow is simpler, SimTag still helps. A quick glance confirms the Simulator matches the branch you think you’re on. The “Pending Build” indicator catches “forgot to rebuild” moments by warning you when commits exist since the last build. During PR reviews, it acts as a sanity check-you’ll know for sure you’re testing your colleague’s code, not your own.

The overlay is unobtrusive and easy to ignore-until you need it.

Features

Branch overlay
See the git branch for every simulator window at a glance.

Pending build indicator
SimTag detects when you’ve made commits since the last build. A small warning dot tells you the running app might be stale-no more debugging code that isn’t even in the build.

Custom labels
Add your own text to the overlay. Useful for marking simulators as “PR Review”, “Testing”, or whatever helps you stay oriented.

Details

• macOS 13+
• Requires Screen Recording permission (used only to track window positions-not to record anything; setup is guided on first launch)
• Runs in the menu bar
• Optional launch at login
• Overlay position is configurable (any corner, top/bottom center)

I use SimTag every day now. It’s one of those tools you don’t think about-until it’s missing.

Download:

https://aryamansharda.gumroad.com/l/sim-tag

Getting Started

1. Download SimTag
2. Move the application to the Applications folder.
3. Launch and allow Screen & System Audio Recording permissions (System Settings → Privacy & Security → Screen & System Audio Recording).
4. Grant file access permissions when prompted.

FAQ

Multiple Xcode projects open?
SimTag figures out which project produced each specific simulator build.

React Native / Flutter?
Works fine. SimTag detects the git branch of whatever Xcode project built the app.

Git worktrees?
Fully supported. Each worktree shows its own branch correctly.

Originally published at https://digitalbunker.dev on February 11, 2026.

Many of you are probably familiar with Bézier curves and how they create smooth paths and designs, but did you know there’s a simpler way to a similar results?

I came across this blog post yesterday that introduced me to Chaikin’s Algorithm. After spending an afternoon playing around with it, I knew I had to write about it.

What is Chaikin’s Algorithm?

Chaikin’s Algorithm is a simple method to smooth out a rough polygonal line into a nice, smooth curve. It works by repeatedly adding new points along each line segment, at 25% and 75% of the way between the original points, and then connecting these new points. Every time you do this, the line gets smoother and smoother.

Let’s apply the algorithm to this starting set of points:

Next, we’ll add new points at 25% and 75% of the way along each line segment. We’ll look at how we calculate these points in a minute, for now we’ll just estimate.

Now, let’s combine just the new points together:

You’ll see that by effectively cutting off the corners, we’ve achieved a more curved appearance.

Let’s do it one more time.

We’ll start again by adding new points along each of the new line segments:

And then connect them:

We can see that in just 2 iterations we’ve transformed our initial jagged line into a much more pleasant curve.

Calculating Control Points

To calculate the control points at 25% and 75% along a line segment, we need to use linear interpolation (a.k.a. lerp). It sounds fancy, but it’s simply a way of finding a point that is some percentage of the way between two other points.

If you’re already familiar with this concept, feel free to skip to the next section.

Or, if you’re interested in exploring the relationship between different interpolation approaches and how they relate to animations in iOS (UIKit & SwiftUI), check out my earlier blog post:

https://digitalbunker.dev/exploring-animation-curves/

We’ll start by looking at the linear interpolation formula and then we’ll look at an example:

L(t) = (1 − t) ⋅ P0​ + t ⋅ P1​

• L(t) is the interpolated point.
• t is the interpolation parameter which ranges from 0 to 1.
• When t = 0, L(t) = P0.
• When t = 1, L(t) = P1.
• P0 is the starting point.
• P1 is the ending point.

So, if we wanted to figure out a point that was 25% of the way between P0 and P1, we'd just have to evaluate this expression:

L(t) = (1 - 0.25) * P0 + 0.25 * P1

L(t) = (0.75 * P0) + (0.25 * P1)

In practice, we’ll use this formula to calculate a new control point’s X and Y coordinates individually.

Implementing Chaikin’s Algorithm

Now that we know how the algorithm and linear interpolation work, let’s create an interactive version of it in SwiftUI.

Here’s the main algorithm’s implementation:

func chaikinAlgorithm(points: [CGPoint], iterations: Int) -> [CGPoint] {
    // We want to preserve the starting and ending points, so let's save them.
    guard points.count > 2, let startingPoint = points.first, let endingPoint = points.last else { return points }

    var currentPoints = points

    // We know the more iterations we do, the smoother the curve.
    for _ in 0..<iterations {
        var newPoints: [CGPoint] = [startingPoint]

        for i in 0..<currentPoints.count - 1 {
            // Gets adjacent points
            let p0 = currentPoints[i]
            let p1 = currentPoints[i + 1]

            // Calculates the position of the new control points
            // via linear interpolation
            let q = CGPoint(x: 0.75 * p0.x + 0.25 * p1.x, y: 0.75 * p0.y + 0.25 * p1.y)
            let r = CGPoint(x: 0.25 * p0.x + 0.75 * p1.x, y: 0.25 * p0.y + 0.75 * p1.y)

            newPoints.append(q)
            newPoints.append(r)
        }

        newPoints.append(endingPoint)
        currentPoints = newPoints
    }

    return currentPoints
}   var currentPoints = points

To render the points and curve in SwiftUI, we can use Path:

var body: some View {
    ZStack {
        // Draw the points where the user taps
        ForEach(points, id: \.self) { point in
            Circle()
                .fill(Color.blue)
                .frame(width: 10, height: 10)
                .position(point)
        }

        // Draw the smoothed curve
        Path { path in
            guard !smoothedPoints.isEmpty else { return }
            path.move(to: smoothedPoints.first!)
            for point in smoothedPoints.dropFirst() {
                path.addLine(to: point)
            }
        }
        .stroke(Color.red, lineWidth: 2)
    }
    .background(Color.white)
    .onTapGesture(coordinateSpace: .global) { location in
        points.append(location)
        
        // Perform Chaikin's Algo every time we add a new point
        smoothedPoints = chaikinAlgorithm(points: points, iterations: 3)
    }
    .edgesIgnoringSafeArea(.all)
}

Putting everything together, we can now define any line and generate a curve that matches it’s shape.

1 Iteration

3 Iterations

5 Iterations

You can find the full source code here.

Chaikin’s Algorithm vs. Bézier Curves

Both Chaikin’s Algorithm and Bézier curves are essential tools for creating smooth curves from a set of control points. They are widely used in graphic design, animation, and UI/UX design to generate appealing shapes and paths. One key similarity is that both methods can be applied iteratively to increase the smoothness of the resulting curve. With Chaikin’s Algorithm, each iteration adds new points and refines the curve, while Bézier curves can be subdivided further to achieve a similar effect.

However, there are significant differences between the two. Bézier curves are mathematically more complex, requiring polynomial equations and manipulation of control points to define the curve. In contrast, Chaikin’s Algorithm is straightforward, using simple linear interpolation between points. Bézier curves are defined by a specific set of control points that directly influence the shape of the curve. Moving a control point will change the entire curve’s shape. Chaikin’s Algorithm, however, generates new points along the line segments, gradually smoothing the path without direct manipulation of the original control points.

In terms of applications, Bézier curves are widely used in vector graphic design, font design, and path animation due to their precision and control. On the other hand, Chaikin’s Algorithm is more commonly used for quick and easy curve smoothing, particularly in applications where simplicity and efficiency are more critical than precise control over the curve’s shape. In summary, while both Chaikin’s Algorithm and Bézier curves are powerful tools for creating smooth curves, they cater to different needs and levels of complexity. Chaikin’s Algorithm is ideal for quick, easy smoothing, while Bézier curves offer greater control and precision for more complex designs.

If you’re interested in more articles about iOS Development & Swift, check out my YouTube channel or follow me on Twitter.

And, if you’re an indie iOS developer, make sure to check out my newsletter! Each issue features a new indie developer, so feel free to submit your iOS apps.

Universal Link Checker & Apple App Site Association Validator

Originally published at https://digitalbunker.dev on June 20, 2024.

After exploring universal links and the Apple App Site Association file in a previous blog post, it was clear that developers needed a straightforward solution for testing an app’s universal links.

Easy AASA Management

What is getuniversal.link?

It’s a developer utility that simplifies the process of testing universal links-those special URLs that link to specific content within your app.

With just the path to your domain, getuniversal.link allows you to test all the universal links your app supports. Whether it’s a link that opens your app or redirects to your website, ensuring these work correctly is crucial for providing a seamless user experience.

How Does It Work?

Using getuniversal.link is simple!

Start by entering the path to your domain where your AASA (Apple App Site Association) file is hosted (e.g. youtube.com, yelp.com).

The platform will fetch the latest copy of your AASA file from Apple’s servers and will give you an easy-to-use dashboard to let you test them. You can see exactly how each link behaves, verify the setup, and identify regressions.

You can either navigate to those URLs directly or grab the Terminal command to open the link in the booted Simulator.

No matter how many apps your AASA file supports, you’ll be be able to test them all.

Even if you use the component-based AASA file, that’s supported too!

You can easily create custom links based off the specified Universal Link pattern for easy testing.

These links are stored in local storage, so you can always come back to them in the future.

The platform will also tell you when Apple will also let you know when Apple’s cached version of your AASA file will refresh.

We’re also planning on adding AASA file monitoring, so you’ll be informed whenever there’s a syntax error in your configuration or occasions where the file is unreachable.

For other feature requests, let me know at aryaman@digitalbunker.dev.

getuniversal.link simplifies testing by allowing you to save a static link to the configured dashboard directly on your home screen, whether on the Simulator or a physical devices (e.g. getuniversal.link/turo.com).

This enables easy testing of universal link behavior and lets you share the link with your team for convenient access to the dashboard.

Why Choose getuniversal.link?

• Efficiency: Save time with automated fetch and test features that cut down the manual steps required in testing each link.
• Accuracy: With precise testing tools, you can ensure that all your universal links work exactly as intended.
• Convenience: The platform’s integration with the Terminal and iOS ecosystem makes it easy to test the links via iOS Simulator or device.

Ideal for Developers and Teams

Whether you’re a solo developer or part of a larger team, getuniversal.link is designed to support your development process at every stage. Did I mention it’s all free?

Ready to take your app’s universal link testing to the next level? Streamline your testing process today.

https://getuniversal.link/

Originally published at https://digitalbunker.dev on May 8, 2024.

Recently, while working on a side project, I needed to convert an array of Codable models into a CSV file. While there are several 3rd-party solutions available, I was reluctant to introduce yet another dependency into my project for what seemed like a fairly straightforward task. Instead, I’d like to share an implementation you can use to perform this task.

Both of these implementations work well when you can make some assumptions about the variability of your data. If you have highly dynamic and variable input data, then by all means use a more robust 3rd-party solution.

This is all about creating a simple solution for simple use cases.

Basic Implementation

Let’s start by creating a model and adding some fake data.

struct Employee: Codable {
    var id: Int
    var name: String
    var department: String
}

let employees = [
    Employee(id: 1, name: "Alice", department: "HR"),
    Employee(id: 2, name: "Bob", department: "IT"),
    Employee(id: 3, name: "Charlie", department: "Finance")
]

Our first step in creating the CSV file is to set up the header row that specifies and outlines the columns.

To do this, we can use the Mirror API in Swift, which gives us a way to list out all the properties of an object as key and value pairs. If you want to learn more about the Mirror API, I recommend checking out this article.

According to Apple, the Mirror API “provides a representation of the substructure and display style of an instance of any type.”

We’ll use the first item in our input as the template for the header row:

func convertToCSV<T: Codable>(_ items: [T]) -> String {
    var csvString = ""

    // Reflection to get property names for the header row
    if let firstItem = items.first {
        let mirror = Mirror(reflecting: firstItem)

        // The label is the name of the property in the object
        // being reflected (i.e. id, name, department)
        let headers = mirror.children.compactMap { $0.label }
        csvString += headers.joined(separator: ",") + "\n"
    }
}

Now, to build the rows, we’ll use Mirror again, but we’ll extract the value this time. We'll also include some basic escaping and validation logic to ensure everything runs smoothly.

func convertToCSV<T: Codable>(_ items: [T]) -> String {
    var csvString = ""

    // Reflection to get property names for the header row
    if let firstItem = items.first {
        let mirror = Mirror(reflecting: firstItem)
        let headers = mirror.children.compactMap { $0.label }
        csvString += headers.joined(separator: ",") + "\n"
    }

    // Convert each instance to a CSV row
    for item in items {
        let mirror = Mirror(reflecting: item)
        let values = mirror.children.map { child -> String in
            let value = "\(child.value)"

            // Basic escaping; handles potential commas and quotes in values
            if value.contains(",") || value.contains("\"") {
                return "\"\(value.replacingOccurrences(of: "\"", with: "\"\""))\""
            }
            return value
        }

        // This trailing newline is required for a valid .csv file
        csvString += values.joined(separator: ",") + "\n"
    }

    return csvString
}

// Usage
// convertToCSV(employees)
//
// Output
// id,name,department
// 1,Alice,HR
// 2,Bob,IT
// 3,Charlie,Finance

Advanced Implementation

Great! We have a working implementation, but there’s a few things I’d like to address:

• How can I make the column names capitalized? How can I create more readable column names?
• How might we pre-format values, like dates, before exporting them?
• Can we selectively choose which properties to include in the output file?

Let’s start by creating a struct to encapsulate the types of customizations we want to make.

struct CSVCustomization {
    var headerTransform: ((String) -> String)?
    var valueTransform: ((String, Any) -> String)?
    
    // Set of property names to exclude
    var excludedProperties: Set<String> = []  
}

Next, we’ll pass that into our convertToCSV function:

func convertToCSV<T: Codable>(
        _ items: [T],
        customization: CSVCustomization? = nil
    ) -> String { ... }

Now, when constructing the header, we’ll first verify that the current property isn’t listed under excludedProperties and then proceed to apply any necessary transformations using headerTransform:

var csvString = ""

// Reflection to get property names for headers
if let firstItem = items.first {
    let mirror = Mirror(reflecting: firstItem)
    var headers = mirror.children.compactMap { $0.label }

    // Exclude headers
    if let excluded = customization?.excludedProperties {
        headers = headers.filter { !excluded.contains($0) }
    }

    // Apply header transformations if provided
    if let headerTransform = customization?.headerTransform {
        headers = headers.map(headerTransform)
    }

    csvString += headers.joined(separator: ",") + "\n"
}

We’ll make a similar adjustment to our row-building logic. Note the shift from using map to compactMap.

// Convert each instance to a CSV row
for item in items {
    let mirror = Mirror(reflecting: item)
    let values = mirror.children.compactMap { child -> String? in
        guard let label = child.label, !(customization?.excludedProperties.contains(label) ?? false) else {
            return nil
        }
        var value = "\(child.value)"

        // Apply value transformations if provided
        if let valueTransform = customization?.valueTransform {
            value = valueTransform(label, child.value)
        } else {
            // Handle potential commas and quotes in values
            if value.contains(",") || value.contains("\"") {
                value = "\"\(value.replacingOccurrences(of: "\"", with: "\"\""))\""
            }
        }
        return value
    }
    csvString += values.joined(separator: ",") + "\n"
}

Here’s the final implementation with a tweaked Employee model:

struct Employee: Codable {
    var id: Int
    var firstName: String
    var lastName: String
    var department: String
    var ssn: String
}

struct CSVCustomization {
    var headerTransform: ((String) -> String)?
    var valueTransform: ((String, Any) -> String)?

    // Set of property names to exclude
    var excludedProperties: Set<String> = []
}

func convertToCSV<T: Codable>(
    _ items: [T],
    customization: CSVCustomization? = nil
) -> String {

    var csvString = ""

    // Reflection to get property names for headers
    if let firstItem = items.first {
        let mirror = Mirror(reflecting: firstItem)
        var headers = mirror.children.compactMap { $0.label }

        // Exclude headers
        if let excluded = customization?.excludedProperties {
            headers = headers.filter { !excluded.contains($0) }
        }

        // Apply header transformations if provided
        if let headerTransform = customization?.headerTransform {
            headers = headers.map(headerTransform)
        }

        csvString += headers.joined(separator: ",") + "\n"
    }

    // Convert each instance to a CSV row
    for item in items {
        let mirror = Mirror(reflecting: item)
        let values = mirror.children.compactMap { child -> String? in
            guard let label = child.label, !(customization?.excludedProperties.contains(label) ?? false) else {
                return nil
            }
            var value = "\(child.value)"

            // Apply value transformations if provided
            if let valueTransform = customization?.valueTransform {
                value = valueTransform(label, child.value)
            } else {
                // Handle potential commas and quotes in values
                if value.contains(",") || value.contains("\"") {
                    value = "\"\(value.replacingOccurrences(of: "\"", with: "\"\""))\""
                }
            }
            return value
        }
        csvString += values.joined(separator: ",") + "\n"
    }

    return csvString
}

// Usage
let employees = [
    Employee(id: 1, firstName: "Brad", lastName: "Pitt", department: "HR", ssn: "123-45-1234"),
    Employee(id: 2, firstName: "Bruce", lastName: "Willis", department: "IT", ssn: "987-45-1234"),
    Employee(id: 3, firstName: "Tom", lastName: "Cruise", department: "Finance", ssn: "123-46-1234"),
    Employee(id: 4, firstName: "Jackie", lastName: "Chan", department: "Legal", ssn: "315-45-1234")
]

let customizations = CSVCustomization(
    headerTransform: {
        if $0 == "firstName" {
            return "First Name"
        } else if $0 == "lastName" {
            return "Last Name"
        }

        return $0.capitalized
    },
    valueTransform: nil,
    excludedProperties: ["ssn"]
)

convertToCSV(employees, customization: customizations)

// Output
// Id,First Name,Last Name,Department
// 1,Brad,Pitt,HR
// 2,Bruce,Willis,IT
// 3,Tom,Cruise,Finance
// 4,Jackie,Chan,Legal

If you’re interested in more articles about iOS Development & Swift, check out my YouTube channel or follow me on Twitter.

And, if you’re an indie iOS developer, make sure to check out my newsletter! Each issue features a new indie developer, so feel free to submit your iOS apps.

Originally published at https://digitalbunker.dev on April 22, 2024.

Converting Codable Models To CSV was originally published in HackerNoon.com on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Apple App Site Association (AASA) file enables iOS features like Universal Links, Shared Web Credentials, Handoff, and App Clips by establishing a secure and verified link between your iOS app(s) and a web domain.

If you’ve noticed that certain links on the mobile web versions of Instagram or YouTube keep you in the browser, while others redirect you into the app, this behavior is all being driven by the AASA file.

Creating The AASA File

The Apple App Site Association file is a configuration file that defines how URLs are handled and specifies whether they open in a web browser or link directly to content within an app.

Here’s a basic example:

{
  "applinks": {
    "apps": [],
    "details": [
      {
        "appID": "ABCDE12345.com.example.app",
        "paths": [
          "/",
          "/about-us/",
          "/products/*",
          "/services/detail/?id=*",
          "/news/article/*",
          "/promo/*",
          "NOT /private/",
          "NOT /settings/*",
          "*.html"
        ]
      }
    ]
  },
  "webcredentials": {
    "apps": ["ABCDE12345.com.example.app"]
  },
  "appclips": {
    "apps": ["ABCDE12345.com.example.app"]
  }
}{ "applinks": { "apps": [], "details": [ { "appID": "ABCDE12345.com.example.app", "paths": [ "/", "/about-us/", "/products/*", "/services/detail/?id=*", "/news/article/*", "/promo/*", "NOT /private/", "NOT /settings/*", "*.html" ] } ] }, "webcredentials": { "apps": ["ABCDE12345.com.example.app"] }, "appclips": { "apps": ["ABCDE12345.com.example.app"] } }

Attempting to visit any of these paths would route the user to the app:

"/",
"/about-us/",
"/products/*",
"/services/detail/?id=*",
"/news/article/*",
...

And for paths prefixed with NOT, the system will not reroute the user, allowing the experience to continue in the browser:

"NOT /private/",
"NOT /settings/*",
...

Deploying The AASA File

When you’re ready to deploy your AASA file, you’ll need to host it at your website’s root or .well-known directory:

• /apple-app-site-association
• /.well-known/apple-app-site-association

Note: there should be no file extension on the AASA file.

For the CDNs to successfully cache this file, it must be hosted on a domain that is available to all IP addresses and ranges, serves the file over HTTPS, does not redirect, and is not blocked by access policies.

You should also make sure your server serves the file with Content-Type: application/json and that the file doesn't exceed 128KB in size.

When you first host your AASA file, Apple’s CDNs are set up to retrieve it within 24 hours, meaning that they will request and cache a copy from your server within the first day of its publication.

This 24 hour window relates only to getting the file into Apple’s CDNs for the first time. Subsequent updates happen at a different interval which we’ll look at shortly.

Testing & Validation

As your app evolves, you’ll need to revise the AASA file to incorporate universal links for new user flows.

Errors in the AASA files are common, so validation of both the behavior and syntax of this file become an essential part of the process. Any mistakes in this file, once acknowledged by Apple’s CDNs, can effect universal linking behavior for all users — new or old.

Fortunately, there are several ways of verifying the behavior of the AASA file before the changes make it to Apple.

Bypassing The CDN

Associated Domains support an alternate mode that allows developers to verify the behavior of the modified AASA file by bypassing the CDNs and retrieving the file from your server directly.

1. Go to Signing & Capabilities -> Associated Domains
2. Add ?mode=developer to the end of the domain entry (e.g. applinks:yourdomain.com?mode=developer)

To activate this mode in your Xcode project:

Now, when you build and run your app, it will retrieve the updated AASA file directly from your server.

You can only use alternate modes during development and you must remove the query string from the Associated Domains before you submit your app to the App Store.

Verifying AASA File Configuration

You can use the following tools to verify the syntax and configuration of your AASA file:

• AASA Validator | Branch
• How do I access Apple's AASA validator (App Search API Validation Tool)?
• yURL: Universal Links / App Links Validator

If I need to update the AASA file at work, I’ll start by making changes to the version in our staging environment, then use the links above to validate the configuration, and will then enable developer mode for local testing.

After confirming everything works as expected, I’ll bring those modifications over to the production environment. But now, the question is, how long will it take for all clients to receive the updated version of this file?

Rolling Out Changes

You can check if Apple’s CDNs have picked up the latest version of the file by visiting:

• https://app-site-association.cdn-apple.com/a/v1/{YOUR_DOMAIN_HERE}
• https://app-site-association.cdn-apple.com/a/v1/facebook.com

If the CDN does in fact have the most recent version of the file, then any new app installations will also receive this latest version. For existing users, however, their devices will only check for an updated copy once per week.

Reinstalls of the app will fetch the latest version from the CDN.

In effect, the rollout period for any change to the AASA file is both the time it takes for the CDN to refresh its cache combined with this week long check-in period for existing users.

Still seeing the old version?

While you can’t clear the CDNs cache, you can at least verify that the AASA file will be correct when the cached version does update.

Adding any query parameter to the link above will force the CDNs to re-request the resource, so you’ll be able to verify that the future version of the file will be correct once the cache updates.

https://app-site-association.cdn-apple.com/a/v1/<domain>?digitalbunker

When will it update?

To better understand the remaining time before the cached version is updated, we can look at the Cache-Control field in the response headers from the CDN.

The Cache-Control header is used by web servers to dictate how, and for how long, both browser and intermediary caches (like CDNs) should cache the provided version of a file.

Let’s use Facebook and Yelp as examples:

• https://app-site-association.cdn-apple.com/a/v1/facebook.com
• https://app-site-association.cdn-apple.com/a/v1/yelp.com

Now, we can determine when the cache will update by subtracting age from max-age:

In playing around with this approach, it seems like the refresh rates are fairly variable with the shortest max-age being 3,600 seconds, or 1 hour, and the longest being 21,600 seconds, or 6 hours.

It also may be useful to know that Apple’s CDNs override the Cache-Control settings specified by the original website. For example, accessing the AASA file from Yelp directly has a max-age: 1200, but when retrieving it from Apple's CDNs, it's max-age: 3600.

By caching the file longer, Apple is able to minimize the frequency of requests to the original servers, reducing traffic, and load on both their network and the origin server.

Hope you enjoyed this article! If you did, please consider sharing 😊🙏.

If you’re interested in more articles about iOS Development & Swift, check out my YouTube channel or follow me on Twitter.

And, if you’re an indie iOS developer, make sure to check out my newsletter! Each issue features a new indie developer, so feel free to submit your iOS apps.

Originally published at https://digitalbunker.dev on April 13, 2024.

Do you remember that DVD screensaver from the early 2000s? Not only was it a practical tool for preventing screen burn-in on CRT displays, but it’s also become a cultural icon.

Like many of you, I can remember seeing this screensaver as a kid, but I’d completely forgotten about it until I rewatched this scene from “The Office” recently:

I thought it’d be fun to recreate this screensaver using SwiftUI. Admittedly, there’s no real reason for it other than the fact that I’ve got a long flight ahead and some time to kill.

Let’s get started!

Working With The Canvas API

First things first, let’s get all the UI elements set up. We can tackle the animation later.

struct ContentView: View {
    @State private var position: CGPoint = .zero

    private let canvasSize: CGSize = UIScreen.main.bounds.size
    private let imageSize: CGSize = CGSize(width: 128, height: 76)
    private let image = Image("dvd_logo")

    var body: some View {
        Canvas { [position] context, size in
            // Set the background color to .black
            context.fill(Path(CGRect(origin: .zero, size: size)), with: .color(.black))

            // Draw image at current position
            var image = context.resolve(image)
            image.shading = .color(.red)
            context.draw(
                image,
                in: CGRect(x: position.x, y: position.y, width: imageSize.width, height: imageSize.height)
            )
        }
        .onAppear {
            // Set initial position to the center of the canvas after the view appears
            position = CGPoint(x: (canvasSize.width - imageSize.width) / 2, y: (canvasSize.height - imageSize.height) / 2)
        }
        .ignoresSafeArea()
    }
}

We’re able to use SwiftUI’s Canvas API to set a background color for the screen and draw an image with a background color applied. Then, in the onAppear, we're calculating the center point of the screen and using that as the starting location for the image.

Aside: The Need For The Capture Group

At this point, I encountered some interesting behavior with the Canvas API.

Unless I explicitly declared position in the Canvas's capture group, the image would always get drawn at .zero even though the position is updated in the onAppear.

This behavior becomes even more interesting when you compare it to a regular SwiftUI view with a similar setup, where everything behaves as expected.

In the following SwiftUI view, the Text element accurately reflects the center of the View, and the View gets redrawn when the position value changes in .onAppear.

struct ContentView: View {
    @State private var position: CGPoint = .zero
    private let canvasSize: CGSize = UIScreen.main.bounds.size

    var body: some View {
        VStack {
            Text("\(position.x), \(position.y)")
        }
        .onAppear {
            // Set initial position to the center of the view after it appears
            position = CGPoint(x: canvasSize.width / 2, y: canvasSize.height / 2)
        }
    }
}

Let’s chalk this up to a difference in how Canvas manages it's dependencies and continue on with our implementation. If you know what's going on here, I'd love to hear about it.

Creating A Draw Loop

So far, we’ve successfully replicated the appearance of the DVD screensaver.

Next, we’ll need to build a mechanism to trigger the View to redraw at regular intervals. My initial approach was to simply use a Timer that fired every 1/30th of a second, so the View would redraw at 30 frames per second.

After some feedback from users on Reddit about this original approach, it turns out that using CADisplayLink is a far better option.

CADisplayLink is a timer object that allows your app to synchronize its drawing to the refresh rate of the display.

Using CADisplayLink ensures that our UI updates appear smooth and free the visual artifacts that might occur if our updates are out of sync with the screen's refresh rate.

The following CADisplayLink wrapper below allows us to detect when the hardware intends to redraw the screen and trigger a custom completion handler at that time.

@MainActor
final class DisplayLink {
    private var displaylink: CADisplayLink?
    private var update: (() -> Void)?

    func start(update: @escaping () -> Void) {
        self.update = update
        
        displaylink = CADisplayLink(
            target: self,
            selector: #selector(frame)
        )
        displaylink?.add(to: .current, forMode: .default)
    }

    func stop() {
        // Stops the display link from firing and effectively
        // invalidates it, removing it from all run loop modes. 
        //
        // After calling .invalidate(), the display link 
        // cannot be reused.
        displaylink?.invalidate()
        update = nil
    }

    @objc func frame() {
        update?()
    }
}

Then, in our View, we can simply add:

@State private var displayLink = DisplayLink()
....
.onAppear {
    displayLink.start {
    // Update position of the image
    }
}
.onDisappear {
    displayLink.stop()
}

Now, we know we want the image to move every time the View is redrawn, but how fast should it move?

Let’s add a velocity vector to control the movement speed of the DVD logo:

@State private var velocity: CGVector = CGVector(dx: 1, dy: 1)

In the displayLink update block, we'll update the position.x and position.y by adding the corresponding values from the velocity vector. This adjustment allows us to control the speed of movement along the X and Y axis independently.

displayLink.start {
    // Update position based on velocity
    position.x += velocity.dx
    position.y += velocity.dy
}

If you were to run this now, you’d notice the image gradually drifting off-screen:

Next, we’ll add some boundary checks to ensure our image stays within the visible area of the screen.

Adding Boundary Checks

How should we respond when our image reaches an edge?

If the image is approaching the right side of the screen, then all we need to do is switch the direction of its horizontal movement, right? Similarly, if the image is approaching the top of the screen, we only need to flip its vertical movement while keeping its horizontal movement the same.

With this intuition in place, the boundary checks become very simple:

displayLink.start {
    // Update position based on velocity
    position.x += velocity.dx
    position.y += velocity.dy

    // Check if image hits an edge
    if position.x + imageSize.width >= canvasSize.width || position.x <= 0  {
        // Flip horizontal direction
        velocity.dx *= -1
    }

    if position.y + imageSize.height >= canvasSize.height || position.y <= 0 {
        // Flip vertical direction
        velocity.dy *= -1
    }
}

We’re on the home stretch now! Now, all we need to do is change the color of the image every time it hits an edge.

@State private var imageColor: Color = .green

// In Canvas
var image = context.resolve(image)
image.shading = .color(imageColor)

// In displayLink.start {..}
// Check if image hits a horizontal edge
if position.x + imageSize.width >= canvasSize.width || position.x <= 0  {
    // Flip horizontal direction
    velocity.dx *= -1
    imageColor = Color.random()
}

if position.y + imageSize.height >= canvasSize.height || position.y <= 0 {
    // Flip vertical direction
    velocity.dy *= -1
    imageColor = Color.random()
}

extension Color {
    static func random() -> Color {
        let red = Double.random(in: 0...1)
        let green = Double.random(in: 0...1)
        let blue = Double.random(in: 0...1)
        return Color(red: red, green: green, blue: blue)
    }
}

You can find the source code here:

GitHub - aryamansharda/DVDScreensaver: SwiftUI implementation of the DVDScreensaver

Hope you enjoyed this article! If you did, please consider sharing 😊🙏.

If you’re interested in more articles about iOS Development & Swift, check out my YouTube channel or follow me on Twitter.

And, if you’re an indie iOS developer, make sure to check out my newsletter! Each issue features a new indie developer, so feel free to submit your iOS apps.

• Ace The iOS Interview
• Indie Watch

Recreating The DVD Screensaver In SwiftUI was originally published in HackerNoon.com on Medium, where people are continuing the conversation by highlighting and responding to this story.

As someone who loves staying current with iOS Development changes, my week is basically a marathon of scrolling through blogs, podcasts, newsletters, and YouTube videos.

But, let’s be real, I’ll inevitably miss out on some cool content. There’s no easy way of staying on top of everything.

So, to solve the problem for myself and other developers, I’m excited to introduce a space that brings together everything you need for iOS Development — all in real-time.

From insightful blogs to engaging podcasts, curated newsletters, new package releases / updates, and YouTube videos, you’ll find everything you need here:

iOS Development News

Just wrapped up Day 2 at SwiftLeeds! Big thanks to SwiftLeeds for having me as a speaker! It was a pleasure to meet and connect with so many people in the iOS Community.

Looking forward to many more exciting speaking engagements in the future!

I’ll include a link to the recorded talk once it’s available.

In the meantime, you can find a copy of the slides here:

SwiftLeeds Xcode Editor Extension Day 2.pdf

And all of the sample code here:

GitHub - aryamansharda/EditKitPro: A multi-purpose Xcode Editor Extension for iOS and macOS developers