Working Around Rork Max's 20-Geofence Wall with Dynamic Re-registration

Implementing the Re-registration Manager

Here's a thin wrapper you can add to Rork Max's generated code. It holds all candidate geofences (an array of GeoTarget) and re-registers only the 20 nearest the current location.

import CoreLocation
 
struct GeoTarget {
    let id: String
    let coordinate: CLLocationCoordinate2D
    let radius: CLLocationDistance   // 100–150m recommended (see below)
}
 
final class GeofenceCoordinator: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()
    private var allTargets: [GeoTarget] = []
 
    // The iOS limit is 20. Hold to 18 as a safety margin (reason below).
    private let maxActiveRegions = 18
 
    var onEnter: ((String) -> Void)?
 
    override init() {
        super.init()
        manager.delegate = self
        manager.allowsBackgroundLocationUpdates = true
    }
 
    func start(with targets: [GeoTarget]) {
        allTargets = targets
        manager.requestAlwaysAuthorization()
        // Coarse monitor that drives the rotation of the 20
        manager.startMonitoringSignificantLocationChanges()
        if let here = manager.location {
            reregisterNearest(to: here.coordinate)
        }
    }
 
    /// Re-monitor only the maxActiveRegions nearest the current location
    private func reregisterNearest(to center: CLLocationCoordinate2D) {
        let origin = CLLocation(latitude: center.latitude, longitude: center.longitude)
 
        let nearest = allTargets
            .sorted {
                let a = CLLocation(latitude: $0.coordinate.latitude, longitude: $0.coordinate.longitude)
                let b = CLLocation(latitude: $1.coordinate.latitude, longitude: $1.coordinate.longitude)
                return a.distance(from: origin) < b.distance(from: origin)
            }
            .prefix(maxActiveRegions)
 
        let nextIDs = Set(nearest.map(\.id))
 
        // Stop only those currently monitored that aren't in the new set of 20
        for region in manager.monitoredRegions where !nextIDs.contains(region.identifier) {
            manager.stopMonitoring(for: region)
        }
 
        // Start only those newly entering the set
        let currentIDs = Set(manager.monitoredRegions.map(\.identifier))
        for target in nearest where !currentIDs.contains(target.id) {
            let region = CLCircularRegion(
                center: target.coordinate,
                radius: target.radius,
                identifier: target.id
            )
            region.notifyOnEntry = true
            region.notifyOnExit = false
            manager.startMonitoring(for: region)
        }
    }
 
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let here = locations.last else { return }
        reregisterNearest(to: here.coordinate)
    }
 
    func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
        onEnter?(region.identifier)
    }
}

Two choices here are deliberate. First, instead of tearing everything down and re-registering every time, it updates only the diff. stopMonitoring and startMonitoring are themselves registration operations with the system, so wholesale swaps thrash when the user walks back and forth near a boundary. Leaving untouched the targets that survive into the new 20 damps that churn.

Second, it holds to 18 rather than the full 20. The region-monitoring budget can be consumed not just by your code but by other features or some libraries in your app. Exhaust it, and the last couple you registered get quietly ignored again. Leaving a few slots of headroom keeps you out of that contention.

The Pitfalls That Only Surface on a Real Device

Simulating a location in the simulator won't faithfully reproduce region monitoring. This feature assumes a real device. Rork Max gives you both the in-browser streaming simulator and a path to install directly onto your own iPhone via QR, so the reliable move is to install through the latter and walk it. Here are the real-device pitfalls, roughly in the order you'll hit them.

If you're already inside a region, didEnterRegion won't fire. The arrival event triggers the instant you cross the boundary from outside to inside. If you're standing on the spot when the app launches, no crossing happens, so no notification arrives. Right after launch or re-registration, call manager.requestState(for:) and, when didDetermineState reports .inside, treat it as an arrival yourself.

func locationManager(_ manager: CLLocationManager,
                     didDetermineState state: CLRegionState,
                     for region: CLRegion) {
    if state == .inside {
        onEnter?(region.identifier)   // cover the case of being inside without a crossing
    }
}

Don't make the radius too small. CLCircularRegion has an effective lower bound on radius tied to the device and hardware; specify something well under 100m and it won't actually detect at that precision. The urge to trigger pinpoint-tight is understandable, but staying around 100–150m makes arrivals far less likely to be missed.

You need Always authorization. To catch arrivals while the app is closed, "Always" permission is required. Asking for Always cold tends to get denied, so the realistic path is to earn When In Use first and prompt for the upgrade to Always in the context where the feature is used. Alongside that, add NSLocationAlwaysAndWhenInUseUsageDescription and NSLocationWhenInUseUsageDescription to Info.plist, and Location updates under Background Modes in Signing & Capabilities. This is territory Rork Max's generated code can't fill in, so you supply it by hand. If location itself won't budge, my walkthrough on fixing location permission that won't take effect lays out the isolation steps and gives you the full picture of where things stall.

CLMonitor as an Option on iOS 17 and Later

Since iOS 17, CLMonitor is available as the successor to region monitoring. You work with CLMonitoringCondition through an async flow, and the monitoring state is structured, so it reads more clearly than the old delegate-based approach. If you're writing arrival detection fresh, it's worth considering.

But moving to CLMonitor doesn't retire the "narrow to the nearest and rotate" design. The number of conditions you can watch still has a practical ceiling — you can't load hundreds of geofences at once. Even with a newer API, the idea of re-selecting a small live set from many candidates stays the same. The structure this manager builds — hold all candidates yourself, load only the near ones into the OS — ports straight onto CLMonitor. My rule of thumb: migrate once you can require iOS 17+, and stay on region monitoring while you still support older OSes.

The Next Step

Start by adding a single line that prints manager.monitoredRegions.count right after your current geofence registration. If it's stuck at 20, it's worth swapping in this article's manager. If it comfortably sits under 20, you don't need dynamic re-registration yet — resisting the urge to complicate things ahead of need is, I think, an important call in indie development too.

Location is a domain where much of the truth only reveals itself once you're walking with a real device. I still get surprised by per-device behavior differences, but once you fold the limit into your design as a premise rather than a bug, it becomes a great deal easier to work with. Thank you for reading.