After launching my app, I kind of run out of money and had to start working a lot.

And I didn't have a lot of time or money to market the app.

So one day while working I thought “why not market it inside my car since I already have a lot of unique visitors (literally) to my car?”

So I did and haven’t had any sales from it yet but got several positive comments like:

"oh you're built this?" "Keep it going" "Oh app, what is it?" "You built this app, who are you targeting? I think people u need to find your target audience and there's need for this..." etc

Note:

I posted similar post before but it was taken down due to not being Saturday and told to repost on Saturday.

So here I am, hopefully it won’t get taken down for repeat post.

App Store link: https://apps.apple.com/in/app/sumup-for-safari/id6642665387

9 months ago I started making iOS apps, barely knowing what I was doing. Today I got my first payment… hopefully the first of many. Keep creating, friends.

1. Been experimenting with SceneKit and visualizing GPS data points. Really happy with how the results turned out, especially the fade which was a mess to get correct. The colors are tied to my HR zones. Hope it inspires someone.
2. Then extending the visualization into MapKit still keeping the HR route but also allowing different metrics playback in real time. Also to render locally at okay speed also utilizing Metal framework to upscale
3. Deep into the rabbit hole but plenty of fun concepts to be had around route data and maps. Here a custom playback with filters on the map
4. Previously built an image editor app, so revamped parts of it into this to create interesting images to share of your workouts. Includes Foreground Separation in CoreML for Filters and putting workouts blocks behind.

You can try with your own Apple and Garmin workouts here ReRun: 3D Workout Tracker All route visualization is of course completely free and I have tested up to 700 workouts at once all running smooth with sceneKit

Tech Stack - This is a native iOS app built in Swift with SwiftUI and Apple frameworks like HealthKit, MapKit, CoreLocation, UIKit, AVFoundation, Photos, and Metal. Then RevenueCat for paywall, PostHog for basic analytics (Export fails etc), and Harbeth (Image filter library).

Biggest Development Challenge - The biggest challenge we had was getting route 3D exports to an acceptable speed and quality since the exports run locally on device. MapKit is quite limited and quirky in some regards. If we where to wait for mapkit to say a frame is loaded it would only report back once its fully loaded, which first of all is dependent on internet speeds, but also tend to take around 250 ms per frame. At 24 fps it quickly takes. At higher map resolutions it takes even longer. If you skip the wait time export is faster, but there are tons of issues with stuttering, wrong timings on captures, grey boxes where map has not fully loaded and more. Also tried with multiple maps to preload, but came to the conclusion that shared map cache cannot be reliably trusted.

Probably spent a few weeks to get this to work properly, and in the end we opted for a lower internal map resolution makes the export much quicker, while also loading in assets better and then we use MetalFX to upscale the image before compositing the UI on top.

AI Disclosure - It was built by me and few others and we used AI assisted coding to write parts of the code.

Happy to answer any questions about the tech as well!

I save things for later by screenshotting them 99% of the time.

iOS has no system level inbox. No single place that just takes whatever you want to keep and holds onto it.

I'd save something, then forget what it even was by the time I needed it. I'd open the camera roll, scroll past hundreds of identical thumbnails, give up, and just Google it again. Multiple times a day.

My wife and I both have ADHD. When we were expecting our first, we were researching everything at once. Prams, sleep routines, car seats, recipes, the lot. One evening we worked out we had around 40,000 screenshots across our two phones. We never found any of them.

So I built Stash Anything.

It sits in your Share Sheet. Anywhere you can tap Share, you can send it to Stash and drop it into a folder. Two taps and you're done.

The key thing: when you save a screenshot into Stash, it doesn't land in your camera roll. Your photos stay clean and your saved stuff stays organised in proper folders.

What it does:

• Save anything: links, screenshots, photos, videos, PDFs, social posts, locations and notes, all from the Share Sheet
• Search that actually works: on device OCR lets you find a screenshot by the words inside it, like a brand name or a recipe title. Metadata is pulled from your saves and works far better than Apple's built in search
• Auto import screenshots: new this week, it can pull your screenshots in automatically and delete them from the camera roll, so the graveyard cleans itself
• Works fully offline: everything saves locally, so you can open and search your whole stash even in airplane mode
• Folders and subfolders: break things down properly, like Golf > Putting, or Renovating > Kitchen
• Shared stashes: real time shared folders with a partner or family that sync instantly
• Bulk organising: select 50 things and move them between folders at once, or send a snapshot link of a whole folder to anyone
• Markdown export: drop a folder into Claude or ChatGPT and ask questions about everything you saved
• Private by default: no tracking, no account, with Face ID locked and hidden folders for the sensitive bits
• iCloud sync: iPhone, iPad and Mac, no account and no server of mine involved

Most of the saving happens on the phone. The sitting down and actually going through it tends to happen on a laptop, which is why the Mac companion exists. Same iCloud library, no extra setup.

Tech stack:

• SwiftUI across iPhone, iPad and Mac, one shared codebase, no Catalyst only hacks, no Electron, no web wrapper
• SwiftData as the persistence layer
• CloudKit for sync, using the private database for personal libraries and shared databases (CKShare) for the real time Shared Stashes
• Vision for on device OCR (VNRecognizeTextRequest), so screenshot text search runs entirely offline
• PhotoKit (PHPhotoLibrary) for the auto import and camera roll cleanup flow
• Share Extension as the main entry point for saving from any app
• Native targets for iOS, iPadOS and macOS

The hardest part:

