r/SwiftUI

I’ve been building Hostflip, a free and open-source native macOS app for switching /etc/hosts profiles from the menu bar. I thought its SwiftUI/AppKit seams might be useful to share here.

Most of the UI is SwiftUI. MenuBarExtra, the main window, and Settings share a single workspace store built with Swift’s Observation framework. The main window combines a sidebar and editor with a drift review: if another tool edits /etc/hosts, Hostflip stops writing and shows the difference for review instead of silently overwriting it.

Two small AppKit escape hatches were needed:

• NSViewRepresentable with NSTitlebarAccessoryViewController keeps the master switch pinned to the trailing edge. Putting it inside the SwiftUI-managed toolbar made it move whenever SwiftUI rebuilt the toolbar items.

• NSApplicationDelegateAdaptor handles the window lifecycle, so a normal launch opens the main window while a login-item launch remains menu-bar-only.

The privileged boundary stays outside the UI. A minimal root helper exposes a two-method XPC interface: a handshake and a single write operation that atomically replaces the merged hosts content. The app and helper verify each other’s code-signing identity before accepting the connection.

Hostflip is MIT-licensed and notarized. It currently requires macOS 14 or later on Apple silicon.

Source: https://github.com/heronapp/hostflip

I’d especially appreciate feedback on the SwiftUI/AppKit seam and the shared state flow between MenuBarExtra and the main window.

Every time I set up a new machine or wiped a simulator, I lost 20 minutes to

proxy certs and trust settings just to see a JSON response. So I built Owlse.

It's a Mac app. You add a Swift Package to your iOS/macOS project, and every

request your app makes streams to your Mac live over Bonjour. No proxy, no

certificate installation, no traffic leaving your machine.

**What's in it**

- Live streaming per device — history survives disconnects, and you can pause

or resume a stream without losing what's already captured

- Full request inspector: Overview, Headers (incl. cookies), Body, Timing, cURL

- Timing breakdown per phase — DNS, TCP, TLS, wait, download — plus protocol

and TLS cipher

- Timeline waterfall, so you can spot serialised chains when a screen feels

slow but no single request looks bad

- WebSocket frames grouped by connection, JSON pretty-printed

- Side-by-side compare that highlights which headers differ between two requests

- Mocks — write a rule (or build one from a captured request) and push it to

every connected device

- Crash reporting — on by default, symbolicated, sent on next launch

- Full-text search across headers *and* response bodies

- HAR export, so you can hand a capture to your backend team

**Setup**

Add the package, drop two keys in your Info.plist, done:

https://github.com/debuging-life/owlse

Free, macOS 13+, Universal and Apple Silicon builds.

Download: https://www.loudowls.com/products/owlse

Hi! I’m wondering if and how its possible to make a toolbar menu show the state of a toggle inside. I know using Toggle() in the toolbar shows this type of effect but i need a title and description to the toggle for it to make sense. Therefore there needs to be some window to open, which works fine with Menu(). However, that doesn’t show the state of the toggle when closed.

Apple managers to that with the photos app when selecting filters. See example images.

Thanks!

I would like to reproduce this menu above the keyboard in the notes application on swift? Is it natively possible?

GitHub: https://github.com/amosgyamfi/open-swiftui-animations/tree/master/Gists_To_Try/HandwrittenAnimation

There are 6 SwiftUI scribbling animations, English, Chinese, Spanish, Finnish, Korean, and Arabic. It will be animated in 32 languages. I will add the remaining later.

Copy the animations from GitHub, modify them to your need, or use your own SwiftUI path views.

As a former motion designer I was a bit disappointed by the lack of motion design in the app market. Since I released my own audio app, I am trying to bring subtile motion design into typography, colours and transitions. I am currently working on a new startscreen, hope you like it! I'd love to see more motion in apps, let me know what you think?

I'd like to reproduce this type of searchable element but at the bottom of the page. I tried using `placement: .bottomBar` but it doesn't work. Does anyone have any ideas?

None of these output production SwiftUI directly, the real question is which gives the cleanest reference to rebuild from with the least manual cleanup. Tested these for iOS over the last few months.

