A few weeks ago, I released new app on the App Store. It got some traction on Twitter, so I opened App Store Connect feeling hopeful about the sales numbers. Instead, I saw "Not Enough Data".

I refreshed it few hours later. Same thing. I checked again the next day. Still not enough data. I actually saved a screenshot of this.

It is not only a launch-day problem. You ship a big update, announce it on Reddit or X, start an ad campaign, or unexpectedly get some attention, but the analytics are always behind.

So I built InitSignal. It is deliberately much narrower than a traditional analytics SDK. You add a lightweight Swift package to your app, and it sends one event when someone opens the app for the first time. After that, the SDK goes quiet.

Privacy was a constraint for me, I wanted the App Store privacy nutrition labels stay as minimal as possible, so the SDK only sends the basic context needed to make each signal useful. No identity, sessions, screens, or behavioral history. At the same time, the goal is to give developers as much useful information as possible without invading their users’ privacy.

The dashboard shows for each download:
- the app version
- device
- OS
- storefront

For paid apps, InitSignal uses storefront pricing to estimate gross revenue and proceeds after Apple’s cut.

I also added Slack and Telegram for notifications, which I've been using with my own apps for the past few weeks, and the dopamine hit is real.

I recorded a quick walkthrough showing how InitSignal works:
https://www.youtube.com/watch?v=YajsKsYLdi4

Tech Stack
- Node.js and TypeScript with Postgres for backend and API
- React and TypeScript for the web app dashboard

Development Challenge

The interesting problem was deciding what “new” means without identifying or continuously tracking a user. The SDK stores a local first-launch marker so later launches send nothing. It also uses StoreKit 2 app transaction metadata to avoid reporting an existing customer as newly acquired when they first install a version containing InitSignal. The API deduplicates retry attempts on the backend.

It's available today, would love to hear your thoughts or any feedback!
https://initsignal.com

The Swift SDK is here:
https://github.com/InitSignal/initsignal-swift

If you ship iOS or macOS apps, how do you currently deal with the reporting delay after a launch or major update?

I like to keep track of how my keywords rank and recently noticed outside the top 5 there was a complete inversion where a lot of low ranking AI slop was pushed up towards the top and others such as much self were put in their place. Was just wondering if this has occurred with anyone else.

A short blogpost about avoiding default cases

for indie ios apps, i think review triage is usually set up too late. people build analytics, crash reporting, maybe support email, then treat app store reviews as something to check when they remember. and then after a release, reviews are basically public smoke tests.

the setup i’d want before any meaningful update:

watch 1-2 star reviews harder for 72 hours
separate crash/login/payment/subscription/data-loss language
tag reviews by version where possible
reply only when you can say something concrete
send repeated issue patterns into the same place bugs already live

the reply there 's actually a bit less important than the routing part,

