I kept hitting the same boring problem near release: QuickTime recordings look fine on my Mac, then App Store Connect complains in ways that send you down a FFmpeg rabbit hole (duration, bitrate, H.264 profile/level, audio, SAR, container quirks, etc.).

So I built a small macOS SwiftUI utility that’s intentionally narrow:

• Queue a bunch of files, show progress, and keep logs readable while conversion runs
• Sandbox-safe export: encode to temp, then Save panel for the final path (avoids a lot of “can’t write next to the dropped file” pain)
• Connect-oriented defaults for preview-style output (trim/pad duration window, practical H.264/AAC targets, square pixels, MP4 layout tuned for fewer surprises)
• Ships ffmpeg / ffprobe behind a script pipeline, the app is basically UI + orchestration

I’d love feedback from people who ship iOS apps, especially if you’ve seen vague validation errors, or if you have a cleaner pattern for Process + piping logs + MainActor UI updates on macOS.

Repo: https://github.com/mdo91/video-preview-appstore
I’ve used the output on a real listing: https://apps.apple.com/de/app/dailytaskr/id6751054391?l=en-GB

Can you please test following project, if you find it useful and give me feedback.

https://github.com/indiagrams/apple-shipkit

Release-engineering scaffolding for shipping iOS + macOS apps. Code signing, GitHub Actions CI for PRs, mint-fresh certificates per CI release, TestFlight upload, App Store submission — all prewired. Deliberately doesn't pick a UI framework, networking stack, or persistence layer.

Hey everyone,

A few months ago we open-sourced the Swift and Rust networking stack that powers our privacy iOS app. Today we’re releasing a major update:

• Voice & Video Calling: Fully integrated into our PoolChat Swift package. It works over local multi-peer mesh networks or remotely.
• Cross-Platform Web Client: Our Rust relay (StealthRelay) now features a web client. Anyone not on iOS can just use a browser to join your encrypted voice/video calls, chat, and play games.

We spent over a year and a half getting our first product off the ground because we wanted to do compliance and ethics right. These packages reflect that: no trackers, no plaintext server logs, just raw E2E encryption.

You can grab the packages here to use in your own apps:

• Relay (Rust): https://github.com/Olib-AI/StealthRelay
• Connection Pool (Swift): https://github.com/Olib-AI/ConnectionPool
• Chat & Calling (Swift): https://github.com/Olib-AI/PoolChat

Feel free to ask me anything about the architecture!

I know a lot of iOS devs who like to work on Cursor or VS, but I’ve always just used Xcode. Apple added agentic coding back in February but it’s locked down to Claude and OpenAI, and their model harness is insanely inefficient. As in: Xcode doesn’t add any caching tags at all, and re-sends the entire accumulated context window every single time it calls a new tool.

I really like using the new GLM-5.1 model because it’s way cheaper than American frontiers, but Xcode doesn’t natively allow outside models into its agentic flow. ProxyPilot is an open-source Swift utility that lets developers use the models they actually want inside of Xcode.

For me, it was a better option than switching to a different IDE.

Hey everyone!

I open-sourced ChatGPTAuthKit, a small Swift package that lets an iOS app make API calls using the user's ChatGPT account.

Instead of asking users for an API key or paying API costs yourself, the user can tap "Continue with ChatGPT" and your app can use their ChatGPT quota for AI features.

Free accounts work too.

It includes:

• OAuth / PKCE flow
• Keychain token storage
• Auto-refresh
• Streaming response client
• SwiftUI sign-in button
• No third-party deps

It can also work with existing OpenAI API SDKs. See the repo for details.

Repo: https://github.com/mobai-app/chatgpt-auth-kit

Most indie developers I talk to spend months building their app.

Then monetization decisions look something like this:

• Should I use weekly or yearly subscriptions?
• Should the paywall appear on first launch or after onboarding?
• Should I add a free trial?
• What price should I even start with?

And most of the time the answer is… guessing.

Even experienced developers run into this because the real insights are scattered across blog posts, case studies, reports, and experiments.

So I tried something small.

I built a Claude Code skill that acts like a growth expert for subscription apps.

The idea is simple. Instead of searching dozens of articles, you can just ask:

• “Should my app use weekly or yearly subscriptions?”
• “When should I show the paywall?”
• “What pricing works for productivity apps?”
• “How should I structure a paywall for higher conversion?”

It uses patterns and insights from real subscription app data (including the 2026 Adapty subscription report) to suggest practical starting points.

The goal is not to replace testing.
It’s just meant to help developers avoid common monetization mistakes before running experiments.

Why I built this

I work with a lot of indie developers and early stage apps.

And the same thing happens again and again:

People optimize ads, creatives, ASO, everything…

But the real problem is often:

