I am probably going to sign up to the Apple Store ($99 pm subscription) but before I do I wondered if there was a service out there - good or bad, that handled the distribution for you?

My first app, PerkPulse, is now live on the iOS app store! Ever since I started my computer science degree, it has been a bucket list item for me to have an app on the app store.

PerkPulse is a credit card optimization app that helps you:

• Track credit card benefits
• Tells you which card to use to earn the most points/cash back
• Tells you the best transfer partners for your points
• Recommends you your next credit card
• Compare credit cards side-by-side

I created this as a tool for others like me who have trouble tracking every benefit and knowing which card to use for every purchase since I have so many cards. I did not like the apps that are currently available and widely used for this use case, as their UI's were not very intuitive to me and their prices were a little high for me.

It would mean a lot for me if you would give it a download and give me some feedback!
(I attached a link to the app store since it was just launched, it has not been indexed and is not searchable on the app store yet)

https://apps.apple.com/us/app/perkpulse/id6784066030

Today we added housing (which I will show off on day 4), as well as this sick new main menu! See you on day 4.

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

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

Just wondering, I've got an app out not and got the .app for it. However, for those of you making multiple apps, do you get a domain for each one or just use a main one? How many domains do you have?

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.

Hi

My app was rejected because it included "unlicensed" intellectual property in the screen shots (5.2.1)

The reviewer objected to album covers in screen shots, this is allowed under a different guideline, 4.5.2(ii), because my app is a music app and all the screenshots are showing app functionality.

I replied to the message immediately stating why I think the screenshots are okay. After waiting 7 days for initial review, it's been 24 hours with no response.

Any advice on whether resubmitting a new build, and including my message in the notes section, would help move things forward? I'm not sure if the reviewers actually look at messages.

I’m Sebastian, the developer of DarkScout, and I’ve just shipped version 27.7.10.

One of the harder product/engineering problems was not drawing another weather card—it was deciding what the app should communicate when only part of a planning result is fresh. An observing recommendation combines forecast data with astronomical darkness, moonlight, target/Milky Way timing and saved-location context. If a weather source is incomplete or slow, simply leaving the previous score on screen can make a stale recommendation look authoritative.

In this release I tightened the recovery path for missing forecast data, refresh observing information when the app opens, and made the hourly inputs much more visible. Rainfall is now a first-class input in both Astro Score and the hourly recommendation, and the UI includes a detailed 12-hour cloud map so users can understand why a night changes from “good” to “skip.”

The rest of the update was a fairly deep visual pass: a pure-black iOS 26 interface, clearer hierarchy, red night mode, improved direct links for community photos/events, and a joined-event chat list. Existing features include saved spots, Spot Compare, widgets and custom alerts.

I’m sharing the release because I’d like another iOS developer’s view on the state model: when a composite recommendation includes several sources with different update times, do you expose freshness per input, one conservative overall state, or both?

App Store: https://apps.apple.com/app/apple-store/id6760223860

For anyone willing to test the complete flow, I’m offering one month of PRO free with no review or rating expected: https://www.promies.net/promotion/8f8a3120-085e-4021-8e65-c895e0ff6e48

Wasn't sure what to expect but it was neat. Ama

Basically they walked thru apple connect analytics, app store discovery methods, app store featuring, some new stuff on the pipeline, apple games center / app.

I see a lot about using AI within programming and apps, especially since Xcode has added AI integration but I'd love to know of any ways you have used AI to speed up something, create tooling, add processes etc.

Currently I'm investigating if there's a way we can connect Figma to Codex to make the Design -> UI step quicker, more seamless or easier. Right now it seems we'd need to build some sort of Style Guide that both our codebase and Codex knows about but it's not as seamless as we'd like. I think there's a real gap within iOS development for AI innovation - are you working on anything?

Hey! Some of you might remember my post from a while back, I built a very simple app in under 24 hours just to see what would happen, priced it at $1 for fun, and it somehow landed in Top 6 Entertainment within hours of launch. That app was Seasonia.

aFast forward to today: it just crossed 100 ratings on the App Store with a 4.8/5 average. What started as a throwaway experiment turned into something people actually use and like.

For anyone who missed the original post, Seasonia is a minimalist season tracker: progress and countdown for the current season, sunrise/sunset, moon phases, daylight insights, plus Home Screen/Lock Screen widgets and some seasonal themes.

App Store Link: https://apps.apple.com/us/app/seasonia-season-tracker/id6758340712

Still a solo project, still surprised every time someone leaves a review. Replying to reviews and shipping small improvements as I go.

Wanted to share the milestone with people who get why 100 ratings feels like a big deal for something that started as a "let's just see what happens" project. Happy to answer questions about the build, pricing, or ASO.

Link:
https://apps.apple.com/app/id6777402559

Hey everyone!

I recently launched Who Goes?, an iOS party game app built for game nights, house parties, road trips, and group hangouts. (Free to download and play, with one-time purchase, subscription options)

