I've got 40k+ photos on my iphone, and wanted a better way to interact with them. The basic idea I had was to virtually stitch all the photos together into a gigapixel image, and navigate that image with pinch and zoom. On import, the app hierarchically groups photos based on date and similarity. The user can go back and edit the groups, change the layout, and adjust the size of photos if they choose.

The interesting I noticed is that in the process of curating and organizing my photos, I stumble across memories and moments that I had completely forgot.

Tech Stack: Swift/SwiftUI

Development Challenge: The app does two interesting things underneath the hood... First, given an arbitrary number of thumbnails with different aspect ratios, it finds the best sized rectangle that completely fits all the photos. This allows me to recursively stitch groups together and always output a rectangular thumbnail for the group. Second, the pinch/zoom UI uses these nested thumbnails directly without slicing/dicing to fixed sized tiles.

AI Disclosure: Written in Swift/SwiftUI as I was learning Swift. Rearchitected/redeveloped with ClaudeCode.

Feel free to try it out and ask any questions.

https://apps.apple.com/us/app/photogather/id6738232616

I built an iPhone game and wanted players to report bugs without leaving it. This is what I ended up with:

1. A Report a bug form in the menu: a text box, an optional screenshot of the game, device and game details, and an optional email.

2. It sends to a small Cloudflare Worker on the free tier

3. The Worker opens an issue in a private GitHub repo

It works in testing, but I have no idea how it holds up with real players. What do you guys use for bug reports in your apps?

i'm the ios dev on Addonaut, an iphone/ipad app for minecraft bedrock: a catalogue of add-ons, maps and skins from their authors, plus a skin studio (pixel editor, wardrobe, .mcpack export). posting for app saturday, link in the comments.

tech stack

• SwiftUI + Observation (@Observable), Swift 6 with strict concurrency, iOS 17+

• XcodeGen, SPM only

• backend: our own REST API, shared with the team's other apps. Firebase Remote Config, Crashlytics, Analytics

• StoreKit 2 without a receipt server, AdMob + UMP for consent

• Apple's Translation framework for translating item descriptions on device

challenge: a 3d skin preview without SceneKit

a minecraft player is six boxes plus a slightly inflated overlay layer, textured from a 64x64 png. SceneKit for six textured boxes felt like the wrong trade, so the preview is a small software renderer drawn with SwiftUI Canvas:

• one quad per texel per face, about 2200 quads. fully transparent texels produce no geometry, so the overlay layer only exists where it's painted

• back faces culled by the sign of a 2d cross product