iSwift.dev is the closest to SwiftUI-native, free screen generator for individual screens, Pro starts at $20/mo for unlimited projects and 1,000 AI prompts per billing period. Generates buildable SwiftUI projects from plain English with views, state and navigation, multi-platform for iPhone, iPad, macOS and Watch. Better for individual screens than full cohesive multi-screen flows, and generated code needs cleanup before production, but it's the only tool actually outputting Swift.

SwiftUI Inspector is a free Figma plugin, Pro is a one-time $49. Exports colors, gradients, text labels, shapes, frames and Auto Layout as SwiftUI code. Handles rotation, opacity, shadows, blend modes, wraps in HStack/VStack/ZStack. Only useful if you already have a Figma design to convert, doesn't generate anything on its own. According to a 2026 comparison of 7 Figma-to-SwiftUI tools, expect to spend 20-50% of design time refining the output from any of them.

Compot is free on the App Store with IAP, 100+ prebuilt SwiftUI components, generates Swift from images or text. Good for grabbing components fast, not built for designing complete multi-screen flows.

Google Stitch is free, 400 daily credits, Gemini 2.5 Pro on experimental mode, exports Figma with layers plus HTML/CSS. Material Design native so everything skews Android, fighting it into HIG patterns takes more effort than it saves for iOS work. No production SLA, single user.

Sleek.design around $20/mo generates complete mobile app screens from a description, runs the same prompt through different models to compare outputs, exports Figma and code. Not iOS-native so HIG spacing and nav need explicit prompting, hits limits on complex custom components, better for early screens than final specs. Pairs well with SwiftUI Inspector on the Figma export to skip some manual rebuild.

Realistic workflow is generate screens fast in sleek or stitch, export to Figma, run SwiftUI Inspector for the base SwiftUI code, clean up by hand. Anyone found a shorter path than this?

Hey everyone, I'm the developer. I shipped Tien Len - 13 this week, an iOS version of Tiến Lên (Thirteen), the Vietnamese card game I learned in high school 20 something years ago. Every version on the App Store was ads, coin systems, and casino graphics. Just really ugly stuff. About 4 years ago I started on this, but I finally finished it.

Tech Stack

• Client: full SwiftUI
• Server: Vapor 4 (Vapor 5 migration coming), WebSockets for realtime play and SSE for updates
• Auth: passkeys only, no passwords, no email required
• No API keys in the binary. The client authenticates to the backend through App Attest, and a jwt from the passkey
• Feature flags via Grantiva, which is how ranked mode sits built but its currently off while the player base grows

Development Challenge

I originally built multiplayer on GameKit. Free infrastructure, first-party, seemed like the obvious call. It fought me everywhere

• The authenticateHandler flow hands you view controllers to present, which is clumsy to wire into a pure SwiftUI app cleanly
• Turn-based matchmaking gave me hard-to-debug timeouts and sync conflicts once real devices on real networks got involved
• Testing multiplayer meant provisioning sandbox accounts across App Store Connect and Xcode before anything worked, which made iteration painfully slow
• The core problem: keeping four devices agreed on one table state. GameKit's model is clients exchanging state with each other, so there's no authority anywhere enforcing the rules, and I ended up chasing conflicting snapshots instead of building the game

That last one is what killed it. A card game needs exactly one truth about whose turn it is and what's legal to play. So I replaced GameKit with a custom Vapor backend where the server owns the game. Clients send moves, the server validates them against the rule set and broadcasts new state over WebSockets.

AI Disclosure

Largely self built. Ive been an iOS Engineer for over 13 years, and a Mac engineer before that. The architecture, gameplay, UI, and backend are hand-written. I used AI as a tool in three places: localization, security testing, and verifying game logic edge cases against the rule sets.

The game itself

Offline vs three AI opponents with different play styles, Pass & Play with hand-off screens so nobody peeks at your hand, and online multiplayer with private lobbies, invite codes, and quick match. Southern and Northern rules plus custom house rules for chops, instant wins, and turn timers. Free, with a one-time $4.99 unlock for ranked when it goes live. No ads anywhere.