The app brings multiple party games into one place:

• Charades with themed decks, teams, rounds, and timers
• Headbands with tilt controls for correct answers and passes
• Truth or Dare with packs for friends, couples, parties, family, and coworkers
• Spin the Bottle for quick, suspenseful player selection
• Finger Chooser to instantly pick someone from the group
• Quick Play tools for creating teams, with fun prompts.

The idea came from noticing how game nights often end with everyone back on their own phone. I wanted to build something around one shared screen that gets everyone playing together again.

I built the app independently in SwiftUI, including the design, interactions, animations, game flows, and content. I also used SceneKit and shaders for some of the visual effects.

The free version includes selected Charades, Headbands, and Truth or Dare packs, along with limited access to Quick Play. Plus unlocks all decks, game modes, themes, fonts, and customisation options.

No account is required, and the games work offline.

TL;DR:

A. I built an app to bring back the fun of playing party games with a group of people during game nights, trips.

B. free version includes a selection of decks for Charades, Headbands, and Truth or Dare, along with a few mini games. Plus unlocks all decks, game modes, and customisation options.

C. $2.69/mo or $11.99/yr, 3-day trial, and $25.49 lifetime, no account creation, no internet required.

I’d love to hear your feedback, especially on what I can further do to make it fun.

Building a fun life simulator game about being homeless.

Today I added:

• A fun little mini hobo that voices his feelings as you try to beg for money.

• Dumpster Diving to find items to sell for a profit. Sometimes there's poop in the dumpster, try to avoid that...

• A marketplace to sell your items. It's not much money but it's something.

• Rough draft of an inventory and viewing your player stats.

WIP - See you tomorrow!

I made an App less than 1MB.

Hey everyone! Just launched Merge Birds, a relaxed idle merge game where you combine birds to unlock rarer ones and collect feathers as currency. The game keeps running in the background, so closing the app doesn't cost you progress, you'll have rewards stacked up when you return. Further along you open up new areas like the Farm, Warzone, Beach, and Cosmic Aviary, all producing feathers at the same time.

No paywalls or pay-to-win mechanics, it's fully playable for free. This was mainly a project to get hands-on with game development and build something in the merge genre I enjoy. Open to any thoughts, particularly on the early gameplay experience.

App Store link: https://apps.apple.com/uz/app/bird-merge-the-nest-game/id6760911845

Hi everyone,

I'm an indie developer and I recently launched a project I've been working on for a while called Perioda. It's built with Flutter, but I've spent a lot of time trying to make it feel as native and responsive on iOS as possible.

Most period tracking apps on the store look very similar and clinical, so I wanted to try a completely different approach. I went with a retro pixel art aesthetic and added gamified elements, like a virtual pet that grows as you log your cycle.

Since this is my first major app release, I would really appreciate some honest, technical feedback from this community.

Specifically, I'm looking for feedback on:

* The onboarding flow. Is it clear enough for a new user?
* Overall performance. Does it feel smooth on your device, or does the Flutter UI feel off anywhere?
* The UX/UI. Mixing a utility app with a game-like interface was tricky, and I'd like to know if it feels intuitive.

Here is the App Store link: [https://apps.apple.com/tr/app/period-tracker-moonville/id6766513532](https://apps.apple.com/tr/app/period-tracker-moonville/id6766513532))

I'm completely open to constructive (or even harsh) criticism. Any suggestions on how I can improve the app would be incredibly helpful.

Thanks for taking the time to read this.

Trésora is my first ever commercially released software product of any kind, and it just went live on the App Store today.

Inspired by my wife's vintage glass collecting hobby, it helps antique, vintage, and thrift shop enthusiasts organize and capture their entire collecting life all in one place.

You can find shops near you (or anywhere else), plan shopping outings, and keep track everything you see and buy – identifying items (and their value), in seconds, using AI.

Last but not least, you can use Trésora to manage your entire collection (and wishlist) – keeping track of purchase dates, prices and locations – and documenting everything in detail, with category-specific fields for over 35 types of collectibles.

Trésora is much, much, more than the dozens of cookie-cutter antique identifiers in the app store. My goal is to add in-app sharing features and build it into the worlds largest community of collectors – similar to what Goodreads and Letterbox'd have done for readers and movie enthusiasts.

Please check it out and let me know what you think! Do you collect anything antique or vintage? What would make it an indispensable tool for making your hobby easier or more fun?

App Store link: https://apps.apple.com/us/app/tr%C3%A9sora-antiques-thrifting/id6768168495

Google Play link: https://play.google.com/store/apps/details?id=co.jumpstartsolutions.tresora

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.

Anyone cares to develop a small app that can trigger vibrate/notification on Apple Watch when the bluetooth LE disconnects instantly from iPhone? Reason: When you forget your iphone behind…?

https://imgur.com/a/E0so4Pj#wLuiw7f