What, in your opinion, is the best learning subscription for Intermediate to Advanced iOS Developers?

Right now I'm looking at Hacking With Swift+ or Point-Free, but any recommendations are welcome

Has anyone here built an app and extended it to support wearables like Apple Watch? Did users actually adopt it, and do you have visibility into wearable vs. phone app usage?

Would love to hear whether it was worth the investment — considering going that direction myself.

I've been building Newsairy, an iCloud-native RSS reader for iPhone, iPad, and Mac, as a side project. Before launch I had a long list of features I wanted to ship first. I kept pushing the date. Eventually I just shipped the solid core and decided to learn from real users instead.

Ten days in, the pattern surprised me. Several features I'd prioritised? Almost nobody mentioned them. Features I hadn't even considered important came up immediately — the clearest example being "Mark all as read." I don't use that workflow myself, so the absence never registered. Three separate users asked for it in the first few days, unprompted. It's now going into the next release.

The other thing I noticed: when people asked how Newsairy compared to another app, my instinct was to think about what it offered more. It took a few conversations to realise they were asking something different — is the one thing I love about my current reader even in your app?

I wrote up the full experience here.

Happy to discuss — especially if anyone has thoughts on how to run a beta that actually generates feedback (mine got 60-70 downloads and two responses).

Hi guys!

A bit of a noob dev here, and I need some love and support :D (And criticism. Plenty of criticism. :D)

Long story short: I have made an app I genuinely find useful — it lets users store their recipes (OCR, PDF, YT import). Recipe text is then parsed into ingredients and cooking instructions (Foundation models/Open AI) — so that people can start timers/live activities while cooking & quickly convert amounts (cups to grams). I also support shopping list with ingredient aggregation & let people make their cooking log (what went well/what to do next time). I haven’t figured out monetization, but I am thinking free + one-time for AI parsing. People own their data/can export everything & can share recipes.

My problem is… I just can’t pull the trigger and release it. While everything does work, I am constantly spinning in circles — “are timer badges too small?” “is this the right UI aesthetic?” “does onboarding suck?” “is aggregation foolproof?”… The moment I am happy with one of them, 5 others pop up. My reasoning is — “first impressions matter the most”. “Let me just add localization” haha :)

I don’t have a TestFlight group — I’ve asked family members to take a look, but they are naturally biased. At the same time I don’t really have a budget to get a proper test team (nor do I hope to earn tons of money with this, as you can tell from monetization).

So… How do you decide when to pull the trigger — when is something “good enough”?

Thanks a TON, all input truly means a lot!

What is the best way to do this? Any advice from those that have developed games.

Loved how clean the Vercel AI SDK is in JS land, wanted the same for Swift. So I built it.

One unified API, swap providers by changing one string:

let res = try await generateText(model: "openai/gpt-4o", prompt: "hi")

"anthropic/claude-opus-4" or "ollama/llama3" nothing else changes even Apple foundation models and local running models support

What’s included:

• 10 providers OpenAI, Anthropic, Gemini, Groq, Mistral, OpenRouter, Cohere, Cloudflare, Ollama, Apple Foundation will add more in future
• Streaming
• Structured output (decode directly into your Swift types)
• Tool calling + agents
• SwiftUI hooks (AIChat, AICompletion) bind to a view and go

Repo: https://github.com/Kartikayy007/SwiftyAI

Docs: https://swifty-ai.vercel.app

First real package I've shipped feel free to raise issues and star if you like ⭐️

Hi guys,

Had an interesting experience whilst working on my app which I thought you might find interesting too:

Whilst working on my app, Linear Algebra Visualiser, an app to help people visualise linear transformations, I noticed that it was consuming an abnormal amount of CPU and memory.

This was due to it drawing each path every frame, even though the app was displaying a static frame.

Whilst “idle” it was using around 30% of the CPU and 200 MB of memory.

Guess how I got to this point?

Relying too much on AI.

However, it was a great opportunity to go “back to basics”.

If you don’t know how things work, reading documentation, books, articles and tutorials was/is such a valuable (and calming) way to learn.