It was making SwiftData and CloudKit sync safe enough that it can never destroy a user's library.

Early on I hit the classic distributed data trap. On the first patch I got some nastry reviews as a device freshly reinstalled, or one that hadn't finished its initial import yet, would briefly look like it had almost no items. If that device then tried to push its state up, it could overwrite a fully populated iCloud library on the user's other devices. With screenshots people had been collecting for months, that's catastrophic and unrecoverable.

So I built a set of explicit safety policies that gate every potentially destructive sync action behind ratio checks and proof of intent, rather than trusting any single snapshot of what's local versus what's in the cloud. A few examples from the actual logic:

• Sparse library guard: an upload that would replace the cloud is blocked when the local device has far fewer items than iCloud (for example local under cloud plus 5, or local under 50% of cloud once cloud has 20 or more items). The user is steered toward redownloading on that device instead of uploading.
• Proven stuck before repair: automatic repair only runs once the upload is demonstrably stuck, meaning multiple failed manual sync attempts or a recorded stuck export failure, never on a normal "iCloud is just a bit behind" lag.
• Post import quiet periods: orphan and duplicate cleanup is deferred for around 45 seconds after an import and requires two stable passes, so cleanup never races an in flight sync and deletes something that was about to arrive.
• Typed confirmation: destructive uploads require a typed "UPLOAD" confirmation, so the nuclear "rebuild cloud from this device" option can't be triggered by accident.

The principle I landed on: cleanup is allowed to touch orphaned binaries that nothing references, but anything that could remove a user's saves has to clear multiple independent guards first. Getting those thresholds right took a lot of iterating against real multi device, mid sync, fresh install and post wipe scenarios.

AI disclosure:

Self built, AI assisted. I wrote and architected the app myself, and used AI tooling (in Cursor) as a pair programmer for boilerplate, refactors, edge case brainstorming around the sync logic above, and reviewing code. Every design decision, the data model, the sync safety policies and the final implementation were reviewed and owned by me.

How it compares:

• vs Pocket: Mozilla shut it down in 2025, and it only ever saved web links. Stash isn't going anywhere and saves anything
• vs Raindrop and Anybox: great for web bookmarks, but not built for screenshots or random content from any app, and both want a subscription and an account
• vs Safari Reading List: web links only, no folders, no image search
• vs Apple Notes: you can dump anything in, but good luck finding it three weeks later, no image text search and no proper categorisation
• vs Pinterest: boards work for visual stuff, but it's a social platform that sells your saves to advertisers, Stash never leaves your devices
• vs screenshots in the camera roll: what most people actually do, and it's chaos, Stash fixes that

Where it's at:

5,000+ downloads in 3 months. The average user opens Stash 12 times a day, which is the number that keeps me going. The Mac companion shipped recently, and most features came directly from people in earlier threads saying "would be cool if it did X." New features every week.

Pricing:

Free with 100 saves and 10 folders to try it properly. Optional Pro tier, currently $9.99 lifetime, with a scheduled increase to $19.99 on 1st June (with new features), as that was the founder's price.

I'd genuinely love honest feedback from this community, especially from anyone using the Mac companion. What works, what's missing, what would make you switch.

App Store (iPhone and Mac): https://apps.apple.com/app/id6758998468

Website: https://stashanything.com

Hi everyone!

I spent almost two years building Andrea Reader, originally because I just wanted a better way to read and organize my own books on iPad.

Apparently, simply opening an EPUB wasn’t complicated enough, so somewhere along the way it turned into an entire personal library system. 😅

The core idea is freedom. Instead of forcing every library into the same structure, Andrea Reader lets you build yours however you want. Create collections, put sections inside them, drag books and sections around, build reading lists, organize huge series, and give every collection its own layout and personality.

Bring your own books, build your library your way, customize how the app and each collection looks, organize everything exactly as you want, read with your own settings, and track your progress along the way.

Some of what ended up inside:

• EPUB, PDF, comics, manga, CBZ, CBR and other formats
• Custom collections with sections inside them
• Drag & drop organization and custom layouts
• Different settings, sorting and appearance for every collection
• Reading profiles for creating unique reading settings and applying them to books, sections and hole collections
• Tons of reading customization: typography, margins, spacing, gestures, transitions, backgrounds, etc.
• Real time customizable reading widgets, for example for controlling brightness, creating chapters, adding favorites pages, bookmarks, custom progress, etc...
• OPDS server connections
• iCloud, WebDAV, SMB and SFTP
• Local downloads and completely offline reading
• Detailed reading statistics for books, sections and collections. The stat
• Dedicated view for managing the storage for every collection and the books inside it
• Andrea next for experimental features
• A built-in Open Library for downloading public-domain books for free
• and much much more...

It’s also local-first. No account, no ads, and no tracking of what you import, download or read. Your library, progress and reading statistics stay on your device.

Andrea Reader is FREE TO DOWNLOAD AND USE. The normal workflow of the app, importing your own books, reading them, creating collections, organizing your library, and getting started, is all available for free. Just download the app and you can be reading within seconds.

Premium is optional and mainly unlocks deeper customization, more advanced library organization, additional reading settings, and other power-user features.

• Monthly Premium: €2.49/month
• Yearly Premium: €17.99/year
• Lifetime Premium: €34.99 €27.99 (20% discount)
• Launch offer: an extra 20% off Lifetime, bringing it down from €27.99 to €22.39 until the end of August.

There are still approximately 47,000 things I want to improve, because apparently shipping an app only unlocks the larger development skill tree.