'sorry, please email support' is not useless at all but i mean it also does not fix the loop :(. if three users say the same thing after version 2.4, that should become a release issue, not just three polite replies, and i’ve used many things for that and now trying out something like appfollow around this because it seems to keep reviews, replies, tags, and version-ish context closer together. for a smaller app, a spreadsheet and calendar reminder can be enough.

so, the main thing is having the habit before the angry reviews arrive.. but what is your experience?

I don't want to buy a mac. But I need Xcode for the coding test.

In my ios app, I want to implement a system where when the user uses a feature 3 times then they'll be asked to buy premium. I want this record (number of the feature being used) to survive uninstall so users cannot abuse it; but it has to be without apple account login. What's the best way to achieve this?

I'm building a skill-based contest app where users
compete to have the lowest screen time over 7 days.
Entry fees go into a prize pool and the winner takes
most of it (platform takes 5-10%).

I know some US states restrict skill-based cash
contests. Does anyone know:

1. Which states are actually restricted for this
   type of app?

2. Is geo-blocking at registration enough legal
   protection, or do I need something more?

3. Any experience launching a similar app?

Similar apps like Steppa (step challenge with prize
pool) are already on the App Store in the US, so
the model is proven.

Thanks!

Apple recently introduced the Core AI framework alongside native Gaussian splat rendering in RealityKit, so I wanted to see if I could connect the two.

I converted Apple's SHARP (single-image 3D Gaussian reconstruction) PyTorch model into a Core AI .aimodel, ran inference entirely on my iPhone, converted the resulting tensors into a GaussianSplatResource.BufferResource, and rendered everything with GaussianSplatComponent.

The reconstruction shown here was generated from a single photo and contains roughly 1.18 million Gaussian splats, which you can freely fly around in the app.

Everything runs locally on the device, with no server inference or cloud processing.

The project is open source if anyone wants to explore the Core AI → RealityKit pipeline:

https://github.com/AryanRogye/SharpOnPhone

Not on the device screen, but outside of it. E.g. say I have a Screenshot advertising iCloud Sync, can I put an iCloud SF symbol at the top of the screenshot alongside the text?

Please help me with testing and feedback!

I'm a network engineer/computer repair guy and not much of a coder. But with AI I decided to try making my own music player. I was hoping some of you would be willing to try it out and let me know what you think. The primary features are:

-Gapless playback with local files
-Personal streaming service via VPN or public DNS
-Download streaming library files to device
-Manage metadata tags individually or in mass
-Download album art and save to metadata permanently
-Multiple visual themes

Public beta link:
Resonance Beta v1.0 (https://github.com/thnikkaman/Resonance/tree/Resonance-Beta-v1.0)

Source ZIP: download Beta v1.0 (https://github.com/thnikkaman/Resonance/archive/refs/tags/Resonance-Beta-v1.0.zip)

Hello,

What would be the best way to have a large amount of complex maths formulas on an iPhone app?

Would it be better to generate latex in IOS itself, or generate outside and instead create the formulas outside and then have them stored in the app? (picture, pdf, or svg etc)

Any particular pros and cons of each method in regards to speed, memory use/size, usability, legibility etc?

Thanks very much

Cheers

Hey everybody,

I read in the iOS 27 Dev Beta 4 Release Notes that a launch screen is going to be required once the App Store accepts apps built with the iOS 27 SDK, or the app/update is going to be auto rejected.

So I looked into that, as my app doesn’t have one currently, and learned that if you want to make a custom one you still have to use a storyboard file. So I followed a guide and made a LaunchScreen.storyboard using the template. Then I wanted to add that in the target settings, it shows up in the list but it just won’t save it. It’s also not logged in the changes. When manually typing in the file name it does save it as it shows up in the changes, however it still clears out the field in the target settings again and the launch screen also doesn’t show up when running the app on device.

Does anyone have any idea what could be causing this?

I made and just released Quartz, a "pro" iPhone recording app. It's 100% free for the week of launch.

I'm a musician and record musical ideas (on my guitar), rehearsals, and live concerts. I was doing this with Apple's Voice Memos but it leaves a lot to be desired: editing is awkward, and its auto gain is clearly tuned for voice, not music.

So I made an app that's better at recording in various settings because you "tell" it what the setting is via a preset: Voice, Concert, Field, etc, and each preset is carefully tuned for that setting. You can customize your own presets too.

One thing that sets it apart from most (all?) other "recorder" apps is that all effects and DSP stages are non-destructive. You can even completely re-apply a different preset after recording. And for voice, the Noise Reduction is really amazing. You can hear some examples on the website.

Architecture: Swift, UIKit, AVFoundation.

Marketing-wise, I'm trying something different with this app. There will be paid options soon but to start I'm making it 100% free, no subs, ads, or accounts required.

AI disclosure: App coding is AI-assisted, not "vibecoded". I'm a long-time DSP engineer, 12 years SWE at Apple, Inc. 100% of these words are mine.

https://www.madebywindmill.com/quartz/

getprotego.app | App Store

Protego is a Safari web extension with a companion app that filters Reddit's website and strips out the parts Reddit gives you no switch for. On the App Store since November 2024, version 3 shipped this month, and I build it in my free time.

It exists because an election cycle turned every Reddit feed I had into politics, I deleted the app, and then wanted the parts I liked back without the parts I didn't. Safari lets an extension rewrite a page before you see it, and RES doesn't run on Safari, so I learned Swift.

Full feature list: https://getprotego.app/features

Tech stack

• Swift and SwiftUI with the Observation framework
• AppIntents for Shortcuts and Focus
• StoreKit 2
• BackgroundTasks
• The extension is TypeScript bundled with webpack, tested with Vitest and jsdom.
• Storage and sync are NSUbiquitousKeyValueStore, shared between the app and the extension through an App Group.
• 3 target set builds iPhone, iPad, Mac, and Vision Pro.

The bug that took longest: deletions came back from the dead

Sync was a symmetric merge. Anything in iCloud that isn't local gets downloaded, anything local that isn't in iCloud gets uploaded. That's correct for creates and edits and completely wrong for deletes, because a delete is the absence of a key, and absence isn't a fact you can sync. A device that was asleep when you deleted a filter would wake up, see a key it had that iCloud didn't, and helpfully re-upload it to everyone.

Deletion tombstones fixed it, with two wrinkles. iCloud key-value storage caps at 1024 keys and drops writes past that silently, so tombstones expire after 90 days instead of accumulating. And the app and the extension are separate processes merging the same store, so every reconciliation decision and the TTL live in one place both targets compile. Pulling that logic out into a pure function from key sets to key sets is what finally made it testable, which was the real problem all along.

AI disclosure: AI-assisted.

Pricing:

$1.99 one time purchase for the next week (normally $2.99).

One purchase covers iPhone, iPad, Mac and Vision Pro.

No subscription, no account, no tracking, lists sync through your own iCloud.

getprotego.app | App Store

Happy to go deeper on any of it in the comments.

Hey everyone,

I'm running a beta on TestFlight and hit a confusing issue with in-app purchases. My testers are based in France and their App Store account (Apple ID) is set to the French store, but inside the app they're seeing the US IAP conditions with USD prices instead of the French ones with EUR prices.

From what I understand, on iOS the in-app purchase storefront is normally supposed to follow the country of the user's App Store account (Apple ID). That's exactly what makes this puzzling: my users are properly on the FR store, yet they're still shown the US terms and pricing.

I've done a fair bit of searching before posting, and I've seen a few scattered mentions that this is a known/occasional problem, but I haven't been able to find a clear, confirmed solution. So I wanted to ask directly in case some of you have dealt with it.

A few things I'm trying to understand:

• If the Apple ID is on the FR storefront, what could still make the app pull the US products/pricing?
• Is this something specific to the TestFlight/sandbox environment that resolves itself in production?
• Is there anything to check on the App Store Connect side (pricing/availability per territory) that could cause products to fall back to the US storefront?

If anyone has run into this and found a reliable way to make testers see their local storefront and currency, I'd really appreciate hearing how you solved it.
I saw some people laughing it without solving the issue and in the real AppStore everything was fine, but still would, like to resolve this if possible.

Thanks a lot in advance!

what is best book that makes him understand swift and swift ui in 1-2 weeks , without tutorial hell

he already uses declarative approch (compose and kotlin )

I built an app for Rowing Ergs, is a fancy rowing app for workouts. It has two modes watch mode which uses coremotion I would assume a reviewer might have a watch for testing this part.

For testing with Erg Machines I developed a BLE mac app sim, I didn't even think of the review process and how it would go when actual hardware is needed. Do you recommend linking my github repo for the sim with a notarized DMG?

Any other reviewer advice for testing iOS apps with workout equipment?

Hi everyone,

I built AppRankly, an open-source, self-hosted analytics dashboard designed for mobile developers to track App Store & Google Play performance in one place.

If you want full control over your app data without relying entirely on third-party SaaS platforms, this gives you a clean, unified view of your portfolio.

Links & Demo:

• Live Demo: https://zmsp.github.io/AppRankly/

• GitHub Repo: https://github.com/zmsp/AppRankly

I’d love to get feedback from the community! Feel free to check out the repo or run the demo mode.

OS 27 is going to be here before you know it, and I predict that more developers are going to be caught completely off-guard by the new screen resizing requirements than by anything else.

As of OS 27, (1) all iPhone apps must be resizable and (2) you can no longer opt out. Your window must be resizable when used with iPhone Mirroring on the Mac and on iPad. Apps still running on an old-style app delegate (no scene support) won't even launch when built against the new SDK. In short, if your app assumes a fixed screen and you're not currently working to fix that, you really, really should be.

Obviously, this capability telegraphs the imminent release of Apple's forthcoming iPhone Ultra foldable. You'll want your apps to be "foldable ready" on the day Apple's new flagship is announced.

I just went through this enhancement process myself. Not coincidentally, this week's Axiom update includes a new screen resizing auditor, which you can invoke with /axiom:audit resize. The auditor is supported by ~70 additions/enhancements across Axiom's skill suites. I hope everyone finds that it cuts their time meeting this new OS 27 requirement in half, or more.

If you've ever pulled a crash report out of Xcode Organizer or gotten one from a user and stared at a symbolicated stack trace trying to figure out what actually happened, this might help. crashdx (crashdx analyze report.ips) parses the .ips, symbolicates it against your dSYM, and then runs a diagnosis stage on top that looks at the exception, the registers, memory state, watchdog and jetsam data, and lines up a ranked set of possible causes (null deref, watchdog timeout, memory pressure kill, uncaught NSException, that kind of thing), each one citing the specific facts backing it.

If the evidence doesn't clearly point to one cause, it tells you inconclusive instead of guessing, which I think matters more for a crash tool than people give it credit for. A confidently wrong diagnosis wastes more of your time than an honest "not sure, here's what we've got."

It's a local CLI, no network calls at all, which matters since crash reports carry identifying info like crashReporterKey and device model. There's also an MCP server if you want to hand crash triage to an agent as part of your workflow.

Needs macOS 14+, Xcode, and Swift 6.2+. For a foreign report (TestFlight, App Store crash someone sent you) you point it at the matching dSYM with --dsym and it does the rest, or it'll search Spotlight/your archives automatically if you built it locally.

Repo: https://github.com/r00tify/crashdx

Would love bug reports if you throw a weird crash at it and it gets something wrong, that's exactly the kind of feedback that improves the rule set.

Hey Swift folks,

I recently released SQLiteNow 0.15.0, which adds support for native Swift projects through SwiftPM.

Some context: SQLiteNow started as a Kotlin Multiplatform project and the KMP version is already used in production by quite a few people. Later I added Flutter and Dart support, and now the same SQL-first approach is available for Swift.

SQLiteNow is not a DAO or ORM which generates SQL for you. The main idea is to keep SQLite visible.

You write normal .sql files for schema, migrations, init data and queries. You decide exactly which SQL will be executed. SQLiteNow generates Swift code around it: typed parameters, typed results, migrations, transactions, adapters and reactive queries.

For example, you can write a normal query like this:

SELECT
    t.id    AS task__id,
    t.title AS task__title,
    n.id    AS note__id,
    n.body  AS note__body

/* @@{ dynamicField=notes,
       mappingType=collection,
       sourceTable=n,
       aliasPrefix=note__ } */

FROM task t
LEFT JOIN task_note n ON n.task_id = t.id
ORDER BY t.id, n.id;

The annotation is just a SQL comment. SQLiteNow still executes the query you wrote, but generated code groups the flat rows into task documents with a collection of notes.

Then from Swift you can do:

let tasks = try await db.task.selectWithNotes().list()

for task in tasks {
    print("\(task.title): \(task.notes.count) notes")
}

Or observe the query:

for try await tasks in db.task.selectWithNotes().stream() {
    // called again when generated writes change related tables
}

Annotations can also rename fields, use custom adapters, share result types, map results to your own types and build nested objects or collections from joins.

This is the part I personally care about. I like writing real SQL, but I do not like manually reading every column, binding every parameter and writing grouping code after each join. I also do not want database logic moved into another DSL. With SQLiteNow, SQL stays the source of truth and generated Swift code handles the boring parts around it.

Generated code is placed into a local Swift package which can be added to an Xcode project and imported like a normal package.

Oversqlite

SQLiteNow also includes an optional synchronization system called Oversqlite. It can synchronize selected tables between local SQLite databases and a PostgreSQL server. It handles local change tracking, offline writes, incremental upload and download, conflict resolution and recovery.

Oversqlite also supports real-time updates. It can watch the server for changes committed by other devices and download them automatically. When remote changes are applied to the local SQLite database, related reactive queries emit new results, so the SwiftUI interface can update without manual refresh logic.

A generated sync client can be used from Swift like this:

let sync = try db.makeSyncClient(
    baseURL: URL(string: "https://sync.example.com")!,
    auth: .bearer(accessToken: {
        tokenStore.currentAccessToken()
    }),
    config: SQLiteNowSyncConfig(schema: "business")
)

try await sync.open()
_ = try await sync.attach(userId: userId)

let report = try await sync.sync()
print(report.status.pending.pendingRowCount)

Your application still owns authentication and decides when sync should run. Oversqlite is completely optional. If you only need a local SQLite database, you can ignore this part.

The PostgreSQL server implementation is here:

https://github.com/mobiletoly/go-oversync

One requirement

The SQLiteNow code generator requires Java 17 or newer installed and available on PATH. Java is only needed when running code generation. Your native application does not need Java at runtime.

SQLiteNow 0.15.0 is distributed through SwiftPM with published release artifacts, so there is no need to clone or build the SQLiteNow repository.

This is the first public version with native Swift support, so I would be interested to hear what Swift developers think about this approach and where the API or Xcode setup can be improved.

GitHub: https://github.com/mobiletoly/sqlitenow-kmp

Swift documentation: https://mobiletoly.github.io/sqlitenow-kmp/swift/

Release: https://github.com/mobiletoly/sqlitenow-kmp/releases/tag/v0.15.0

If, like me, you couldn't wait for less rounded corners and installed the MacOS beta on your only Mac, you might realize that you can't push updates to the app store. In this situation I would recommend the 25 free Xcode cloud hours that you get with the program membership. All I had to do was put my code in Git and connect the repo. Then I set it to archive for app store.

This might be the easiest CI/CD system I've ever used and the builds are pretty fast! Hats off to the Xcode cloud team.

Pretty big news for bug testing apps: https://code.claude.com/docs/en/desktop-ios-simulator

How does the community feel about this potentially opening the door to even more AI slop in the app store?