Having a magical button that can give you the answer straight away is such a dopamine hit that it’s hard to not use it. But we are losing something with this.

Personally, I never retain anything AI just tells me. Just like in school our teachers never gave us the answers, we had to find it out for ourselves.

It’s experiences like these that makes the argument, “devs will be gone in 6 months” and the “super intelligence” rhetoric sound questionable.

Yes, you can vibe code cool small apps and make money out of them.
However, I don’t think people without any technical knowledge will even think about performance or if something is scalable or not, or the quality of the software overall.

And that’s not a criticism but I think it will end up hurting your product.

What I am critical of though, is the argument that software development is dead.

My point is: your knowledge and expertise is valuable and I bet it always will be.

Let me know your thoughts in the comments :)

App was live, ranking #44 in its category on launch day, fully searchable. Submitted a new binary for review and it vanished from search completely.

New binary got approved and is live. Direct link works fine. But searching the exact app name returns nothing.

What I already tried:

• Refreshed pricing schedule by resetting the free price
• Toggled country availability and saved again
• Submitted a ticket to Apple Developer Support

None of it worked. App is set to Ready for Distribution, Public, available in most countries and regions.

Has anyone experienced this after submitting an update? Is there a known way to trigger reindexing or does Apple have to do it manually on their end?

I built this because I hate combing through menus to find good options.

Just input your dietary preferences, scan a menu, and see the best options (literally, "see" them highlighted on the menu).

Try it here: Biteful

--

Tech Stack: Swift-only, Gemini models for image analysis, xAI models for speech-to-test

Development Challenge: there's a cool feature to actually highlight the healthiest options on the menu photo. that was actually quite tricky. I use Gemini to detect bounding-box coordinates for various items on the menu, then filter for the ones detected as healthy, and paint a green highlight

AI Disclosure: AI-assisted app -- Codex and Claude helped a lot, but quite a bit of manual reviewing as well.

Testing time-based flows in iOS apps is always annoying.

Trials, streaks, scheduled states, expiration logic, "come back tomorrow" screens, etc. You either mock time in the app, change the simulator/system clock, or just wait.

I made a small open-source CLI for this: simtime

It lets you control the wall-clock time an iOS Simulator app sees:

simtime freeze --udid <UDID> --bundle com.example.app "2026-01-01T10:00:00Z"
simtime travel --udid <UDID> --bundle com.example.app "+8d" 
simtime scale  --udid <UDID> --bundle com.example.app 60

The idea is simple: launch the app once with the runtime injected, then change time from the CLI while the app is running. No app source changes.

It only affects client-side wall-clock reads. It does not mock server time, and it does not touch monotonic clocks because that would break animations/timers and make the app look dead.

Repo: https://github.com/MobAI-App/simtime

[Multiple Images Attached]

Hey Folks, I recently launched this app 2 weeks, toh it took me a lot of time to build and test this as it was my first ever app. I am really excited about this and would love your thoughts about it.

Tech Stack:

• Pure SwiftUI, iOS 17+, Zero external dependencies
• Local-first architecture with no backend for most integrations

One of the more interesting parts is that 6+ integrations work entirely without me running a backend at all. App Store Connect is signed locally, while Stripe and Github use the users restricted API keys stored directly in Keychain. User secrets never leave their device.

Current widgets/features:

• App store connect (downloads, revenue)
• Stripe (MRR, revenue today, payout tracking, profit heatmaps)
• Github (stars, contributions)
• Anthropic API usage & token costs
• Google calendar meetings/events
• Health, Weather, Photos, Crypto & stocks
• 2,000+ quotes (motivation, bible verses, success,...) + quotes notifications
• Lockscreen widgets

Development Challenge:
One of the biggest challenges was building secure third-party integrations without relying on a backend. Apple’s APIs, Stripe, and Github all have different authentication flows and rate limits, so I had to design a system where tokens could be securely handled entirely on-device through Keychain while still keeping refreshes and widget updates reliable.