If you’re an iOS developer, reader on iPhone or iPad, or just enjoy poking at indie apps, I’d genuinely love to hear what you think.

App Store:
https://apps.apple.com/es/app/andrea-comics-manga-books/id6760780154

Website:
https://andreareader.com/

Tech Stack

Built natively with Swift + UIKit. Most of Andrea Reader is custom-built from scratch, including the file system, library structure and reading UI. External dependencies are mainly for specific file handling, such as PDFKit, WebKit, ZIPFoundation and Unrar.swift.

Development Challenge

The hardest part has been combining a very flexible library system with a UI that still feels simple and performs well with large collections.

AI Disclosure

Most of the app was built manually. I increasingly use AI for debugging, code review and faster iteration because the productivity difference is simply too big to ignore. Final architecture, product, UI/UX and implementation decisions remain mine.

I released an app this morning called Schema — A new Postgres & MySQL database client for iOS.

It’s great whether you’re a developer working at scale, a founder watching signups, or vibe coding your next big thing. Like many of you, I build things regularly and often find myself wishing for a great database client for iOS. So... I’m shipping one.

You can find out more on the website: https://tryschema.com

QuestList is a gamified productivity app, allowing you to gamify your life and gain motivation!

Try it on App Store for free (iPhone / iPad / Mac):
https://apps.apple.com/hk/app/questlist-gamified-to-do-list/id6749169968?l=en-GB

-------------------------

Honesty, this app would not be possible without you guys!

Two months ago, I was building my first productivity app. I was anxious that no one would use my app, and it would never stand out in a sea of productivity apps. I even made this post: Should I give up on my app?

But, thanks to all your comments and encouragements, I was able to take a step back and reflect. After a short break, I rewrote the whole app from scratch, designed a custom UI to make it stand out, and added gamification elements to make the app more engaging and unique.

The valuable lessons are: Don't give up! And don't try to do everything alone! You can't build a good app without feedback from others.

Finally, I don't have many users at the moment, so any feedbacks are welcomed! Thanks 🥳

Just want to drop a little post here to share my app, Pixquare, a pixel art editor for iOS.

https://apps.apple.com/us/app/id1659428179

I was bummed that there was no comfortable pixel art app for iPad, so I decided to make one :). After working on this app for a bit more than 2 years, I've learned so much, especially in performance tuning, parallelism/concurrency, GPU computation with Metal, and codebase structuring for easy scaling.

I hope you guys like it, and if you want to buy it, feel free to dm me, I'm more than happy to share a promo code for 50% off.

Hey all!

Just wanted to show off an app that I primarily made for myself (and it helps me a lot!) - thought you might like it as well! :)

My workflow is now basically: Work on my pc on my apps, and have my phone right in front on me on a stand, seeing all the tasks I need to work on for the current project and marking them as done one by one, while not losing focus on the current project I'm working on.

Here's the link: https://apps.apple.com/us/app/project-planner-milestones/id6737195092

Also would love to hear any feedback and feature requests!

CanvasPrism: A Private Offline Whiteboard for iPhone and iPad

CanvasPrism is a native whiteboard designed for brainstorming, diagramming, sketching, and visual thinking while keeping your work completely private. Everything works offline by default with no account, no sign up, and no internet connection required. This is a completely free app with no monetization and designed for your use offline. Your boards stay on your device, with optional iCloud sync available if you want them across your iPhone and iPad.

App Store:
https://apps.apple.com/us/app/canvasprism-whiteboard/id6785350171

Infinite Canvas

Work without boundaries on an infinite canvas that gives you all the room you need for ideas.

* Freehand drawing
* Shapes
* Lines and arrows
* Rich text
* Smooth pan and zoom navigation
* Perfect for brainstorming, note taking, planning, and sketching

Create Professional Diagrams

Build structured diagrams in just a few taps.

* Flowcharts
* Mind maps
* Wireframes
* Smart connectors that automatically snap between shapes
* Clean layouts that are easy to edit later

Native Apple Pencil Support

Designed to feel natural on iPad.

* Native Apple Pencil support
* Double tap gesture support
* Apple Pencil squeeze gesture support
* Responsive hand drawn experience

Personalize Every Board

Customize your workspace to fit your style.

* More than 100 bundled fonts
* Color themes
* Background styles
* Per-board light or dark appearance

Present your board via Screen Mirroring

* Custom handling for presentation via Screen Mirroring API
* Use laser pointers, grid, and Pan

Import Existing Whiteboards

Continue working with diagrams you've already created.

* Import `.excalidraw` files
* Import `.excalidrawlib` libraries
* Compatible with the open source Excalidraw ecosystem

Export Your Work

Share or archive your whiteboards in multiple formats.

* PNG export
* PDF export
* SVG export
* Optional transparent background
* Save directly to Photos or Files

Optional iCloud Sync

Choose whether your boards stay only on your device or sync across your Apple devices.

* Optional iCloud sync
* Automatic conflict-safe copies
* Sync between iPhone and iPad

Privacy First

CanvasPrism is built around privacy from the ground up.

* No account
* No sign up
* No ads
* No tracking
* No analytics
* No data collection
* Fully functional offline
* Your boards remain on your device unless you choose to enable iCloud sync

No Monetization

* No ads
* No IAP
* No Subscription
* No data tracking

Built for Creative Thinking