Up next: an interactive learn mode, emotes, more themes, and something fun you can flick around the table while you wait for your turn.

Happy to go deep on any of it, especially the App Attest setup, the GameKit lessons, or running Swift on the server.

https://apps.apple.com/us/app/tien-len-13/id6758355876

After getting a lot of feedback that Pocket Vault’s was looking a bit boring and bland, I completely redesigned the colour system, added proper light and dark themes, and reworked the overall visual hierarchy in SwiftUi. Here’s the code: https://github.com/AaravB09/Pocket-Vault

Let me know what you think of this new palette! I would love to hear what you guys think. Any feedback is welcome 😄

And if you guys can subscribe to my YouTube channel, I would really appreciate it. Here’s the link : https://youtube.com/@aaravbansal-9?si=-qJ6CmDqqLNPARDz

Hi r/ollama,

I’m Stephen, the indie developer behind Rockxy, an open-source native macOS HTTP debugging proxy.

I’ve integrated Ollama into Rockxy’s AI Assistant so developers can investigate captured HTTP, HTTPS, GraphQL, and WebSocket traffic using a model running on their own machine.

The AI Assistant demonstrates the current flow:

1. Select one or more captured requests.

2. Ask a debugging question, such as why a request failed or what changed between two flows.

3. Rockxy builds a bounded context from only the selected traffic.

4. Common sensitive values, including authorization headers, cookies, and tokens, are redacted.

5. Review Data shows the exact context before it is submitted.

6. After approval, the selected Ollama model processes that context through the configured local Ollama runtime.

7. The answer streams back with evidence connected to the source requests and suggested follow-up steps.

The Assistant is intentionally read-only. It may prepare a replay, comparison, filter, or another investigation step, but it does not execute those actions automatically.

The main design question is how much network evidence a local model actually needs.

Sending an entire capture session creates noise, wastes context, and may expose unrelated data. Sending only a summary is safer and faster, but could remove the exact header, timing, payload, or WebSocket event that explains the problem.

I would particularly value the community’s opinion on these questions:

- Should the model receive structured request summaries, raw HTTP sections, or a combination of both?

- Is Review Data useful control, or would you prefer a persistent per-project policy after the first approval?

- Which Ollama models and context sizes work well for JSON, REST, GraphQL, and WebSocket debugging on Apple Silicon?

- For multi-request investigations, should Rockxy pre-filter and rank evidence before inference?

- Should suggested actions remain user-confirmed, or would you want an optional agent mode with stricter permissions?

I’m especially interested in results from smaller local models. The goal is not to require the largest model just to explain a failed API request.

Rockxy is native Swift, local-first, and open source under AGPL-3.0:

https://github.com/RockxyApp/Rockxy

Rockxy website:

https://rockxy.io

Please be direct about anything that feels unsafe, slow, confusing, or unnecessary. Architecture suggestions, model recommendations, test cases, issues, and contributions are all welcome.

For r/ollama members who test this with a real debugging session and provide detailed feedback, please DM me your Mac configuration, Ollama model, findings, and the email you plan to use at checkout. I’ll personally send you a private Rockxy Pro tester discount code as a thank-you. The offer is for genuine testing and is not tied to upvotes or stars.

I created GitaSandesh to make the wisdom of the Bhagavad Gita accessible, clean, and distraction-free in daily life. Whether you're looking for daily quotes, structured reading, or quick verse translations, the goal was to build a simple, beautiful experience for iOS.

Key Features:

• 📖 Complete Bhagavad Gita – Read chapters and verses with clear translations.
• 🌅 Daily Inspiration / Sandesh – Get meaningful daily quotes to start your day.
• 🔍 Search & Bookmark – Easily save your favorite verses for quick reference.
• 🚫 100% Free – No ads, no paywalls, no subscriptions, and no data tracking.

App Store Link: https://apps.apple.com/us/app/gitasandesh/id6772055132

I’d love to get feedback from this community! If you have suggestions for features, UI tweaks, or localized translations, please let me know in the comments.

Thanks for checking it out! 🙏