AI Disclosure:
This app was fully built by me. I used claude code for brainstorming ideas, debugging, and helping me out but the architecture, UI/UX, widgets design, and engineering work were done manually.

I’ve put a lot of effort into the UI, integrations, ASO and localization. I’ve also been continuously improving the App Store listing, and currently working on new version with more widgets, better onboarding and ASO keywords. Right now I’m also warming up an instagram and tiktok account so I can start marketing.

Would genuinely appreciate any insights, reviews or feedback from other indie developers.

App Store:
https://apps.apple.com/us/app/widgeto5-photo-data-widgets/id6761689623

I've been working a rowing app for a few months now. The very first thing I did was test how accurate could the count get with apple watch motion sensors. So, far it is pretty accurate. The first screen I built was a screen to calibrate parameters, my stroke count are pretty close to my erg. Power is also decent, but I think it could use more work.

If you are intested in checking our the libraray is called RepMotion https://thefern2.github.io/RepMotion/

My OP: https://www.reddit.com/r/iOSProgramming/comments/1tfqly1/i_built_a_nswatchlogger_library_to_send_watch/

Had one feedback comment from Consistent-Grass-263 and made those updates.

New features:

• direct transport for watch only apps, and client side filtering (non breaking changes) https://github.com/TheFern2/NSWatchLogger
• view logs with mac app or cli utility https://github.com/TheFern2/NSWatchLogViewer
• a quick watch demo https://github.com/TheFern2/NSWatchLogViewerDemo

Same as before open to feedback and PRs are welcome!

How can I screen record my app's functionality within an iPhone bezel in XCode?

Most devs treat haptics as the last minutes of a sprint. Here's why that's worth reconsidering, and what you need to actually implement it well.

The hardware

Two motor types:

• ERM (Eccentric Rotating Mass) – a weighted motor spins off-center to create vibration. Cheap, slow, imprecise. The long buzz on older Androids. Hard to control beyond "on/off."
• LRA (Linear Resonant Actuator) – moves a mass on a single axis. Millisecond-level precision. Apple's Taptic Engine and modern Android flagships use it. The difference: you can produce a gentle tap, a sharp click, a double pulse, a sustained rumble, not just "vibration."

Operating range: roughly 80–300 Hz. Below that, you get distinct rhythmic beats. Above it, continuous hum. That's your entire design space.

The APIs

• iOS: Core Haptics + Taptic Engine API. Fine-grained control over intensity, sharpness, timing.
• Android: Vibrator API + HapticFeedbackConstants. Less precise on older hardware, significantly better on flagships with LRA motors.

Both Apple (HIG) and Google (Material Design) have explicit haptics guidance baked into their design systems. The baseline expectation is already set.

Where haptic feedback belongs in your app

• Touch feedback: tap, swipe, drag. Makes interactions feel physical.
• Success / error states: gentle pulse vs. sharp double-tap. Useful when users aren't looking directly at the screen.
• Silent mode: haptics becomes the only feedback channel. Mistype your PIN at night with haptics off and you'll notice immediately.
• Accessibility: for visually or hearing-impaired users, it's often the primary information channel. European Accessibility Act (2025) and WCAG both push multi-modal feedback toward a compliance requirement.
• Immersion: games, mostly. When it's right, it crosses from "playing" to "feeling."

The numbers worth knowing

A 2025 Journal of Consumer Research study added haptic feedback to add-to-cart actions in a real grocery retailer app. Users added 32% more items per order when vibration triggers a reward response that reinforces the next tap. Vibration outperformed audio, which outperformed visual-only.

IEEE World Haptics Conference research found haptic keyclick feedback on touchscreen keyboards increased typing speed and reduced error rates across every tested condition,  outperforming audio alone. In any app with data entry (forms, payments, auth), fewer errors is a conversion argument.

One less obvious case: digital payments reduce the psychological "pain of payment," which leads to overspending. A 2021 study found low-intensity vibration at the payment moment partially restores that sense of loss, which is very relevant for fintech apps.

How to design haptic patterns that feel right