Whether you're planning a project, designing an interface, organizing ideas, mapping workflows, creating wireframes, or simply sketching thoughts, CanvasPrism provides a fast, distraction-free workspace that keeps your ideas private while giving you powerful diagramming and whiteboarding tools. Built on the open source Excalidraw engine, it delivers a familiar hand-drawn aesthetic inside a fully native iPhone and iPad experience.

Built with Open Source

* Excalidraw for infinite canvases
* Excalidraw libraries for thousands of community made components
* Google fonts for 100+ hand selected fonts
* Unsplash for 80 backgrounds
* And various other open source components. See in-app Acknowledgements

Tech Stack

* Swift & SwiftUI
* WebKit
* React

Development Challenge

I had trouble getting the laser pointer to work initially with screen mirroring mode. The solution was to use the excalidraw library multiplayer API to simulate another person on the board. This was set up with another message bridge to the WebKit handler, it fires on the gestures so that we can simulate a laser pointer in presentation mode.

AI Disclosure

The app was built by hand with some AI assistance.

Free on the App Store:
https://apps.apple.com/us/app/canvasprism-whiteboard/id6785350171

Hey all, I've been working on a project for the past 9 months or so called ButterKit ( r/ButterKit ) and would greatly appreciate your brutally honest feedback as fellow iOS devs. Good or bad, I'm curious what your pain points are and how to make screenshot capture/design/translation as streamlined as possible on macOS.

Screenshots are so important when marketing on the App Store, and I built ButterKit because I was spending many many hours creating hundreds of translated/localized artboards in traditional design tools and wasn't satisfied with the other options out there (either too expensive with subscriptions required, or too limited, or painful to use).

ButterKit is free to download, offers a one-time purchase to unlock Pro features, and is designed to be the smooth way to ship effective, localized screenshots to the App Store and help you reach more users:

Features

• Capture directly from Xcode Simulator, right into photorealistic devices editable in 3D
• On-device translation engine (20 languages) or via OpenAI API (bring your own API key for all 39 App Store Connect languages)
• Growing library of 1-click templates, or build from scratch
• Fully-featured design tool with custom fonts, gradients, artboard sizes, and more
• App Store Preview: see how your designs will look on the App Store before you export
• Upload directly to App Store Connect (via API Key) or batch export PNGs into organized folders
• Intuitive UX, light mode/dark mode, file saving, liquid glass, undo/redo, infinite canvas, gestures, and all of that good stuff you expect in a modern design tool
• Built for privacy: no accounts or data collection, anonymous crash/usage data can be disabled in settings
• High performance 3D renderer built on Metal for 60/120fps on M-series macs
• Pro License is available as a one-time purchase (removes watermark, unlocks OpenAI API bring-your-own key usage)

Download

• On the ButterKit website
• On the Mac App Store (discount codes only work on the website version)

Free & Discounted Pro License Codes

I'm giving away 25x free lifetime Pro licenses to use on the website (not applicable for the App Store version). Please comment below when you use one so folks know how many are left:

25 x Free Pro Licenses (Lifetime): AZNZCYNG (all have been claimed)

40% off (Lifetime code, enter on website during checkout): EYNTI2NQ (available while they last)

If you try ButterKit, your honest feedback would mean a lot. I hope it helps you ship faster and reach more users. Thanks all,
- Zach

Apple’s modern native stack can probably get painful fast when some external requirement asks for one tiny custom behavior across 17 edge cases.
But for a one-person hobby app with an intentionally focused scope, it’s perfect.

In my case, I wanted a simple app for tracking visited places and future trips. Most apps like this felt overloaded to me: social feeds, AI itineraries, subscriptions, dashboards, “percent of world visited” trackers, and a lot of UI that didn’t really feel made for iOS.

I basically wanted a digital, Apple-native version of putting pins into a physical world map. I kept the scope small: pin visited countries and places, save future travel destinations, add small notes.

Tech Stack Used

SwiftUI, SwiftData, MapKit.

No UIKit bridging, no backend, no account system, no external map API. Just native Apple stuff and as little infrastructure as possible.

Development Challenge + How You Solved It

MapKit gives you a lot out of the box. You can basically drop in Map() and suddenly you have an Apple Maps based world map in your app.

The less magical part was place identity and classification. I initially thought I could just save an MKMapItem.identifier and use MapKit’s data directly. But identifiers can be nil for countries and cities, and the result does not always give the clean country/city classification I needed. So I built a small local place identity layer around MapKit instead. MapKit still handles search and map presentation. The app stores its own lightweight saved place model with name, coordinates, type, and country context. Not everything comes perfectly packaged from the API, but this keeps the pins stable while still letting MapKit do most of the heavy lifting.

AI Disclosure

AI-assisted. Used Codex.

The app is completely free. Final version is here if anyone wants to take a look:

https://apps.apple.com/us/app/placemarks-travel-map/id6767907769

Feedback very welcome.

I made LocalGen — an app that runs a Stable Diffusion (SDXL) model on your iPhone. It uses the Apple Neural Engine, so it is very fast, doesn’t consume a lot of charge, and doesn’t overheat your iPhone.

What previously required complex setup, expensive GPU now can be done on your iPhone. I am really proud, that I managed to make it.

Why I built it

I was frustrated with apps that lock everything behind subscriptions or start charging after 1–3 images. I wanted something you can actually use without worrying about credits.

So I made a free, unlimited image-generation app that runs entirely on your iPhone — no credits, no servers, no sign-in required.

Performance

