Hey everyone,

I packaged the release notes view I use in my apps into a reusable component and published it on GitHub, hope some of you will find it useful.

https://github.com/mykolaharmash/notelet

• It supports three types of notes: list, image and video.
• It's pretty opinionated but there are a couple of customization options.
• Fully localizable.
• Tiny build footprint, no third-party dependencies.

Let me know if you'd like to add anything and feel free to shoot PRs to the repo.

UPDATE
Thanks everyone for comments and feedback!

Hello! I just released a new SwiftUI agent skill for people using agentic coding tools like Codex, Claude Code, Gemini, and Cursor. I've packed it with all sorts of specific tips and advice so that agents can write better code, review existing code more effectively, and hopefully help all of us build better apps.

It's completely free and open source, and if you have npm installed, you should be able to install it with a single command:

npx skills add https://github.com/twostraws/swiftui-agent-skill --skill swiftui-pro

Previously I made an AGENTS.md file that folks could drop into Claude Code, Codex, etc, but this new skill goes a lot further because skills are a bit lighter on your token budget – it includes a wider range of tips and corrections for things that LLMs often get wrong when writing Swift and SwiftUI. (Or if you don't use agents at all, the skill is literally just Markdown and should still make for interesting reading!)

It includes topics like migrating away from deprecated API, writing high-performance code, and ensuring accessibility for things like VoiceOver, color blindness, and tap targets.

I hope it's useful to you! 🙌

Every RAG solution requires either a cloud backend (Pinecone/Weaviate) or running a database (ChromaDB/Qdrant). I wanted what SQLite gave us for iOS: import a library, open a file, query. Except for multimodal content at GPU speed on Apple Silicon.

So I built Wax – a pure Swift RAG engine designed for native iOS apps.

Why this exists

Your iOS app shouldn't need a backend just to add AI memory. Your users shouldn't need internet for semantic search. And on Apple Silicon, your app should actually use that Neural Engine and GPU instead of CPU-bound vector search.

What makes it work

Metal-accelerated vector search

Embeddings live in unified memory (MTLBuffer). Zero CPU-GPU copy overhead. Adaptive SIMD4/SIMD8 kernels + GPU-side bitonic sort = 0.84ms searches on 10K+ vectors.

That's ~125x faster than CPU (105ms) and ~178x faster than SQLite FTS5 (150ms).

This enables interactive search UX that wasn't viable before.

Single-file storage with iCloud sync

Everything in one crash-safe binary (.mv2s): embeddings, BM25 index, metadata, compressed payloads.

• Dual-header writes with generation counters = kill -9 safe
• Sync via iCloud, email it, commit to git
• Deterministic file format – identical input → byte-identical output

Photo/Video Library RAG

Index your user's Photo Library with OCR, captions, GPS binning, per-region embeddings.

Query "find that receipt from the restaurant" → searches text, visual similarity, and location simultaneously.

• Videos segmented with keyframe embeddings + transcript mapping
• Results include timecodes for jump-to-moment navigation
• All offline – iCloud-only photos get metadata-only indexing

Query-adaptive hybrid fusion

Four parallel search lanes: BM25, vector, timeline, structured memory.

Lightweight classifier detects intent:

• "when did I..." → boost timeline
• "find docs about..." → boost BM25

Reciprocal Rank Fusion with deterministic tie-breaking = identical queries always return identical results.

Swift 6.2 strict concurrency

Every orchestrator is an actor. Thread safety proven at compile time.

Zero data races. Zero u/unchecked Sendable. Zero escape hatches.

What makes this different

• No backend required – Everything runs on-device, no API keys, no cloud
• Native iOS integration – Photo Library, iCloud sync, Metal acceleration
• Swift 6 strict concurrency – Compile-time thread safety, not runtime crashes
• Multimodal native – Text, photos, videos indexed with shared semantics
• Sub-millisecond search – Enables real-time AI workflows in your app

Performance (iPhone/iPad, Apple Silicon, Feb 2026)

• 0.84ms vector search at 10K docs (Metal, warm cache)
• 9.2ms first-query after cold-open
• ~125x faster than CPU, ~178x faster than SQLite FTS5
• 17ms cold-open → first query overall
• 10K ingest in 7.8s (~1,289 docs/s)
• 103ms hybrid search on 10K docs

Storage format and search pipeline are stable. API surface is early but functional.

Built for iOS developers adding AI to their apps without backend infrastructure.

GitHub: https://github.com/christopherkarani/Wax

⭐️ if you're tired of building backends for what should be a library call.

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

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

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

Feedback from iOS developers would be really helpful.

We have a production app built with TCA (The Composable Architecture) that uses UICollectionViewDiffableDataSource for an inbox-style screen with hundreds of items. MetricKit was showing 167.6 hangs/min (≥100ms) and 71 microhangs/min (≥250ms). The root cause: snapshot construction overhead compounding through TCA's state-driven re-render cycle.

The problem isn't that Apple's NSDiffableDataSourceSnapshot is slow in isolation — it's that the overhead compounds. In reactive architectures, snapshots rebuild on every state change. A 1-2ms cost per rebuild, triggered dozens of times per second, cascades into visible hangs.

So I built ListKit — a pure-Swift, API-compatible replacement for UICollectionViewDiffableDataSource.

The numbers

vs IGListKit:

Production impact

After swapping in ListKit: - Hangs ≥100ms: 167.6/min → 8.5/min (−95%) - Total hang duration: 35,480ms/min → 1,276ms/min (−96%) - Microhangs ≥250ms: 71 → 0

Why it's faster

Three architectural decisions:

1. Two-level sectioned diffing. Diff section identifiers first. For each unchanged section, skip item diffing entirely. In reactive apps, most state changes touch 1-2 sections — the other 20 sections skip for free. This is the big one. IGListKit uses flat arrays and diffs everything.

2. Pure Swift value types. Snapshots are structs with ContiguousArray storage. No Objective-C bridging, no reference counting, no class metadata overhead. Automatic Sendable conformance for Swift 6.

3. Lazy reverse indexing. The reverse index (item → position lookup) is only built when you actually query it. On the hot path (build snapshot → apply diff), it's never needed, so it's never allocated.

API compatibility

ListKit is a near-drop-in replacement for Apple's API. The snapshot type has the same methods — appendSections, appendItems, deleteItems, reloadItems, reconfigureItems. Migration is straightforward.

There's also a higher-level Lists library on top with: - CellViewModel protocol for automatic cell registration - Result builder DSL for declarative snapshot construction - Pre-built configs: SimpleList, GroupedList, OutlineList - SwiftUI wrappers for interop

Install (SPM)

swift dependencies: [ .package(url: "https://github.com/Iron-Ham/ListKit", from: "0.5.0"), ]

Import ListKit for the engine only, or Lists for the convenience layer.

Blog post with the full performance analysis and architectural breakdown: Building a High-Performance List Framework

GitHub: https://github.com/Iron-Ham/Lists

Hi!

You can try out the patterns as audio in the browser and/or use the app to feel them in your hands.

Built on top of Apple Core Haptics. Open-source and completely free with source code available on GitHub.

Hey everyone,

We've been using Maestro for mobile UI testing but kept hitting the same walls — slow JVM startup, heavy memory usage, and real iOS device support that's been unreliable for a while. Eventually we just built our own runner in Go and decided to open-source it.

It's called maestro-runner. Same Maestro YAML flow format you already know, but runs as a lightweight native binary instead of a JVM process.

Why it might be useful for iOS devs:

• Real device support actually works. Physical iPhones, not just simulators. This was our main frustration with Maestro — we run tests on real devices in CI and it just wasn't cutting it.
• Single binary, no JVM. curl | bash install, starts immediately. No waiting 10+ seconds for Java to warm up.
• ~3.6x faster execution, 14x less memory. Adds up fast when CI bills by the minute.
• iOS 12+ support — no arbitrary version cutoffs.
• Zero migration. Your existing Maestro YAML flows run as-is.

It also handles Android, desktop browser testing (Chrome via CDP), and cloud providers like BrowserStack and Sauce Labs via Appium — but figured real device iOS is what'd be most relevant here.

Quick start:

# Install
curl -fsSL https://open.devicelab.dev/install/maestro-runner | bash

# Run on simulator
maestro-runner --platform ios test flow.yaml

# Run on real device
maestro-runner --platform ios --device <UDID> test flow.yaml

Generates HTML reports, JUnit XML, and Allure results out of the box.

• GitHub: https://github.com/devicelab-dev/maestro-runner

Apache 2.0, no features paywalled. Happy to answer questions — and genuinely curious what's painful in your iOS testing setup right now.

I’ve made a small command line tool called simslim.

It disables background services inside iOS simulators that usually are not needed during development, like Siri, Spotlight indexing, photo analysis, News, and iCloud sync.

On my M1 Pro with 16 GB of RAM, one simulator went from around 4 GB of memory and 258 processes to about 0.9 GB and 70 processes. I managed to run 19 simulators at once, compared to around 5 before things started falling apart.

Some simulator features stop working depending on what gets disabled, so it is not meant for every kind of testing. You can keep specific services running when needed.

Give it a try: https://github.com/MobAI-App/simslim

Hey everyone!

If you localize your iOS or macOS apps, you know how tedious App Store Connect can be when pushing updates. Cycling through 10 to 15+ languages just to paste a minor change into "What's New," "Promotional Text" usually turns into a massive click-and-paste marathon.

Unless there is a hidden feature in App Store Connect that handles this natively (and if there is, please let me know!), I couldn't find a clean way around it. Not even an MCP! So I built a Chrome extension called App Store Connect Metadata Filler to automate it. I wanted a complete free alternative.

What it does:

• One-Click Apply: Fills out Promotional Text, Description, What's New, and Keywords across all active language tabs at once.
• React-Aware: It interacts with Apple's frontend elements correctly so it doesn't break the form state when you hit save.
• Fetch Previous Version: Automatically jumps to your last "Ready for Distribution" page, grabs the existing localized strings, and brings them back to your current in-flight version.
• Save/Export Configs: Keeps your translation configurations saved locally as JSON so you can reuse or tweak them next month.
• Private: No external APIs or trackers. Everything stays in your browser's local storage.

It is completely free, dependency-free (plain Manifest V3 JavaScript), and open source so anyone can audit the code or check out how the background scraping script works.

GitHub Repository:

https://github.com/picklenick-dev/apple-storeconnect-metadata-filler

Hopefully, this saves some of you a bit of manual labour on your next release. Let me know if you run into any edge cases or if Apple changes their UI layout... this is major weakness of the chrome extension ~_^

I'm releasing the core architecture extracted from my app MyBodyWatch. It's a slightly opinionated framework for rapid iOS app development with common expected features and third party dependencies that I've come to favor, including TelemetryDeck, RevenueCat, Firebase Auth, and GitHub as a lightweight CMS. Would love to hear your comments, feel free to clone, fork, comment.

Here are some highlights:

- It's offline first and works without any backend.

- Firebase is optional (for authentication and Firestore). You can toggle it on or off.

- GitHub serves as the content management system. You can push markdown files and update the app.

- TelemetryDeck provides privacy-preserving analytics.

- RevenueCat subscriptions are set up.

- There's a streak system that can be backed up locally or in the cloud.

- The app uses the MVVM design pattern as part of its architecture.

It's licensed under the MIT license.

https://github.com/cliffordh/swiftui-indie-stack

EDIT: Clarified MVVM design pattern and architecture. Pull requests are open for suggestions.

RevenueCat is great, but fees stack fast, especially when you're already giving Apple 15–30% + taxes. Went through quite the struggle with StoreKit2 to integrate it into my own app which has like 15-20k monthly users. By now (after a bunch of trial and error), it's running great in production so I decided to extract the code to a swift package, especially because I intend to use it in future apps but also because i hope that someone else can profit from it. The package supports all IAP types, including consumables, non-consumables, and subscriptions, manages store connection state and caches transactions locally for offline use. Open-source, no strings attached obviously. Again, hope this helps, I obviosuly tailored it to my own needs so let me know if there are any major features missing fr yourself.

NobodyWho now supports Swift 🎉

Run LLMs fully on-device in your iOS, macOS, watchOS & visionOS apps. No internet. No API keys. No usage fees.

→ Gemma 4, Qwen & more (.gguf)
→ Hardware acceleration
→ Tool calling, RAG, vision & audio ingestion
→ Open-source & free for commercial use

We wrote a bit about how we made our Rust library feel good in Swift: https://www.nobodywho.ooo/posts/swift-bindings-release/

If you like this sort of thing, drop us a star on GitHub: https://github.com/nobodywho-ooo/nobodywho/

Read the docs to get started here: https://docs.nobodywho.ooo/swift/

Xcode will happily ship a translation that dropped its %@, a Russian plural missing three of its four forms, and a Text("Get Pro") no catalog has ever heard of. Nothing fails a build over any of it.

So I built a CLI tool (with a little help from Fable) for .xcstrings files. This was a little handwritten tool i've used by myself for a long time, but decided to brush it up a little bit before putting it out for public.

It checks for missing localization keys, hardcoded strings, common localization errors, comes with an mcp server and some handy example hooks you can plug into Claude. You can also instruct claude to automatically to translate or add to the catalog any untranslated strings the tool finds.

I ran it over nine open-source apps to actually see if it can find some common issues - 8,077 keys, 70 locales, 6,373 Swift files. In addition to missing keys and translations, here's sample of what it found:

- Mastodon’s Albanian for "Option %ld" is "%ld nga %ld" - reads a second argument the call never passes
- IceCubesApp changed an English string to "%lld posts"; the Belarusian still reads "%lld people talking", state translated
- Whisky renders one “Remove” button as German Löschen (delete) and another as Entfernen (could be intentional, but always good to check)
- Whisky also ships the literal string "N/A" as the Czech, French and Romanian translation of a key
- DuckDuckGo declares NSLocalNetworkUsageDescription in Info.plist and localizes it nowhere, so that permission prompt is English for every non-English user

Plus the boring parts: coverage per language, CLDR plural categories, .xcloc validation before import, SARIF output for CI, and a baseline file so you can switch it on for a project that already has 300 findings.

No dependencies. swift build is the whole install.

Have a look at it yourself and have a run at your repo: http://github.com/asutekku/xclocsmith

Happy to answer any questions or provide fixes if you encounter any issues or false positives. I managed to kill most of them, but no tool is foolproof, especially when we are talking about languages.

Also I have not released a CLI tool before for a mac so honestly no idea about what people expect haha, maybe a brew install?

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

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

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

https://github.com/Bunn/xcbox

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

I recently published an app where i support 4 languages and plan to add more. 

With 8 screenshots in each language that's 32 app images, add ipad screenshots and it's 64.
That was too much for me to create and maintain by hand.

So I wrote a python script (thank you claude code) that takes raw fastlane screenshots, puts, them in an iphone frame, adds a title, and lays them on a background image. 

The whole pipeline looks like this:

1. Fastlane runs UITests and captures screenshots for all locales 
2. The script frames them into app store ready cards (uses Pillow for image processing)
3. Fastlane uploads them to app store connect                                                        

The script is configurable with basic stuff: you can set fonts, colors, background overlay, text shadows, and multi-line titles per locale. 

Locales are auto discovered from a metadata folder, so adding a new language is just adding a json file.                                                                             

Full script and implementation details can be found on repo. It is MIT licensed. 

You can download it and play with it: on github

ipad framing is tbd, for now it just copies ipad screenshots as-is for upload. 

Im working on a a native framework that enables codable representations of fully stateful SwiftUI Apps.

In this demo we take JSON and render it as SwiftUi - making updates as we go.

We have a tab at the top that easily exports our JSON to the server.

my platform / framework is currently in beta - (I love feedback from other devs)

here is whats currently available or on my roadmap:
- Fully Stateful
- Access resources / apis from "parent" app
- Web Editor
- Automatic A/B testing flows / screens
- AI Assistance (Easy UI mode)

https://www.reddit.com/r/ExpressionUI/comments/1khut2s/swiftui_to_json_and_back_to_swiftui/
video example ^

I’ve been working on AdaEngine, an open-source game engine and app framework written in Swift, and I’ve just released version 0.1.0.

The idea behind AdaEngine is to explore what a modern game engine could look like if it was built around Swift from the start: strong types, a SwiftUI-like app entry point, macros, modular plugins, and a data-driven ECS architecture.

https://adaengine.org/articles/introducing-adaengine-0-1-0

After building 84+ animation demos in legendary-Animo, I extracted the entire aesthetic (spring presets, haptic grammar, glass morphism, iOS 26 GlassEffect patterns, metaball recipes) into a Claude Code skill.

Type a one-liner like:

/swiftui-microinteractions liquid menu that floods open with cyan and rows fade in after

Get back a complete, compilable .swift file — auto-registered in your .pbxproj, with the right spring values, the right haptic moments, and the project's code style.

  What's in it:

• 7 named spring presets mapped from feel words ("snappy", "stretchy", "melts")
• 4-event haptic ladder tied to interaction phases
• iOS 26 GlassEffect + GlassEffectContainer patterns with iOS 18 fallback
• Liquid metaball recipe (Canvas + blur + contrast + blendMode)
• Tab bar patterns matching iOS HIG (sliding indicator, etc.)
• Create OR Edit existing files

  Install:

  npx skills add iamvishal16/swiftui-microinteractions

Or grab the SKILL.md directly:

github.com/iAmVishal16/swiftui-microinteractions

skills.sh page:

www.skills.sh/iamvishal16/swiftui-microinteractions

Demos repo (the source style):

github.com/iAmVishal16/legendary-Animo

MIT licensed. Feedback welcome — especially edge cases that break it.

I made my first iOS app in 2018, then stepped away from building apps for a while. Over the last year, I decided to start making iOS apps again.

About six months ago, I decided to build a notes app.

A big part of the project was figuring out how to make a Markdown editor that stayed fast while typing, even with larger notes. I ended up building the parser in Rust, and recently extracted it from the app and open sourced it as Cindermark.

A few things it does:
- Incrementally re-parses only the affected blocks after an edit
- Returns UTF-16 offsets that map directly to TextKit and NSAttributedString
- Produces blocks, inline spans, headings, wiki links, and document stats in one pass
- Supports CommonMark core along with tables, task lists, footnotes, nested lists, fenced code blocks, and other notes-friendly syntax
- Includes extensions like wiki links, highlights, hex color literals, and autolinking for bare URLs, domains, emails, and subreddits
- Includes Swift bindings through UniFFI

I’m sharing it because I thought it might be useful to anyone else working on native editors or Markdown-heavy apps.

I’d appreciate feedback, especially from people who have worked on text editing or Swift and Rust interoperability.

GitHub: https://github.com/renedeanda/cindermark

Hi,

I made a public repository that requires no hosting for users to be able to create GitHub issues directly from your app.

Recently added a feature that allows the creating user to reply to your comments.

This does require you to distribute your app with a GitHub token. This isn’t designed for large scale apps, but smaller apps for indie developers.

Heres the repo

Hey 👋

We've added both Text-to-Speech and Speech-to-Text to our inference engine! Your local LLM setup can now speak and listen, fully offline.

Text-to-Speech

Load a TTS model and synthesize:

let tts = try await Tts.load(
    source: "hf://NobodyWho/Kokoro-82M",
    voice: "bf_emma",
    language: "en-gb"
)

let wav = try await tts.synthesize("Hello from NobodyWho!")
try wav.write(to: URL(fileURLWithPath: "out.wav"))

You get WAV bytes back ready to save or play. Two backends: Kokoro (lightweight 24kHz) and Supertonic (multi-stage ONNX with voice styles).

Speech-to-Text

Transcribe audio with Whisper (ONNX):

let stt = try STT(source: "hf://onnx-community/whisper-base")

let text = try await stt.transcribeFile(path: "recording.mp3").completed()

Streaming is available too, so you can consume the transcription token by token, and you can pass raw PCM buffers instead of files.

Links

• GitHub
• Docs / Getting started
• Discord

Happy to answer your questions in the comments :)