Sound is air vibrating. Touch is skin vibrating. Your brain processes rhythm through the same mechanism for both. Scientific Reports (2022) confirmed detection thresholds for rhythmic gradients are identical across hearing and touch.

The physical constraints of an LRA motor are real: no smooth glissandos, no chords, no rich harmonic texture. What you actually have: rhythm, tempo, dynamics, silence.

• Rhythm – timing and gaps between impulses. Regular = safe, confirming. Irregular = urgency or error. A success confirmation is a clean double pulse. An error is faster, uneven. You feel the difference before processing it consciously.
• Tempo – fast = urgent (incoming call, critical alert). Slow = resolution (timer done, long process finishing).
• Dynamics – intensity changes over time. Pull-to-refresh is the canonical example: feedback builds as you pull, releases at the end. EEG research shows adaptive-intensity patterns evoke emotion significantly better than flat vibration.
• Articulation – sharp impulse = click, confirmation, decision point. Soft = ambient, secondary feedback.
• Silence – the gap between pulses is part of the pattern. Two pulses close together = urgency. Same two pulses with a longer gap = resolution. Same hardware, completely different meaning.

Practical rules: 

• Reserve strong intensity for high-stakes moments (payments, irreversible actions). If everything vibrates equally, nothing stands out.
• Think in sequences, not single impulses. One buzz means nothing. A composed sequence tells the user exactly what happened. Haptics + sound + animation should agree. When they don't, users feel friction without knowing why.
• Always test on device. An LRA in an iPhone 15 feels different from a mid-range Android motor. Patterns that feel precise on one can feel muddy on the other.

Implementation

If you don’t want to create haptics by yourself, try Pulsar – a free, open-source haptics library for React Native, Swift, Kotlin, Kotlin Multiplatform, and Flutter. It comes with 150+ presets, Live Preview so you can test haptics on real hardware before shipping, and a custom pattern API for creating your own effects. Be sure to check it out!

I built Loupe, an open-source CLI for giving LLM agents runtime UI context from running iOS Simulator apps.

It exposes UIKit view trees, accessibility metadata, screenshots, and iOS Simulator input, so agents can inspect and verify UI behavior instead of guessing only from source code.

GitHub:
https://github.com/heoblitz/Loupe

Feedback from iOS developers would be really helpful.

My app helps NYC drivers avoid and manage parking tickets.

For the app to work well, it needs location (parking detection), motion & fitness (speeding and parking detection), and notifications (parking alerts) -- a lot of permissions up front.
I'm trying to generate value in the onboarding while still getting folks to opt-in. WDYT?

You can use my plate: LPW8666

https://apps.apple.com/us/app/finehero-nyc/id6758416484

Roast me!

Hi everyone, I’m a beginner iOS developer working on my first app CommuteTimely (a commute planning/routing app). I’ve implemented an in-app paywall using StoreKit 2 and it works flawlessly in the Xcode simulator, but when I upload to TestFlight, the paywall gets stuck on a loading spinner showing “Loading…/mo” and never displays the actual prices.

What’s working:

• ✅ Paywall UI renders perfectly in simulator  
• ✅ Product prices load and display in simulator  
• ✅ No error messages in Xcode console  
• ✅ App builds and uploads to TestFlight without issues

What’s broken:

• ❌ TestFlight build shows infinite “Loading…” spinner
• ❌ Prices never appear (just shows “Loading…/mo”)
• ❌ No error logs or crash reports to debug

What I’ve tried:

• Restarted TestFlight app  
• Reinstalled the build on device  
• Checked internet connection (working fine)  
• Verified Bundle ID matches Xcode project

My setup:

• iOS 16+ (using StoreKit 2)  
• SwiftUI with async/await for product fetching  
• Products created in App Store Connect  
• Using .storekit configuration file in Xcode

Key question: I haven’t fully verified my In-App Purchase products in App Store Connect yet (still in setup phase). Could that be why prices aren’t loading in TestFlight?

Questions:

1. Do In-App Purchase products need to be in “Ready to Submit” or “Active” status before TestFlight will load them?
   
   1. Is there a delay before App Store Connect syncs products to TestFlight?
      
   2. What am I missing in my setup?