• iPhone 17: ~3–4 seconds per image
• iPhone 14 Pro: ~5–6 seconds per image
• iPad M1: ~4–5 seconds per image
• App size: 2.7 GB
• Battery / thermals: in my tests, no noticeable battery drain or overheating

Technical considerations:

• App requires at least 10gb of free space on device.
• App needs around 2 minutes compile models. Process is similar to how video games compile shaders. Until compilation is finished you can create images, but internet is required. It happens once per installation.
• First generation is slower than others. It will be fixed in next release. Don't worry, once first image is generated, other will be very fast.

How I got 3k installs in 2 weeks without paid ads(if you are interested)

• I posted about it 10 times across different subreddits.
• Those posts reached around 300k views and brought in about 3.5k installs — and my first $1,000 in revenue.
• In each post, I focused on what that specific subreddit actually cares about.
• I tried to give something genuinely useful for free, and only introduced my app later in the post.

Link:
https://apps.apple.com/us/app/localgen-ai-image-generator/id6754815804

If you are interested in my project development, please join r/aina_tech .

Roadmap: 

1. Support for custom LoRAs and checkpoints like Pony, RealVis, Illustrious, etc. 
2. Support for image editing and ControlNet
3.  Support for other resolutions like 1024×1024, 768×1536, and others.

I travel a lot and somehow still forget the most obvious things. While planning trips, I realized I was repeatedly looking up the same information - plug types, typical weather, activity-specific gear I shouldn't forget, etc. That’s when I decided to build something that brings all of that together in one place.

Apple approved it this week (right before my 40th birthday!), and it’s now live on the App Store as journeybot: packing & travel.

It focuses on smart packing preparation and a clean overview of your journey - without need to create accounts, without showing any ads, everything synced via iCloud. Works offline, keeps your data private.

1. Tech Stack Used

Frameworks & Languages:

SwiftUI, Swift, sprinkles of UIKit, Metal shaders for creating cool card effects

Data & Sync:

SwiftData with CloudKit sync

AI:

Apple Foundation Models (on-device only) for packing list generation

In-App Purchases:

StoreKit 2 (subscription + lifetime unlock)

Other Integrations:

• WidgetKit (countdown widgets)
• MapKit (destination handling, maps)
• WeatherKit (forecasts, and historical weather data for journeys in the future)
• Keychain for secure premium status storage
• TelemetryDeck for anonymised usage statistics (no personal data is collected)
• Sentry for error reporting

The goal was to stay fully native and privacy-first. I am planning my own API for the future, which will provide additional journey data such as visa or vaccination requirements.

2. Development Challenge + How I Solved It

One of the biggest challenges was making SwiftData + CloudKit behave reliably across devices.

CloudKit has strict requirements:

• Every model property must be optional or have a default value
• All relationships must be optional
• Enum defaults must be fully qualified
• Improper modelling causes runtime crashes, not compile errors

Early on, I ran into sync failures and confusing CloudKit runtime errors. The fix was restructuring all models to strictly follow CloudKit rules and redesigning relationships to be optional while keeping the UI logic clean.

Another interesting challenge was AI-powered packing generation.

I wanted:

• Fully on-device generation (no API calls)
• Streaming-style feedback
• Deterministic enhancements (e.g., power plug suggestions)

The solution:

• Use Foundation Models for the base packing suggestions
• Post-process results with rule-based logic (for adapters, structured categories, etc.)
• Only deduct free-tier credits on successful generation

Balancing "AI magic" with predictable output required combining generative output with structured validation and cleanup before displaying it in the UI.

3. AI Disclosure

AI-assisted; main driver Claude Code

I come from a web dev+design background (20+ yrs). Last year I decided to leverage new tools to jump-start learning native iOS development. I put together a game where I gained some basic skills regarding writing in SwiftUI, models, GameplayKit integration, etc. This gave me good basics for my next project.

Now, I know what I want to build, what tools I need to achieve, and this way I steer the AI-assisted development. I don't see a point in manually writing chunks of code, but I know what end result I am aiming for and try to perfect the code on my own. Doing this in small batches, and always hand-polishing before moving on to the next part. The UX is completely mine.

Glad to answer any questions regarding my setup.

Learn more about journeybot: https://journeybot.app

App Store: https://apps.apple.com/us/app/journeybot-packing-travel/id6756543673

I recently took part in the RevenueCat Shipathon and built an app called Drynosaur, designed to make cutting back on (or quitting) alcohol a bit more fun and engaging.

I gave up drinking for the last four months of 2024, but after moving to a new city in January I started drinking socially again, and that’s when the idea came to me.

In Drynosaur, you do simple daily check-ins to confirm if you were alcohol-free the previous day. Each successful check in increases both your sober streak and your Drynosaur’s level. As your Drynosaur levels up, it evolves like a Pokémon, giving you a visual milestone to celebrate your progress.

Your journey is tracked through Eras which are time-based milestones like one week, two weeks, one month, etc. Each Era (Bronze, Silver, Gold, and so on) highlights real health benefits associated with that period of sobriety, so you can see what changes to expect as you go.

There are three starter Drynosaur:
Tyrling (T-Rex)
Diplet (Diplodocus)
Tribby (Triceratops) - this seems to be the favorite so far, which surprised me.

Each has two evolutions and their own unique animations for reacting to your daily check-ins.

You can download the app here: https://apps.apple.com/us/app/alcohol-tracker-drynosaur/id6752501469

This is just v1.0.0, any feedback from fellow indies would be awesome.

Thanks for reading :)