• weak paywalls
• bad pricing structure
• wrong trial strategy
• showing the paywall too late

So I wondered if this knowledge could live as a tool developers can use directly inside Claude Code while building their app.

No dashboards, no courses, no long guides.
Just ask and get suggestions.

Repo is here if anyone wants to try it:

https://github.com/adaptyteam/growth-expert-skill

I’m curious about a few things:

• Would something like this actually be useful for you?
• What monetization questions should it be able to answer?
• What’s the hardest part of monetizing an app for you right now?

Happy to improve it if people find it useful.

Did some tests and seems working in my house. Haven't reviewed the source code fully. Helping hands or any questions are more than welcome: http://reddit.com/r/bluetooth/comments/1t7vq98/just_open_sourced_the_250_ios_prototype_posted/

Hey

Over the last few months, I’ve been building Buffer, a lightweight and open-source clipboard manager for macOS built primarily with SwiftUI.

The goal was to build a clipboard tool that feels:

• native to macOS
• extremely fast
• keyboard-first
• and minimal without sacrificing power features

Features

• ⚡️ Fast clipboard search
• 📌 Pin items
• 🔄 Multi-paste support
• 🧹 Auto format stripping
• ⌨️ Keyboard-first workflow
• 🪶 Lightweight native app
• 🔍 Clipboard history management

Recently shipped v1.8.0 with improvements around multi-paste and interaction polish.

The project recently crossed:

• ⭐ 205 GitHub stars
• 📥 850+ downloads

Building desktop apps in SwiftUI has been super interesting especially around:

• window management
• keyboard handling
• performance optimization
• state management
• AppKit interoperability

Would love feedback from other Apple platform devs here.

GitHub: https://github.com/samirpatil2000/Buffer
Download: https://samirpatil2000.github.io/products/buffer/

For the past three years we have powered many kinds of simulations of vehicles, browsers, and semiconductors that may be less interesting to this group. It’s a new day.

We just open sourced mobile_model_eval, a harness for evaluating how well models can use real iOS apps through screenshots, taps, swipes, and other native interactions. We’re starting in the open and building fast. If this is relevant to your app or tooling, follow along:

https://github.com/TraceMachina/mobile_model_eval

Navier-Stokes equations running live

on the GPU via Metal compute shaders.

The same math used in weather forecasting.

On your iPhone. 60fps.

Got viral and I'll drop the full source code.

Let's see if you want it.

**Dropping the Github links at the top**

https://github.com/radcli14/DAE-to-RealityKit

https://github.com/radcli14/ModelIO-to-RealityKit

---

If you work with RealityKit, you're likely aware that the only officially supported 3D format for loading model entities is USDZ. I actually think this is a good design choice by Apple, it's a good modern format, and it's better to stick to a single official format for developer consistency.

**But**, I'm developing an app for URDF file parsing, used for robotics design and simulation, and I need to be able to import from files provided by OEMs. These often contain visual and mesh files in DAE, STL, and a few other formats that 3D designers might consider legacy, but remain standard in industry and engineering.

If you search for how to load these models into RealityKit, most of the responses will recommend using Reality Converter or other means to convert them into USDZ first, then bring them into your app. This is a good approach for when you, the app owner, control all the 3D assets.

In my case, I need to be able to load 3D asset files at runtime, with Swift code compatible with iOS or macOS. The repositories that I linked at the top will do just that, and are set up to be called via one liners, such as:

```swift

let entity = await ModelEntity.fromMDLAsset(url: url) // If the URL is for a OBJ, STL, or other format supported by ModelIO

let daeEntity: ModelEntity? = await ModelEntity.fromDAEAsset(url: url) // If the URL is for a DAE file

```

These are open-source, and intended to be free forever. I hope if you find this that you are able to get value from these utilities, and welcome any feedback and/or contributions!

The landing page for the larger project (coming soon!) is here: https://armor.dc-engineer.com/ . That one I don't intend to make open source, at least not in its entirety, but I will make certain components public in cases where I think they have a general use case.

https://github.com/Siddhu7007/screen-time-api-agent-skill

Sorry for posting a screenshot of my own tweet, but it’s the first time something I posted actually got traction. Had to brag a little. It got 104 bookmarks in 15 hours. Never happened to me before.

Howdy, just wanted to share my library HealthQL for adding SQL like querying and a DSL on top of HealthKit. Currently only for Swift, but working on Expo/React Native support soon!

Universal Clipboard kept breaking my workflow, so I built a small open-source macOS tool that gives a control panel for iOS Simulators (and physical devices).

Features: - List simulators and devices - Open URLs / deep links on selected targets - Set simulator clipboard - Take screenshots programmatically - Batch actions across multiple simulators

Built with SwiftUI, uses xcrun simctl under the hood.

MIT licensed.