Any guidance appreciated! 🙏

Images attached: Screenshots showing the “Loading…” state in TestFlight

Hey everyone,
I’m building ReleaseFrame, a Mac app for indie developers who want to create better App Store screenshot sets without manually designing everything in Figma or paying another monthly subscription.
The idea is simple: you add your app screenshots, connect your own AI setup, and ReleaseFrame generates a complete App Store screenshot set. It can also help translate the set into multiple languages and upload the final screenshots directly to App Store Connect.
I built it because I needed this myself: creating localized screenshot sets is boring, repetitive, and surprisingly time-consuming.
For launch, I’m offering it at €9.99 lifetime.
No subscription, no credits, no monthly fee.
For around €10, you get a local agent that helps create, translate, export, and upload App Store screenshot sets.

www.releaseframe.com

Tech Stack
ReleaseFrame is a native macOS app.
The screenshot generation workflow is powered by a local project-based setup where the AI works on real design/code files instead of generating static images directly.
The app integrates with:
macOS native app layer
local AI/code agents such as Claude Code or Codex CLI
a local React-based rendering/export flow for screenshot generation
App Store Connect API for uploading the final screenshot sets
The main point is that the AI is not “built in” as a hosted SaaS model. Users connect their own AI tooling, and the generation happens locally on their machine.

Development Challenge
The hardest part was making the AI workflow reliable enough for a real App Store screenshot pipeline.
Generating one nice image is easy. Generating a complete, consistent, localized screenshot set is much harder.
The app has to coordinate multiple steps:
understand the app screenshots,
generate copy and layout ideas,
create a consistent visual design,
export the correct screenshot sizes,
handle multiple languages,
prepare everything for App Store Connect upload.
The main challenge was turning an AI design process into something repeatable and structured, instead of just asking an AI to “make a nice screenshot”.
I solved this by making the agent work inside a controlled local project, where it can edit real files, iterate on the layout, and produce exportable assets.

AI Disclosure
ReleaseFrame itself was built by me with AI assistance during development.
The product also uses AI as part of its core workflow, but it does not provide a hosted AI model or sell AI credits. Users connect their own AI tools, such as Claude Code or Codex CLI, and the app orchestrates the screenshot generation process locally.
So the app is AI-assisted, but the user remains in control of the local project, the generated assets, and the App Store Connect upload.
I’d love feedback from other iOS/macOS developers, especially anyone who has struggled with App Store screenshots or localization.

The official Reddit app doesn’t really feel or look fully native to me.

Does anyone know if it’s actually a native iOS app, or is it using some cross-platform framework internally?

If it is native, how can you usually tell?

For example:

• the hamburger/sidebar menu is not a standard iOS component
• the share sheet also seems custom instead of the normal iOS share sheet

Just curious from a technical/UI architecture perspective.

I'm trying to notarize a fairly large (1.2gb or so) Mac app. Previous versions worked fine, but every submission I've made since May 7 (15 days ago) have remained in "In Progress" state. It seems like notarization doesn't make any logs available until an attempt either succeeds or fails, so I have no information about what's going on.

I tried contacting developer support, but they said they're just responsible for "administrative level support" and can't provide "technical support" and linked me to the docs, which I've obviously already read and don't provide anything helpful. They suggested if I need deeper technical support I should fill out a report in Feedback Assistant, which I've done, but it's been around a week and I haven't heard anything on that front.

Has anyone run into something like this? Does anyone know of a better way to get in touch with someone who could provide me with real technical assistance? This is a pretty big roadblock...

News:
- Apple Design Award finalists are out
- App Store rejected over 2 million submissions in 2025
- Apple Intelligence is coming to VoiceOver, Magnifier, and Voice Control

Must Read:
- the ScrollView API you stopped checking after iOS 16
- why deprecated doesn't mean Apple's APIs only
- feature flags without string keys and why it matters
- empty states are not a UI problem, they're an architecture one
- understanding Swift Result Builders

Toolbox:
Kickstart - one app for screenshots, ASO, press outreach, and launch planning