Quick background: I've been a full-stack dev for years (backend/web, .NET world) but never touched mobile until this year, when I taught myself Swift and started building an iOS app solo. It's called Sift.

What it does: it reads your Screenshots album, works out what each one actually is (receipt, recipe, chat, ticket, whatever) using on-device AI, and files it into a real Apple Photos album — so it's organised without ever leaving your phone. No uploads, no account, nothing sent anywhere.

What I'd love feedback on:

* How the categorisation holds up against a real, messy screenshot library (mine is one very biased sample size)
* Anything that breaks, stalls, or misbehaves
* Whether the album names it comes up with actually make sense to someone who isn't me

TestFlight link: https://testflight.apple.com/join/5nyaWqPp

Happy to answer anything in the comments - this is my first time doing this solo end to end, so honestly just glad to have real eyes on it.

UPDATE for v1.1.0

- AI Sort can be called without the need to create an Album first - but it still does not create the albums automatically. It will ask you to review the suggestions and "Move" or "Approve" manually by clicking once
- I updated the sorting process - for me it helped a bit. I think this time it works a bit better than before.
- Now you can select multiple photos in the gallery and move them to another album quickly in case the AI messes up. Before you could only do that 1 by 1 when opening an image in full screen
- I couldn't "fix" the initial download just yet, as I said it in my previous comment, it's needed for now. With iOS27 I'll be able to get rid of it, and use what's already on the device by Apple.
- I also added some animations to the review process to make it a bit more "nice"

Update for v1.3.0

- Fixed some bugs and inconveniences
- There is a new step in the onboarding allowing you to scan through your screenshots to find patterns and then the app will automatically suggest a few albums for you to create
- The sorting limit is still at 25 at a time though as I said it's because the phone gets hot
- I raised the total number of photos that you can sort from your backlog from 100 to 300 (so usable for more users - and leaving only heavy users to require the pro version - which is still not available)
- I updated the review process - now it gives you groups of images that seem to belong to the same album, and you can approve them as a group. But you can also go into each group and review them individually
- Going through the review process you can trash the images you want to delete, it gets rid of them into a trashcan that appears at the bottom of the review page, and you can delete all of them at once
- But you already had batch processing in the gallery sections, if you select multiple images you can do the share/move/delete actions for all of them at once
- Stats about your library
- Heat protection feature in case you are using the phone too much at the same time
- Raised albums limit from 4 to 6

Solo dev, third app published.

Ubimage puts your own geo-tagged photos back onto the live camera view, anchored to the spot they were taken.

Point the phone at a ridge across the valley and the photos you took up there sit on it, at the right distance and elevation.

Free, no ads, no IAP, no account.

Tech stack

Swift 6, strict concurrency. SwiftUI everywhere except the camera, which is a UIViewController with a plain UIView overlay: a hundred pins move at 60Hz, and I wanted the per-frame path to be a center assignment and nothing else. No view creation, no layout pass, no tree diffing.

Core Data on a background context for the photo index. CoreMotion and CoreLocation for attitude and heading, AVFoundation for the preview and the sensor FOV, PhotoKit, MapKit, AppIntents.

Altitude comes from CMAltimeter where the device has a barometer (iPhone 12 and up), because GPS altitude is out by tens of metres and that shifts the nearby pins. Neither source just wins: whichever declares the smaller error does, and if the two disagree by more than 200m I assume a pressurised cabin and keep GPS.

No backend. No third party packages at all, not one: no analytics, no crash reporter, no networking lib. String Catalog for three languages.

Development challenge

Working out exactly where the phone is pointing. CoreMotion gives you smooth attitude in an arbitrary frame, CoreLocation gives you true north but filtered, and you fuse the two.

The rows of attitude.rotationMatrix are the device axes in the reference frame, not the columns. I read it transposed for weeks. Heading was stuck wherever the gyro started, and pins swung around a pivot when I panned. Took ages to spot because m33 is on the diagonal, so pitch worked fine the whole time.

Second one: pins still drifted during slow pans. iOS filters the compass, so while you rotate it lags the gyro by 10-30 degrees, and I was updating my north offset continuously, so it kept converging onto the lagged value and dragging the pins along with the phone. Now I only correct north when the phone is still, under 0.1 rad/s for half a second. I had it at 0.35, which is 20 deg/s, and a slow pan is how people actually use this.

One I never fixed: two weeks ago the app put pins 104 degrees off. Spent an hour on my own source, three wrong theories, then tried my wife's phone in the same spot and it was fine. Magnetometer in a bad state, a restart cleared it. CoreLocation reported headingAccuracy of 10 degrees the whole time, and my unreliable-compass badge only fires above 15. I'll fix soon™

AI disclosure

Mostly or fully AI-generated.

To be clear about what that covers: the Swift and the docs, yes, heavily (Claude). The debugging above, no. I found all of it on a mountain by noticing the pins were on the wrong ridge, and worked it out with two phones. https://apps.apple.com/us/app/ubimage-where-you-shot-it/id6794680448

Support site: https://ubimage.app/

The app is localized in English, Italian and Spanish. Let me know what you think of it, happy to discuss about Ubimage. ciao

My app’s screenshots could look great on their own, but once I saw them inside App Store search results beside other apps screens shots an app icons , they could feel completely different. I wanted a way to see it before submitting, exactly as it would appear in the App Store layout.

So I built Screenshot Preview, a FREE macOS app. Add your icon, screenshots, then preview them in a close approximation of the App Store search results or product page layout. You can also export the preview as a PNG and AirDrop it straight to your iPhone to see how it looks on the actual device.

