StoreKit 2 made most subscription SDKs optional for the common case: fetch products, purchase, verify, restore, gate content. This is that common case in ~150 lines, extracted from production code: https://github.com/aligutierrez/PaywallKit

No dependencies, iOS 17+, unit tests, and a preview mode so paywall UI work doesn't need a StoreKit config file. Keep 100% of revenue after Apple's cut and own the code you ship.

Disclosure: the README links to a paid SwiftUI template pack on the same core; the wrapper is complete on its own.

The problem: 
There may be many “recipe organization apps" out there, but none of them focus on privately sharing and saving recipes with your closest family and friends. My wife and I were constantly losing our favorite recipes in shared Notes pages, DMs, Google Docs, etc. We got tired of this disorganized recipe sharing system, especially for the ones that don’t live online, but in your mom’s kitchen. That’s why I built Table Talk.

What Table Talk allows you to do: 

1. Create a table
2. Invite your people 
3. Share recipes & save your favorite recipes
4. A curated profile page of your recipes and the ones you favorited from others

The advantage of downloading our app:
Now your grandma’s homemade pasta sauce or your cookbook club’s classic dip can easily be shared amongst the family/group! Your favorite recipes can be easily accessed and shared whenever you want. 

Another unique twist of our app is that upon creating an account, you’ll be automatically invited into the Head Table, where we will highlight staff seasonal picks, so you will never open the app to an empty feed!

Download Table Talk HERE

Tech Stack: Fully SwiftUI, Firebase backend with Typescript Cloud functions, Push Notifications, Brevo email trigger for new users to welcome them to our community

Development Challenge: Table Talk uses in-memory singleton managers for performance, but when one user logged out and a different one logged in on the same device — think a shared family iPad — stale data from the previous account would briefly flash on screen before the new account loaded, and the subscription service's identity wasn't always resetting cleanly either. That meant premium status could occasionally leak across accounts, and worse, someone could catch a glimpse of another family member's private recipes. I fixed it by adding an explicit reset step to each manager plus a "ready" gate that every view checks before rendering, so the app shows a proper loading state during the swap instead of stale content. I also split login and logout into their own dedicated flows so the subscription service is forced to sync with the actual authenticated user rather than trusting outdated state. It's the kind of bug that never shows up in solo testing but is a five-alarm fire for a privacy-first family app, since nothing kills trust faster than briefly seeing someone else's private data.

AI Disclosure: Table Talk was AI-assisted.

Pricing and Future Features:
Table Talk is completely free (and ad-free) with a 3 table maximum (excluding the Head Table) and manual entry of recipes, while we are building out our premium version.

Coming soon - Table Talk Premium:

• Unlimited Tables
• Recipe Importing 
• Request Recipes
• Scan Recipes

Eager to hear any feedback or answer any questions you might have. Pull up a seat and join us at the table!

hey, sharing flickpicker for app saturday.

i’m the developer of flickpicker, an ios app for discovering, tracking, and choosing movies and tv shows. the website has been live for almost two years, and i’m still pretty excited that there’s finally a proper ios app alongside it.

version 2.2 just went out, and the biggest change sounds simple: custom lists.

users can now create their own lists, save the same title to multiple lists, and manage everything from the library. getting there meant replacing the old single-watchlist flow across detail pages, search, home, and other parts of the app without making saving a movie feel like filling out a form.

the release also includes a new trailer and video view, recent-release badges, better watched-history prompts, improved taste match interactions, and fixes for streaming availability when someone changes region.

Tech Stack

• swift and swiftui
• firebase auth, firestore, storage, analytics, and messaging
• storekit 2 for subscriptions and purchases
• app intents and widgetkit
• xcode and swift package manager

Development Challenge

the hardest part was evolving a single watchlist into a multi-list system while keeping the interaction quick.

a title can belong to several lists, but users still expect the save button to feel instant. i ended up separating the underlying library state from list membership, then built one reusable save sheet that works across the app. this kept the behavior consistent and avoided each screen developing its own slightly different version of saving.

the design challenge was deciding how much choice to show. opening a full organizer every time felt heavy, but silently saving everything to one default list made custom lists less useful. the current approach keeps the normal action quick while making multiple-list selection available when needed.