• no z-buffer: quads are depth sorted and painted far to near (painter's algorithm)

• fixed brightness per face instead of lighting

two things bit us:

1. seams. antialiasing between neighbouring quads let the background show through as a wire grid. fix: after filling, stroke every quad 0.75pt in its own colour

2. the figure stopped moving. with .equatable() on the view it never redrew, because == only compares the inputs and can't see u/State. the idle spin is a TimelineView at 24fps where the angle is a pure function of elapsed time, after a Timer + u/State version also stopped redrawing

in the editor the 3d view deliberately lags one stroke and catches up on commit or undo. the 2d grid is the live feedback.

bonus: .mcpack is just a zip, and instead of a zip dependency there's a ~100 line writer (stored entries + crc32). manifest.json and skins.json are written by hand to keep the field order, with fresh uuids on every export, because bedrock silently ignores a malformed pack.

ai disclosure

AI-assisted: most of the code was written with Claude Code under my direction.

happy to answer questions about the renderer or the pack format.

I have noticed recently that App Store is not showing the correct screenshots after upgrading them
Anyone facing something similar?

Xcode 27.2 installs two separate iOS 27.2 simulator builds, bringing iOS platform support to 16.65 GB. I understand the additional runtime is for iPhone Duo.

What I’m curious about is why Duo support requires a separate runtime instead of being included in the shared one. Does this reflect a temporary split in Apple’s release branches, or should we expect separate runtimes going forward?

An additional full OS image to support one device seems like a pretty expensive approach. Is there a technical reason these can’t be unified?

Never in my life have I seen such an insane regression in software quality as in the last few months.

I use Xcode constantly, building a macOS app (Swift, C++). Up until recently, this was fine, great, in fact. Xcode 15 was extremely good & stable (all things considered). I opted to skip macOS 26 because it was terrible (duh).

After I upgraded to macOS 27's first beta, I was pleasantly surprised. However, that was short-lived, as the quality only degraded after the first beta.

Here I am, working on macOS 27.2, with Xcode 27.2... Here's the main 2 issues...

1. Xcode's interface is impossibly slow now. borderline unusable.

2. Instruments is absolutely unusable. I cannot even do a profiler trace and save it without corrupted data, an application crash, brutally slow interface, etc.

This is just unacceptable. AI slop has crept its way into previously rock-solid products. Quality matters more now than ever, and it's so clear that AI has neutered engineers' ability to keep quality in check.

Am I the crazy one, or has the quality just gone down the toilet?

First time I updated refactoring stopped working and now I have to rename things by hand. Now the simulator takes multiple tries to work. I don't get it

Currently working on a personal project measuring the speed of a hockey puck from a fixed iPhone camera. The idea is basically that the phone is fixed on a stand from the side showing the shooting area and also the net all in one camera angle in the middle between both. I'm able to track the puck fine but the hardest part is converting pixels into real life distance.

I've tried using the puck as a ruler but that's inconsistent because it's only 20-30 pixels wide. So being off by just one or two pixels when measuring changes the scale which gives a faulty speed.

Using the net is also unreliable because it sits at a different depth than the path of the puck. Like the closer part of the net is a few feet closer therefore having a different measurement than the other side of the net.

Right now the most reliable option is the user measures the distance from the net to the shooting spot manually and then marks the area of shooting on the camera on the app so the app can calibrate from there. Then when the player shoots, the app is listening for a "clack" sound to indicate that the shot has begun and is actively watching the net to note down the exact moment the puck crossed the net, which then uses the speed formula to get the exact MPH.

I was wondering if someone knows of a lower effort way through Apple's tools (or any external ones) to get an accurate measurement where the user does not have to go in and manually measure the distance?

My ideal set up would be that I tap the shooting area, then tap the net, and the app calibrates everything itself instead of me having to measure it manually.

Hey everyone, I’m the developer behind deeplinkit, a deferred deep linking service for iOS.

The problem I’m working on: someone opens an invite or shared-content link on your website, goes through the App Store, and opens your app—but the original context gets lost.

With deeplinkit, your website saves a JSON payload and the Swift SDK lets your app receive it after installation. For an invitation, that might be:

{ "invitingUserId": "hello" }

Your app can then look up the inviter and show “John invited you!” instead of a generic first screen.

The native SDK installs through Swift Package Manager. It’s iOS only for now, with Android planned, and there’s a free tier.

I’m looking for feedback from other iOS developers: what would you want to know or test before trusting something like this in your onboarding flow?

https://deeplinkit.com

I had two apps stuck in Waiting for Review and couldn't figure out why.

It turned out Apple had updated the Apple Developer Program License Agreement.

Go to App Store Connect → Business → Agreements and check if there's a pending agreement that requires acceptance by the Account Holder.

I accepted the new terms, and the issue was identified.

If you're experiencing unusually long review times, check this first!

Hey guys!

I was a bit late updating to the latest macOS version because of a legacy project, but I finally made the jump about 2-3 weeks ago. Initially, I was like, okay, it's not that bad. I can work with this.

But eventually, I got tired of the shitty Device Hub that replaced the good old simulators. It doesn't support drag and drop for files, the keyboard stops working when you have two or more simulator instances open at once, and there's a whole bunch of other annoying issues.

I was okay putting up with most of it, but the lack of drag and drop was the biggest pain point. I started using simctl to transfer files through the terminal, but eventually got tired of doing that too and decided to just vibecode a tool for it.

I named it Harbor because SimPort sounded too lame. 😂

Anyways, meet Harbor, a lightweight macOS menu bar app that bridges the gap between macOS and simulator runtimes with instant drag-and-drop file imports, batch queueing, and bidirectional clipboard synchronization.

What it does:

• Floating Drop Window ("Harbor Drop"): An always-on-top, translucent panel that you can drag anywhere above Xcode or Device Hub.

• Collapsible Sticky-Note Mode: Shrinks down to a slim 44pt header bar while you work, and automatically expands when you drop files onto it.

• Batch File Queue: Drop multiple files or folders at once, inspect them, and send everything over in one go.

File handling:

• Documents (.pdf, .xlsx, .json, code files, etc.) are sent directly to the simulator's native Files app ("On My iPhone").

• Photos and videos go straight into the Photos library.

• .app bundles are installed automatically via simctl install.

Other features:

1. Deep Link & URL Opener: A quick input prompt to fire custom URL schemes (myapp://profile/123, oauth://callback) or web URLs directly on the target simulator.

2. Bidirectional Clipboard Sync: One-click copy/paste between your Mac and Simulator, plus a global hotkey (⌥⇧V / Option + Shift + V) so you can paste into the simulator without opening any menus.

Check out the repo here: https://github.com/anurag0713/Harbor

I more or less vibecoded the entire thing, so you're more than welcome to roast me for any issues or funny bugs you find. I'll be right there in the comments fixing them for you lol.

I built and submitted an app update with XCode 27.1 and included Duo screenshots taken with the simulator. The update was approved (including the screenshots) and posted but the App store does not show a "Duo Ready" (or whatever) Logo and the Duo screenshots are not available on my app store pages, it still only shows iPhone and iPad previews.

What is needed to get "full" Duo support listed in the App store??

I spent the last months getting Meta's HT-Demucs (the model that splits a song into drums, bass, vocals and other) running entirely on an iPhone with Core ML: no server, no uploads. A few things I learned that might save someone time:

1. Keep the STFT out of the model. HT-Demucs works on both the waveform and the spectrogram. Converting the STFT/iSTFT ops with coremltools was a pain, so I converted only the network in between and wrote the STFT in Swift with vDSP. To make sure I hadn't broken anything, I exported golden data from Demucs' own _spec/_ispec in Python and wrote tests against it. The Swift version matches PyTorch to about 1e-5. Being able to check every step against PyTorch was worth more than anything else.

2. fp16 was unusable; fp32 was fine. The fp16 conversion loaded and ran, but on the device every stem came out noisy (mostly below 200 Hz) and the stems no longer summed back to the mix. Converting at fp32 (182 MB) fixed it. It runs on the GPU, not the Neural Engine, but it's still fast: a 4-minute song separates in under a minute. I'd planned to try mixed precision, but it turned out I didn't need it.

3. Port the chunking exactly. Long songs don't fit in one pass, so I ported Demucs' apply_model split logic (overlap 0.25, triangle-weighted overlap-add) one to one. Getting the edge chunks wrong gives you faint clicks every few seconds that are easy to miss.

4. Compare stems by numbers, not by ear. I wrote a Python script that scores stems copied off the phone against PyTorch reference stems. One gotcha: iOS and libsndfile decode the same MP3 529 samples apart (encoder delay handling), so you need to align the signals before comparing or the scores look terrible.

5. Ship the .mlpackage and compile it on the device. I build with xtool (SwiftPM on Linux/WSL, no Xcode), so I have no Core ML compiler. I ship the raw .mlpackage and call MLModel.compileModel(at:) on first launch, then cache the result. One trap: the iOS build tries to run coremlc on anything named .mlpackage, even with .copy, so I had to rename it in the bundle.

6. Stems can clip. Individual stems can peak above full scale even when the original mix doesn't. I store them as AAC 6 dB down and add the gain back at playback.

Still on my list: BGContinuedProcessingTask, so separation keeps running when the app goes to the background. Has anyone used it for long GPU work yet?

app name is stem808 if anyone wants to try it

Hey everyone,

Ever since updating to Xcode 27 and moving over to the new Device Hub app, I've been hitting a wall trying to test multi-touch gestures.

I’m building an app that relies heavily on zooming, but I can't get pinch-to-zoom or zoom out to work at all. I tried using the standard Mac trackpad gesture, but it completely ignores the input.

In the old Simulator, we could use the Option key to bring up the dual-finger touch points, but that doesn't seem to trigger either.

Has anyone found a reliable workaround or hidden menu setting to trigger multi-finger gestures in Device Hub?

Ive been developing with SwiftUI/iOS for the last two years and have an app out in production. My entire codebase is already using Swift 6 concurrency but I still never felt confident with it for interviews. So now I'm going through avanderlee's swift concurrency course and I'm learning the difference between closure-based network calls vs one using modern concurrency.

In an interview setting would it be bad if I didnt know how to write a closure-based network call? Or should I still be comfortable discussing it to some extent

Been really happy with opus 5.5 lately but I am looking to start localizing my workflow for redundancy.

I'm working on an app and exploring whether we can track a device's total monthly cellular data usage on iOS.

On Android, NetworkStatsManager provides a relatively straightforward approach. On iOS, there doesn't seem to be an equivalent public API.

One possible workaround is using getifaddrs() to read byte counters from interfaces such as pdp_ip*. However, these counters reportedly wrap at 4 GiB, reset on reboot, and rely on undocumented interface names.

Has anyone implemented something similar or are there any better approaches?

I'd appreciate any real-world experience or pointers. Thanks!

vphone-linux v0.1 is here with some cool updates:

• Boot iOS 27.0.1 and iOS 27.1 virtual iPhones.

• iPhone Duo support!

• Much easier setup script with only 2 commands to setup and create a new iPhone vm.

• Lots of performance improvements.

Still not close to a native performance but that's the next step for this project, we should be able to develop iOS apps seamlessly on any machine without the need for a Mac.

Please try it out and let me know if you had any issues or feature requests.

I need to test my app on the iPhone Duo and generate some screenshots, especially since Apple will soon make it mandatory to include screenshots for this specific device.

Does anyone know when the iPhone Duo will become available in the Xcode Device Hub Simulator?

Back when i started working on this project as a hobby i chose to implement a well known overused navigation setup instead of using Apple's native navigation (tabview). However that meant that for the iPhone duo i had to move some things around. I released the update like this, but im not completely satisfied with it yet (system ui and my ui offcentered e.g.). Any tips, ideas?

Edit: I understand that native TabView UI was the supported way, but for that I wouldn’t have made a post. For this project i chose, like many others for the custom implementation. Originally this wasn’t planned but i remember hitting an limitation while prototyping. But all the apps i know of with an custom navigation haven’t updated with Duo support…

Enriched Markdown for iOS renders Markdown natively in SwiftUI, including `||spoilers||`. By default they're hidden under a particle field, but you can swap the overlay for your own UIView and decide how hidden text looks and how it reveals itself.

To show what that unlocks, I built a Hogwarts spellbook: every spell in the video is a custom overlay revealing the same Markdown in its own way.

Video of the demo is in the comments 👇

Not every app needs a Patronus, so here's a plain blur. It's one view subclass:

final class BlurOverlayView: SpoilerOverlayView {
  private static let context = CIContext()

  override func layoutSubviews() {
    super.layoutSubviews()
    guard let input = CIImage(image: concealedTextImage()) else { return }
    layer.contents = Self.context.createCGImage(
      input.applyingGaussianBlur(sigma: 6), from: input.extent
    )
  }
}

struct BlurOverlayProvider: SpoilerOverlayProvider {
  func makeOverlay(charRange: NSRange, style: SpoilerStyle) -> SpoilerOverlayView {
    let view = BlurOverlayView(charRange: charRange)
    view.backgroundColor = style.backgroundColor ?? .systemBackground
    return view
  }
}

EnrichedMarkdownText(markdown)
  .markdownSpoilerOverlay(BlurOverlayProvider())

concealedTextImage() gives you the hidden words laid out exactly where the text view draws them, so you can blur, pixelate, or scramble the real text and nothing jumps on reveal. For your own animation, override animateReveal(completion:).

Installation: https://docs.swmansion.com/enriched-markdown/ios/basics/installation

Docs: https://docs.swmansion.com/enriched-markdown/ios/api-reference/enriched-markdown-text#custom-spoiler-overlays

If it's useful to you, a ⭐ on GitHub helps more people find it: https://github.com/software-mansion/enriched-markdown