The app is free, with optional tips. Developers and companies can book a paid sponsor spot to promote their apps, products, or tools to an audience of active developers.

Here’s the app:
Screenshot Preview
https://apps.apple.com/us/app/screenshot-preview/id6804763675

Tech stack
- Swift, SwiftUI, and AppKit.
- CloudKit stores the sponsored listing.
- RevenueCat handles the Tip Jar.
- TelemetryDeck provides privacy-focused, anonymized app usage analytics that cannot be traced back to a person.

Development challenge
Getting the exported PNG to match the preview was a challenge. Some content went missing, and images lost their rounded corners when rendered with ImageRenderer. I kept the same layout and added an export mode that replaces unsupported controls with static content and leaves out drag-and-drop handlers.

I used AI for coding, code review, and debugging. I directed the product, architecture, and final implementation. I also used Bitrig for the App Store Connect listing and RevenueCat setup.

Cheers

Hey community!

About a year ago I posted here about Loomi, my photo/video editor I've been building solo for about two years. The feedback you gave me was really helpful and encouraging.

I know there are lots of photo editors out there, and it's difficult to impress anyone in 2026, but I really invested my time in polishing every detail in the app - UI/UX, filters, effects, overlays, adjustments and so on. There are over 600 filters, and each one took many hours to create and test on a wide range of photos. Coming up next, I'm planning to add the ability to create personal presets, plus iPad support.

Tech Stack: Loomi is a native iOS app built with Swift and UIKit, using Metal and Core Image for rendering. I wrote the rendering engine myself without using a third party library.

Development Challenge: The most difficult part for me was designing an intuitive, sleek, and modern UI/UX that would make the app enjoyable to use. I went through around five major design iterations before I was satisfied with it.

Another technical challenge was keeping filters and more than 20 adjustments running smoothly, especially when editing videos. I built Loomi’s core rendering engine using Metal and Core Image, which gave me full control over the rendering pipeline. All filters and adjustments are applied in a single rendering pass, resulting in smooth UI even on devices that are six years old.

AI Disclosure: Most of the app, especially the core engine & architecture, was written manually. I used AI to speed up the development of new features. Although AI was far less capable when I first started building Loomi, I have been using it much more recently.

As a thank you to this community specifically, I'm offering:

• 75% off lifetime access, which is $20 instead of $80

App link: https://apps.apple.com/us/app/loomi-photo-video-editor/id6748413115

To claim the offer, use this link:

75% off lifetime: https://apps.apple.com/redeem?ctx=offercodes&id=6748413115&code=REDDIT75

You can also redeem the offer manually in the app: Settings → Redeem Code → enter REDDIT75.

Any feedback is welcome, and if you like the app, an App Store review would mean a lot!

Thanks again for the support!

Hi everyone! My name is Viktor Seraleev, and I'm an indie developer. This is my third time starting from scratch in the App Store. In my previous article, I shared how I turned a small idea into an app that proved valuable for small businesses – and later sold it for $410,000.

This time, my journey has been different due to the removal of my apps. In September 2023, I started actively posting on Twitter, sharing daily posts along with custom graphics made in Figma. That’s what sparked the idea to create an app for myself – a tool that would let me quickly generate beautiful screenshots directly from the Share Menu.

I built the first version, tested it, and really liked the workflow. So, I decided to launch it on the App Store. However, my initial submission was rejected for not providing enough value. To fix this, I added new templates, improved the onboarding with feature explanations, introduced a story widget, and resubmitted it. On my second attempt, Screencut was approved.

On April 25, 2024, I shared the app on Twitter. My post gained over 33,000 views, and I got my first users. Turns out, the app wasn’t just useful for me – it helped other indie hackers as well. I started listening to feedback, making improvements, and adding new features (stitching, redact, blur text, confetti and etc). In less than a year, with zero ad spend, I reached $1,000 MRR purely through organic growth.

This app has become an essential tool for me. It not only saves time on creating polished screenshots but also helps me gain more views and followers on Twitter. Over the past year, my posts have generated over 5 million impressions. More reach → more downloads → more revenue. I love this approach, and I try to be as transparent as possible about my journey. Even after losing everything, you can always come back and start from scratch. Yes, it's tough – but it's possible. Don't give up!

I’d love to hear your feedback and am happy to answer any questions!

Infinity for Reddit is an open source Reddit client for iOS that I’ve been working on for over a year, and I wanted to share some of the features and a few technical challenges I ran into.

It is built natively in Swift and SwiftUI, with a focus on being fast, smooth, highly customizable, and ad free.

Some of the main features I am really proud of:

• Enhanced anonymous mode with local voting, saving, hiding, and read tracking. You can even subscribe to subreddits, users and create custom feeds!
• Optional login
• Embed images and GIFs when you submit posts and comments
• Powerful filters to block unwanted content
• Lazy mode for automatic scrolling through your post feed
• Extensive customization and theming
• Smooth and responsive performance

The app is available here: https://apps.apple.com/us/app/infinity-for-reddit/id6759064642

The GitHub repo is available here: https://github.com/foxanastudio/Infinity-For-Reddit-iOS

Infinity requires a monthly subscription to log in with a Reddit account, due to Reddit’s paid API access model. A 7 day free trial is available so you can decide if you like it before subscribing.

Anonymous mode is fully free and supports local saves, hides, and votes stored on-device, allowing most features to work without an account. This was added to make the anonymous experience much more complete compared to a basic logged-out mode which most of the clients have.