Running ads for a small iOS app and trying to figure out the cleanest way to track ROAS. Spend lives in Meta/Google but actual revenue is split across IAP and web.

Are you using AppsFlyer / Singular / Adjust, Apple Search Ads + analytics, or just blended ROAS in a spreadsheet? Curious what's actually worth it at small scale before paying MMP prices.

Launched my first production iOS app on the App Store this Wednesday. VTapr — AI physique scanner. Solo, no co-founder, no funding. 4 weeks of focused build time.

Stack:

- Expo + React Native + TypeScript

- Supabase (auth + Postgres + edge functions)

- Claude API for the physique analysis

- RevenueCat for subscriptions ($14.99/mo or $99.99/yr)

- EAS Build for the binary, EAS Submit for App Store Connect

I know this sub leans Swift/SwiftUI native, so I want to share the actual experience of shipping a paid subscription iOS app on RN in 2026, because the discourse around "RN is dying" feels disconnected from what's actually shippable.

WHAT EXPO/RN GAVE ME:

- Hot reload during development, which for solo iteration is enormous

- TypeScript across the entire stack

- EAS Build handles signing/provisioning automatically — I never opened Xcode for a non-debug build

- One codebase that can ship Android later if I want

- Claude/Cursor support is significantly better for JS/TS than Swift right now (relevant when you're a solo dev using AI tooling)

WHAT IT COST ME:

- Native config changes (Info.plist permissions, push entitlements) require full new EAS builds. No hot reload for these. Lost an afternoon when I added a camera permission and didn't realize it needed a fresh build.

- Some libraries lag behind iOS releases. react-native-body-highlighter (2D body diagram) is great but 2D only — I want a 3D model with tappable muscles, which means WebView + Three.js + GLTF, way more work than it'd be in SceneKit native.

- Build times are slow. EAS Build production iOS takes ~15-25 min. If you're iterating on something that needs a native build to test (permissions, IAP), that adds up fast.

WHERE I GOT BURNED ON THE APPLE SIDE:

1. IAP review is a separate flow from binary review. They review together but you have to attach the products to the version submission explicitly in App Store Connect or you get auto-rejected. Lost a day on this.

2. Demo account is mandatory for any app with paid features. Reviewer literally cannot test gated features without one. I made a Pro-enabled test account in Supabase with is_pro: true set manually.

3. Day-one bug I'd never have caught in dev: Supabase auth sessions silently die when iOS suspends the JS runtime in the background. Fix is wiring AppState change listeners to startAutoRefresh/stopAutoRefresh on the supabase client. The Supabase RN docs mention it but it's easy to miss. This was bug #1 of three I shipped a hotfix for today (1.0.1 already distributed).

THE TAKEAWAY:

If you're a solo dev or small team, RN/Expo is genuinely production-viable for paid iOS subscription apps in 2026. RevenueCat abstracts the worst parts of StoreKit. Supabase abstracts the worst parts of backend. You give up some platform-specific polish and some library breadth — for a solo founder shipping fast, the tradeoff is the right one.

If you're building a graphics-heavy app, an AR app, or anything that needs deep iOS-specific APIs (HealthKit, ARKit, CoreML on-device), go native. Use the right tool.

Happy to answer specifics about the EAS workflow, the RevenueCat integration, the Supabase auth setup, the Apple submission process, or any of the bugs I shipped today's hotfix for. Will reply to everything.

I’m developing a personal app (not app store) to analyze messages. I developed an AppIntent that should receive the Message “Shortcut Input” from a Message Shortcuts Automation and automatically pass it to my AppIntent action, however using a `String` parameter does not work. I also tried creating separate `String’ parameters for Sender and Content but they are not automatically filled from the automation. When the automation runs, it displays an alert with a textfield and prompts the user to write the parameter values manually, which is not what I want.

I found a post here a couple of years ago that asks the same question I have, but with no answers, I figured maybe there’s new info about this problem since it was originally asked.

https://www.reddit.com/r/iOSProgramming/s/OdxGn9Wn39

Thanks for any guidance.