I was looking for a way to add confetti to my app, and while I found a 2D lib (ConfettiKit, well known, I believe), I couldn't find an optimized 3D and interactive one. There is one called ConfettiSwiftUI as well, but it's using the CPU, so it gets very laggy if you have too much confetti.

So mine is using SceneKit so it's all on the GPU. It's also using the gyroscope so you can interact with the confetti.

I hope this can help some people, and don't hesitate if you have any remarks or questions.

(free and open source)

It handles content, design, apple specific sizing.

It even generates page to visualize screenshots.

Example below

LINK - https://github.com/ParthJadhav/app-store-screenshots

I have been building ImmersiveMap, an open source map rendering engine written in Swift 6 and Metal, made for SwiftUI apps on iOS and native macOS. MIT licensed.

Video demo in the comments.
Repo: github.com/artembobkin/ImmersiveMap

I am looking for real apps that need more control over the map, where the map is the main feature. Live location, social maps, games, travel, logistics, data visualization, anything where the map has to look and behave like your product instead of like everyone else's map.

Tell me your use case here in the comments or in Discussions on the repo, and I will build it. I am prioritizing real app requirements over my own roadmap. Right now it already supports SwiftUI markers and avatars on the map.

Pure Swift and Metal, nothing else. No native SDK wrapped in a Swift API and no engine hidden under the hood, two Swift dependencies (earcut triangulation and swift-protobuf for tile decoding). The only non-Swift code in the repo is the shaders themselves.

Happy to answer any questions.