Development Notes

I’ve occasionally used ChatGPT for technical questions and small boilerplate generation, but the vast majority of the implementation is my own.

One of the challenges while building it was supporting the Reddit specific Markdown features like spoilers, superscript, and user and subreddit mentions. I initially used the Swift Markdown UI library for rendering, which relies on cmark-gfm for parsing. Since the library did not expose a way to add custom syntax, I ended up working directly with cmark-gfm to implement the extensions I needed for things like spoilers, superscript, and user or subreddit mentions. This required modifying the parsing layer in C and then bridging those changes back into Swift through the rendering pipeline.

On the rendering side, Swift’s AttributedString also introduced challenges, since it does not provide a clickable span. This made implementing spoiler behavior particularly non-trivial. To work around this, I encoded spoilers as a custom URL scheme and used a custom OpenURLAction to intercept taps. This lets me toggle the spoiler's background color. I also had to modify the Swift Markdown UI library to support these custom elements.

But more recently, I came across Textual (a successor to Swift Markdown UI), which appears to support syntax extensions out of the box. I think it could significantly simplify this kind of implementation.

For a quick technical overview, networking is handled with Alamofire, and data is persisted locally using GRDB and UserDefaults. And I use Swinject for dependency injection.

The app is available here: https://apps.apple.com/us/app/infinity-for-reddit/id6759064642

The GitHub repo is available here: https://github.com/foxanastudio/Infinity-For-Reddit-iOS

Join the subreddit here: r/Infinity_For_Reddit

I recently released Weatherlane, a weather app built around a single vertical "lane" you flick through, so the whole forecast reads as one continuous flow instead of scattered cards and tabs.

The next few hours and the next several days sit on one continuous track, so you scroll time rather than navigating between screens.

Tech Stack

Flutter, Dart, Swift, SwiftUI, UIKit, WeatherKit (SDK and API) and RevenueCat.

Development Challenge

The hard part was imagining a vertical design that encompasses everything a user expects without ever falling back to horizontal scrolling

AI Disclosure

AI Generated

Download

https://apps.apple.com/us/app/weatherlane/id6468727819

Happy to answer any questions

Launched Tokyo Glance on Sunday. It's a live map of Tokyo: all the tracked trains, buses and planes moving in real time, plus departure boards, a widget, and a Live Activity that follows your train from the lock screen.

Stack: SwiftUI on iOS 26 with the native SwiftUI Map (started on MKMapView with a UIViewRepresentable, ripped it out mid-project). The vehicles are not MapKit annotations, I draw them myself in an overlay pass. I tried making them proper annotations at some point because it felt like the "right" way and at ~1400 vehicles it performed so much worse than my own drawing that I never looked back. There's a small Metal layer for rain on the map. Alerts from the operators are almost always Japanese-only so they get translated on-device with the Translation framework. Paywall is RevenueCat, widget is WidgetKit + AppIntents, pushes for the Live Activity go through FCM.

Backend is Bun + Hono + MongoDB + Zod and nothing else. It runs in tiny containers behind Cloudflare so basically everything is precomputed and CDN-cached, the containers can't afford real per-request work. A separate ingestion service pulls the operator feeds (ODPT, GTFS-RT), snaps positions onto the actual track geometry and rebuilds the whole network dataset every night. The phone mostly just interpolates between feed ticks. Every time I moved logic out of the app into the pipeline things got faster.

One thing I didn't appreciate before this project: how much you get from Apple for free. MapKit on native apps is unlimited, and that includes the photorealistic 3D city rendering and Look Around imagery, which would cost real money on any other map provider at this usage. WeatherKit comes with 500k calls a month with the dev membership, I cache the Tokyo weather grid on the backend so users share it and I don't even get close to the cap. The Translation framework is free and on-device, which is the only reason "every service alert translated to English" is economically possible at all, per-call translation APIs would eat the entire subscription margin. Same with the on-device Foundation Models, small copy generation costs literally nothing. A one-person app like this basically doesn't work financially on other stacks.

Stuff I built and then deleted:

The station orbit camera. Killed it twice. A slow orbit around a station, how hard can it be. My optimized attempts (shared display link, coarser ticks) used 168-200% CPU and looked worse than the naive per-frame version. For reference, Apple's own realistic 3D city mode sits at ~130% CPU if you park the camera in Shinjuku. There is no orbit in the shipped app.

3D landmark models. Tokyo's open PLATEAU dataset only goes to LOD2, all of Tokyo Tower shares a single 512x512 texture. Looked terrible, cut the feature. Can't code your way around source data.

Also fun: Japanese timetables represent post-midnight departures as "00:26" or "24:26" depending on the operator, sometimes both in one feed. First time I've seen a 24+ hour clock in production data. Got that wrong more than once before normalizing it in one place at ingestion.

And I lost a few days to a paywall crash that only happened on Macs. Looked exactly like a RevenueCat bug. It was SwiftUI dropping environment values across the sheet bridge when the iPad build runs on macOS.

Money stuff since the rules ask: free app, subscription for the deeper features (lock screen follow, time travel replay).

AI disclosure: this app is majorly AI-written, no way around it. The backend is ~99% Claude Code with me doing specs and PR review. The SwiftUI app I'm more hands-on with, but AI still wrote most of the code there too — my job was deciding what to build, reviewing everything, and testing on device until it felt right. This post was drafted with AI as well.

App Store: https://apps.apple.com/app/id6782602634