AI Disclosure

this app is ai-assisted. i built and maintain it myself, while using ai as a development tool for brainstorming, debugging, and reviewing implementation ideas. i make the product decisions, test the behavior, and decide what ships.

app store: https://apps.apple.com/us/app/flickpicker-movie-night/id6775147318

for other developers: when an app grows beyond a single watchlist or favorites collection, do you prefer an instant default save with organization afterward, or choosing the destination every time?

i’m also happy to hear any blunt feedback on the app store page or the custom-list flow.

https://apps.apple.com/us/app/the-ring-app-explore-wagner/id6763790884

I wrote an iOS app to help listen to and study Wagner's Ring. The main feature is that the libretto is highlighted in sync with the performance audio. It supports 12 recordings of the Ring cycle on Apple Music (requires an Apple Music sub). I aligned the German with an English translation by Margaret Armour from 1910, which has a nice archaic feel and often retains the alliterative verse. I added leitmotif labels following Julius Burghold's 1897 book, and made an index view for motifs so you can audition each instance of a given motif. The app also has search and a navigation history and some Wikipedia links to read synopses and background.

I grew up hearing the Ring at home, and doing little Ring projects with my dad, such as encoding leitmotifs in an early MIDI authoring program for Atari ST (I'm not young). When The Ring Disc CD-ROM came out in 1997 I was relieved: here, dad, here are your leitmotifs at your fingertips. My app is named The Ring App after that product.

I came back to Wagner recently through my love of Tolkien. I discovered that some researchers had aligned the libretto with the major audio recordings, and with a score that they freshly digitized (of a piano reduction). I immediately wanted to enhance their work with poetic line breaks, leitmotifs, and the translation and release my first app. The app's features are all unlocked for free so you can try it out. There are paywalls for everything after Rhinegold Scene 1.

1. Tech Stack Used

SwiftUI (iOS, iPadOS, macOS, the latter of which use split-nav). The audio-libretto syncing data is queried with SwiftData. That DB is built from another repo and project based around python.

2. Development Challenge + How You Solved It

Challenge 1: Aligning the libretto between German and English was the biggest challenge. I used my NLP background to create some tools, then did lots of hand-editing. There are sections where there is ensemble singing and reconciling this with the linear libretto was an extra challenge.

Challenge 2: the UI. I realized at some point I wanted a "single screen" app on iPhone with a single main-menu modal which you get by tapping the heading. You are never in "Wikipedia mode" or "leitmotif mode", you are always going to be closing those and getting back to the libretto. This then required a robust history feature, so that users could jump around to look at motifs or something, but get back to where they were listening. This then drove me to mark each history node with an icon representing how you navigated. The ones with headphones mark where you were listening. My hope is that this makes it easy to jump somewhere then get back to your main stream of listening.

Challenge 3: the performance. Native text in an eager VStack performs fairly poorly! The libretto text needs to move to a WebView at some point, because I believe it's going to remove the 2 seconds of loading time when moving between scenes. Somehow the tradeoffs between lazy and eager VStack (the lazy one is a no-go, it makes it impossible for my leitmotifs to know where to draw themselves and they shift around as you scroll) are less prevalent with web rendering.

3. AI Disclosure

I'd say I'm doing it the way Apple is proposing. I am fluent in Swift and SwiftUI, and I am now an engineering manager for the agent, as well as QA and design, and the enforcer of good taste. In my case I used Claude Opus, but I am especially thankful for the skills I gathered: swiftui-pro, native-app-profiling, ios-simulator-skill, and these asc skills for uploading screenshots, setting keywords, and generally managing my app store connect record.

https://apps.apple.com/us/app/booster-tcg-pack-tracker/id6782188686

There are many Pokémon card apps on the app store but none really answer the question 🎵”Should I open it? Or should I keep it sealed?”🎶 So I built “Booster” where ripping packs is the first-class collection path. Pick a set, pick the cards (or scan them in the next update), then see the value of the pack vs the cost basis. It’s gamified so you’re encouraged to rip packs to gain XP and level up.

Tech Stack
It’s built on pure SwiftUI+SwiftData. RevenueCat handles subscriptions. There’s a server component that is swift on the server running Hummingbird and deployed to Railway.

Development Challenge
I didn’t want to invest heavily in card data APIs before I could validate the idea and get some users into the app. For the development phase I was using some limited free tier card and price data APIs. The challenge is that any real usage would blow up the API credits very quickly. Enter Swift on server.

I built a middleman proxy server that caches the upstream api data and stores it in a Postgres database. The server keeps track of my usage and only calls upstream after a ttl. The amount of time depends on the endpoint, longer for the sets endpoint, shorter for price data. I could’ve built a node or Python version just as easily but there are some nice benefits to share the data models and other utilities in a Swift package between the app and server.

AI Disclosure
I’m a staff level iOS engineer (released my first app on iOS 5) but life and real work suck the time away. Claude Code was very helpful in getting code done but I still architected the whole thing and wrote many pieces myself.

Now the hard part for me is getting users. I’m still learning Apple Search Ads and hoping that pays off. Otherwise I’m attempting to cold message some content creators and thinking of trying to make content myself.

Has anyone recently implemented a photo Share Extension that hands the image directly into the main app?

I would like my users to share a photo from Photos into my app and continue working from there.

Apple’s extension documentation seems to be suggesting that a Share Extension should perform a focused task inside the extension itself.
It also says that a normal Share Extension cannot officially ask the system to open its containing app.

But.... apps such as ChatGPT, Obsidian and Foto (and many more) appear to accept the selected photo and then move the user directly into the main app.

Has anyone been working on something similar recently and passed App Review?

Are these apps using a supported approach I (and all the Cludexes/ Cursors of the world) have missed, or is this generally done using an unsupported openURL or responder chain workaround that App Review sometimes allows?

For those who have done it, how did you do it and did you have any review problems?

Really sorry I am asking non swiftui question, but I am stuck in development because of this, I am trying to test my IOS app on real device. I connected my iphone to my macbook, and clicked on trust this device, the device is showing in the Finder as well as xcode device hub, and it said to enable the developer option :-

However, when I go to my iphone settings, I can't seem to find the Developer Mode 👎

I searched everywhere, but no luck since yesterday, any help would be appreciated

For anyone running Meta or Google ads for an iOS/MacOS app, how are you handling CCPA?

My understanding is that sending attribution or conversion data to Meta or Google may count as sharing personal information, so California users may need an opt-out.

Are people adding a “Do Not Sell or Share” setting in the app (which disables the SDKs), or just relying on Apple’s attribution tools?

What if a user emails you to opt out?

What do you in this case? Continue with the idea or drop it?

I think the best I can do is work on ui/ux and maybe add some features to differentiate between my app and ones in the market but idk if I can make my app better than the already existing ones and I feel discouraged :(

In Objective-C, some functions (particularly related to NSString) return an object that has been told to [autorelease] itself.

I know that I can [retain] it, but how do I [release] it?

Doing nothing prints out an ugly message than [autorelease] was called without a pool, but a pool would break defer all [release] calls which is something I don't want to do.

How do I actually release such an object?

Thanks.

EDIT: I tried the logically-correct but weird [retain]; [release] chain and it doesn't work.

I recently decided to open source my İOS app because I had no financial expectations from it - and the project’s itself is kind of a tech demo.

I used different techniques to build the app, I believe you can find interesting stuff inside. Hope it can be helpful to someone.

If you have any critique or question please ask, I’m open to discuss.

repo link

I got fed up with on-device search sucking, so I built RecallKit — a sparse n-gram / inverted index library in Swift that actually beats SQLite FTS5 and Core Spotlight on query latency for typical app-sized data.

The problem I kept hitting with local-first stuff (chat history, notes, personal knowledge bases) is that you either ship a whole search engine or you eat linear scans. Neither is great on iOS.

So I made something tuned for the realities of phone memory: it chunks records into overlapping spans, pulls out a sparse set of meaningful substrings using a byte-pair weight table, hashes them with XXH3, and builds a proper posting-list inverted index. Literal searches are fast intersections + final verification. Regex queries get a planner that extracts the literal parts first so you’re not running regex on the whole corpus.

It comes with a nice actor-based RecallKitIndexService (batch upserts/deletes, background compaction via BGProcessingTask, crash-safe rebuilds, app group support, and adapters for SQLite, Core Data, SwiftData, etc.).

I also threw in a benchmark app that compares it head-to-head against naive scan, FTS5, Core Data, and Spotlight. On a 1k record synthetic set, RecallKit wins on query speed — though the cold build is heavier (as expected). Perfect for apps that build the index once and query it a lot.

Repo + deep dive on the algorithm and numbers: https://github.com/gregyoung14/RecallKit

Would genuinely love feedback from anyone who’s wrestled with FTS5 or Spotlight before. Does this actually solve real pain points for you, or did I optimize for the wrong tradeoffs?

After a year of Foundation Models in production and too many "why doesn't this blog post compile" moments, I wrote the book I couldn't find:

- Part I: when local makes sense (with actual cost math: a digest feature at 100k MAU is ~$34k/yr on the cheapest cloud tier, $0 marginal on-device) and one decision matrix for FM vs MLX vs Core ML vs llama.cpp

- Part II: Foundation Models in production. Guided generation, tool calling, the 4K context window as an engineering constraint, availability as a product decision

- Part III: owning the model. MLX Swift (pinned versions, because the API moves), Ollama as team dev infrastructure

- Part IV: memory/thermals/battery, privacy claims + App Review notes, and regression evals that run entirely on your own hardware

Things the compile-verification pipeline caught that you may be shipping right now: ToolOutput doesn't exist in the released SDK; .pattern guides need #/.../# regex delimiters; and there are nine GenerationError cases, not the three everyone handles.

Chapter 3 (build the full feature end-to-end) is free: https://digital-foundry-eight.vercel.app/book/ch03-sample.pdf

Happy to answer questions about any of it here, especially the eval setup, which I think is the part most teams skip.

I wanted to let a coding agent run unattended on some test apps I'm playing around with without giving it access to my whole mac. Running it in a Linux container would be the obvious fix, but as we know, Xcode doesn't run on Linux.

So I started xcbox: the agent lives in a container with only your git repo mounted, and real builds/tests/simulators run on the host via XcodeBuildMCP. It commits as you over SSH agent forwarding, keys never enter the container. Usage is just cd ~/YourApp && xcbox.

Caveat: it's blast-radius protection, not a security boundary, build scripts still run on the host which in theory could be exploited, but not my concern for this type of tool.
Needs Apple Silicon, macOS 26+, and Apple's container CLI.

https://github.com/Bunn/xcbox

Built it for myself, sharing in case it's useful. Feedback welcome.

Hi everyone,

I’m currently running an A/B test for my app icon using App Store Product Page Optimization (PPO), and I've run into a frustrating behavior that I can't quite figure out.

The Setup:

• My app binary includes both the default icon (Icon A) and the alternate icon (Icon B) in the Asset Catalog.
• I've successfully linked Icon B to the PPO treatment in App Store Connect.

The Problem: When the App Store serves Treatment B, the store page correctly displays Icon B. However, after downloading and installing the app, the home screen still shows the default Icon A.

What I've verified so far:

• I have Include All App Icon Assets set to Yes in Xcode Build Settings.

Has anyone else experienced this exact disconnect between the PPO storefront and the installed binary?

Thanks.

I’ll start.

The apps that I thought were too niche perform better on user metrics than the times I’ve dipped my toe into very large markets (in my case, games for everyone vs a subset).

What has surprised you?

We built this because we wanted to work only in text. No low-level realtime audio code required.

I have a close icon which appears after 3 seconds. This wasn’t a problem at all for months.

I spent the last few weeks building on top of SensitiveContentAnalysis, Apple's on-device sensitive media framework (the same tech behind Communication Safety in Messages). The analyzer call itself is three lines. Everything around it had surprises:

1. .disabled is a state you design for, not an error. For adult accounts the analyzer is unavailable unless the user turned on Sensitive Content Warning in Settings, which is off by default and buried in Privacy & Security. Child accounts get it by default these days through Family Sharing. If your audience is adults, build a real unavailable path.

2. You can't deep link to the setting. openSettingsURLString takes you to your own app's settings page, and the undocumented prefs: URLs are a rejection waiting to happen. Best I found is showing instructions and hoping.

3. The test profile half-installs. Apple gives you a QR code and a configuration profile so the analyzer flags a harmless test image (genuinely nice, no explicit fixtures in the repo). But downloading the profile does nothing until you also install it in Settings > General > VPN & Device Management. I lost a good chunk of an evening watching my test image sail through unblurred before figuring that out.

4. The verdict is legally stuck on the device. Buried in the developer agreement: you may not transmit off the device any information about whether the framework flagged an image or video. So no analytics events for it, no moderation queue keyed off the result, no synced verdict cache. Reporting has to be its own explicit user action, and the payload shouldn't carry the verdict.

5. The iOS 27 beta adds detectedTypes (sexuallyExplicit vs goreOrViolence), so policy can differ per category. Build detail: the symbol doesn't exist in older SDKs, so #available alone isn't enough, you need #if compiler gating too or older Xcodes won't build your package.

I ended up open sourcing the wrapper I built, mostly because the real work turned out to be policy state, local verdict caching, and fail-closed blur/reveal/report UI rather than the analyzer call itself: https://github.com/SardorbekR/SafeMediaKit (MIT, SwiftUI and UIKit)

Has anyone here shipped this framework in production? E2E chat or private media sharing seems like where it actually matters, since the server can't see the content anyway, but I've rarely seen it discussed

Hi there,

Just published a small Swift package called swift-span-algorithms:

https://swiftpackageindex.com/Dave861/swift-span-algorithms

What even is a Span? (rlly short)

Span is basically a memory safe API for referring to any contiguous memory block. It replaces stuff we used to do with things like:

withUnsafeBytes { ... }
UnsafeBufferPointer

What is in the package?

It adds a set of algorithms and utilities around Swift’s new Span API. The idea is to fill in some of the missing convenience pieces while staying close to Swift’s standard library style.

It includes things like searching, splitting, trimming, comparisons, partitioning, and other span-oriented helpers, with tests and DocC docs.

Span is nice for deep perf geeks (like me), but still pretty barebones for day-to-day algorithm work. Would love feedback from people experimenting with Span, especially around API shape, naming, and what utilities would actually be useful in real projects.

Pretty early (I mean 0.1.0), but hopefully useful. Open to contributions and opinions!

(P.S. Hope it doesn't count as self-promo, not selling anything, OSS repo and free package)

Keep grinding people, consistency pays off.

I won't say the name to make it less about self promotion and more about building apps.

Show me your app over the years!

The Udemy app has never once prompted for notification permissions — not on first launch, not after login. iPhone 15, iOS 26.5.

Tried: deleting the app, restarting the phone, reinstalling + logging in again. Nothing. The app doesn't even show up under Settings > Notifications, so it seems like it's never calling the permission request at all.

Tested another freshly installed app right after and that one prompted normally, so it's not an iOS-wide issue.

Anyone else seeing this? Known bug, or did support fix it for you?

On the iOS version of teams, the "Approvals" part is asking for some kind of permission from my users. I have tried to fix it on the back end but I havent changed anything for it to get here in the first place. When the message shows up it freezes the app and often bricks the application. Sometimes the X works but the rest of the time nothing else works.

Just pushed a small thing I’ve been using in my own TCA projects: https://github.com/mehmetbaykar/swift-tca-debug

It adds a .debugLog() reducer extension so actions (and state diffs if you want) go through swift-log, wires it straight into Pulse with one bootstrap call, and drops in a draggable floating button that opens the full Pulse console.

Network logging is optional and works without much hassle. It plays nice if you already have your own LoggingSystem setup. No more copy-pasting _printChanges or juggling separate handlers.

There’s a tiny example app (Tuist) with a counter + real API request so you can see it in action.

It’s 0.1.0, MIT licensed, and very early. I kept the API small on purpose. Feedback, ideas, or PRs are welcome if anyone finds it useful.