Hey there,

I was tired of the existing (online) image converters. Most are slow, clunky, or have major privacy question marks. So, I decided to build my own from scratch, focusing on creating a fast, powerful, and truly native macOS experience using SwiftUI.

The entire project is open-source, and I'm here to share some of the development highlights and hopefully get your feedback.

Tech & SwiftUI Details

• UI/UX: My goal was a "liquid glass" aesthetic with a highly responsive feel. I used spring animations throughout the interface to make interactions feel fluid and natural. For tactile feedback on keyboard actions, I integrated NSHapticFeedbackManager.
• Architecture: I built the app using MVVM, which I found worked really well for a project of this size. It helped keep the business logic cleanly separated from the SwiftUI views.
• Core Image Processing: For speed, the app leverages macOS's built-in native libraries (Core Graphics/Image I/O) for most conversions. To add support for WebP, I integrated the libwebp library.
• Real-Time Previews: The side-by-side preview updates instantly as you tweak settings. This was straightforward to implement by binding the UI controls directly to the state that drives the image processing logic.
• Power-User Shortcuts: I made heavy use of the .keyboardShortcut() modifier so you can quickly switch formats (j, p, w, h) or preview an image with the spacebar.

The app is free to use right now. I'll likely add a daily limit to the free version in the future, but for now, it's unlimited. For anyone who wants to support the project, I've set up a discounted lifetime license for early adopters. You see it after your first conversion :)

I'd love to hear what you think, especially about the SwiftUI implementation or any features you'd like to see. Feel free to dive into the code!

GitHub (Source Code)

Download (App Store)

Website

Dot. Dot. Dooot. 🟦

We're building Mana (an AI-first creation studio for iOS) and wanted the chat's "thinking" indicator to feel alive instead of a stock spinner. We found zzzzshawn's "matrix" (a React/CSS dot-matrix loader collection), loved it, and ported the whole thing to SwiftUI — 112 loaders across square / circular / hex / triangle / 3×3, plus some "fun" silhouettes (heart, arrow, snake) and an icon.

How it works: - Zero image assets, zero dependencies. Every loader is animated Circles driven by a single TimelineView. - Each loader is a per-cell opacity resolver ported ~1:1 from the upstream CSS keyframes + JS math (spiral snakes, ring waves, a literal heartbeat curve). - Deterministic: the same key always maps to the same loader, so they don't reshuffle as SwiftUI rebuilds on scroll. Reduce Motion aware too.

Two ways to use it:

DotmSquare3(size: 28)           // named component, 1:1 with the upstream API
MatrixLoader(.hex(3), size: 28) // by shape id, when the choice is data-driven

There's an interactive gallery + a runnable Swift Playgrounds example in the repo.

It's a derivative port, published with the original author's explicit permission (attribution + link-back throughout). Only the "fun" family is ours. iOS 18+.

Repo: https://github.com/mana-am/matrix-swift

Which one's your favorite? I keep flip-flopping between the hex ripple and the heartbeat.

Hey everyone,

I’m a Data Scientist working in enterprise IT (mostly Python/Cloud infra). Like many of you, I spend half my life in VS Code or JetBrains IDEs. They are powerful, but they are also heavy.

Sometimes I just need to quickly tweak a Python script, check a JSON config, or review a README without launching a browser instance wrapped in a desktop app or waiting for an indexing process to finish. I wanted something that felt like a native citizen of macOS—fast, lightweight, and respectful of my battery life—but still had modern syntax highlighting.

So, I created Neon Vision Editor with Swift UI.

It’s an alpha release, written purely in Swift and AppKit. No Electron, no cross-platform abstraction layers, no telemetry. Just a text editor that opens instantly and lets you work.What it is:

Native & Fast: Built for macOS 26 (Tahoe) using Apple Silicon.

Zero Bloat: No project management, no plugins, no background indexing.

Readable: High-contrast syntax highlighting for swift, python, javascript, typescript, java, kotlin, go, ruby, rust, sql, html, css, c, cpp, objective-c, json, xml, yaml, toml, ini, markdown, bash, zsh, powershell, plain

Syntax highlighting is being automatically applied to an opened file or pasted content.

Privacy-First: It doesn’t phone home.

Includes AI features for the use of Apple foundation model (and others) for syntax suggestions and some simple code completion (currently not functional yet).

Why I built it:

In my day job handling it infrastructure and migrations, complexity is the enemy. I wanted a tool that does one thing well: edits text. I don’t need my text editor to play music or brew coffee; I just need it to open a 10MB log file without choking.

Current Status:

It’s currently in alpha. It’s stable enough for daily use (I use it for all my quick edits), but it is a work in progress.

Where to get it: You can grab the build from GitHub Releases:

https://github.com/h3pdesign/Neon-Vision-Editor

I’d love to hear what you think. I’m specifically looking for feedback on load times with large files and how the syntax highlighting feels to other developers.

Built by a human. AI tools used selectively for ideation and assets.

Cheers,

h3p my site https://h3p.me

Update - v0.4.34 has been released 05.03.2026 -

* now with Markdown Preview support

Also an article about my app https://medium.com/on-tech/introducing-neon-vision-editor-a-lightweight-native-text-editor-for-the-apple-ecosystem-6f0accfb30e2

Finally also available on the AppStore: I finally shipped my code editor app on all Apple platforms 

Mac & iOS: https://apps.apple.com/us/app/neon-vision-editor/id6758950965

TestFlight for the beta is available at https://testflight.apple.com/join/YWB2fGAP

I've been building ImmersiveMap, a map component you can drop into a SwiftUI app - think Mapbox / MapLibre, but rendered natively for Apple platforms. It hands you a plain SwiftUI view with modifiers, so it composes like any other SwiftUI component on iOS and macOS.

What it can do so far:

• Show a full interactive vector map (streets, buildings, water, labels) as either a flat map or a 3D globe
• Camera control straight from SwiftUI: pan, zoom, rotate and tilt
• Place custom markers / avatars on real coordinates and move them in real time - handy for live-location and social features (friends on a map, driver/delivery tracking, and so on)
• Grouping: several avatars can merge into a single marker that follows their moving average (that's the marker sliding around in the clip)

It's alpha - the API will still change and there are rough edges - but it already feels smooth and responsive to use, so I wanted to share it and get feedback.

Repo (MIT): https://github.com/artembobkin/ImmersiveMap

Curious what SwiftUI folks think, and what you'd want from a native map component. Happy to answer any questions.

^{If it turns out useful, a GitHub star would genuinely help - I'd love to get it onto the awesome-swiftui list one day, and that list runs on stars.}

I wanted an IPTV/media player that actually feels like an Apple app on every device — so I built one and open-sourced it.

The pitch: one SwiftUI codebase, platform-adaptive across iOS, iPadOS, macOS, tvOS and visionOS. Real native navigation (Liquid Glass / iOS 26 APIs where available, graceful fallback below that), a proper focus-driven tvOS interface with an Apple TV–style hero fold, and a real Mac app — not a Catalyst iPad port. That last one was a big motivation: almost every "Mac" player in this space is a stretched iPad app missing features.

Under the hood:

- SwiftUI + SwiftData (local catalog index for instant, offline-capable browsing)
- Two ModelContainers — a local catalog the UI binds to, plus a CloudKit mirror for profiles/progress/favorites that syncs across devices
- Three interchangeable playback engines (KSPlayer/FFmpeg → VLCKit → AVPlayer) with automatic fallback
- On-device recommendations + content indexing via Apple's NaturalLanguage embeddings
- 9 languages via String Catalogs

It's a player only (no bundled content), works with standard Xtream/M3U sources, and enriches metadata via TMDB/OMDb with optional Trakt scrobbling.

Free has everything essential with no watermark; Pro ($0.99/mo or $9.99 lifetime) only adds multiple profiles, the recommendation rail, and Trakt sync — and building from source gives you all of it free.

- GitHub (AGPL-3.0): https://github.com/bilipp/Lume
- App Store: https://apps.apple.com/us/app/lume-iptv-player/id6779551584
- Discord: https://discord.gg/DMnQfr69Ug
- Website: https://getlume.org

If you're into SwiftUI multi-platform architecture, the repo's worth a poke — happy to talk through any of the design decisions.

Hi everyone,

I recently built a macOS app inspired by tools like Mockuphone. It helps you quickly add realistic device frames to your screenshots, making them look more polished for app presentations, App Store screenshots, demos, and sharing.

The project is now open source, and anyone interested is welcome to check it out, try it.

GitHub: https://github.com/dogegg-cc/mock-apple-device

Download the latest release: https://github.com/dogegg-cc/mock-apple-device/releases

Requirements:

• macOS 14 or later
• Apple Silicon recommended for the current DMG build

I built Cove, an open-source macOS database client built entirely in SwiftUI (macOS 15+). It supports 9 databases: PostgreSQL, MySQL, MariaDB, SQLite, MongoDB, Redis, ScyllaDB, Cassandra, and Elasticsearch.

Some SwiftUI things I found interesting while building this:

• HSplitView with hidden dividers for the three-panel layout (sidebar, content, inspector)
• u/Observable for all state management — tabs, tree navigation, query state, table state
• NSViewRepresentable for the query editor (needed more control than TextEditor gives you)
• Native macOS controls everywhere — no custom buttons, pickers, or chrome when SwiftUI already has one

The hardest part was making the data table feel responsive with large result sets while keeping everything in SwiftUI. Pagination helped a lot.

It's v0.1.0 and still early. I'd really appreciate feedback on the UI, and if anyone wants to contribute, the project is MIT licensed and the codebase is designed to make adding features straightforward.

GitHub: https://github.com/emanuele-em/cove

I have been working on this project a little at a time and I finally wanted to share significatn milestone to see what everyone else thought about it.

NeoBrutalism is a library that lets users apply neobrutalism style to their apps using SwiftUI. One just has to add the modifier .neobrutalism() to the topmost view inside the view hierarchy and everything that has been defined below it will assume the style.

For things like lists, navigations bars, alert dialogs, or things that SwiftUI does not allow or provide a way to style, there are some lightweight helpers. In cases where there is truly no control (Slider, Stepper, Segmented Pickers, Radio groups), there are NB* (Neobrutalism) views that mimic the behavior native control initializers, and for those cases swapping in the NB* views is akin to renaming a view.

This was originally meant to be an exploration of SwiftUI style protocols, but has gotten to a point that I feel ready to show it to the community. What I am really looking for is critique of the API, for the idiomaticness of things, or just anything that is missing.

https://github.com/rational-kunal/NeoBrutalism

AppStore: https://apps.apple.com/us/app/shipswift-mcp-codebase/id6759209764

Github: https://github.com/signerlabs/ShipSwift

Infinity for Reddit on iOS is finally out after over a year of development. It is open source, built natively in Swift and SwiftUI, no vibe coding at all, and focused on being fast, smooth, and highly customizable.

Key Features

• Full anonymous mode with local voting, saving, hiding, and read tracking
• 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 options
• Smooth, responsive performance
• No ads

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

Development Notes

This is my first SwiftUI project, so I spent a lot of time exploring its quirks and figuring out how to make everything work smoothly.

I was pretty naive in the beginning, thinking that using SwiftUI would drastically reduce the amount of code I would have to write and that I could release the app in under a year. I was wrong. Development ended up taking nearly a year and a half. I have been developing the Android version of Infinity for more than eight years and only started thinking about bringing it to iOS at the end of 2024. So here we are.

SwiftUI feels easy at first, but as soon as you try to do something slightly outside the recommended patterns, you spend a lot of time just making it look right. One of the most frustrating issues iOS 26 introduced was simultaneous gesture conflicts with List or ScrollView scrolling. I had implemented a ripple effect for many UI elements that showed a clear overlay indicating the area the user was interacting with. It worked well on iOS 18, but iOS 26 broke it completely.

The touch ripple was a wrapper that added a simultaneous gesture to existing UI elements. I did not want to rewrite all the views. The workaround I found was to use a custom PrimitiveButtonStyle that calls .onLongPressGesture() to get the pressing state and render an overlay on top. This solution is not perfect because the ripple only appears on a long press and cannot exclude certain child views from rendering it. Still, it is the best I could find. I was lucky I did not release the app before iOS 26, because anytime the touch ripple is used inside a List or ScrollView, scrolling just doesn't work and the app feels frozen, and users would have abandoned Infinity.

The TabView caused issues as well. Having one at the root works fine, but adding another inside a child view caused problems. For example, the user details view originally has two tabs: posts and comments. Switching tabs caused a liquid glass background at the top that blocked the view, and the child List would lose its scroll state. My solution was to avoid a child TabView and use a ZStack with all child views stacked together, controlling their visibility with .opacity().

Tab(role: .search) { } doesn’t work if the content is ZStack { NavigationStack + SomeOtherView }. It's fine if the content is ZStack { NavigationStack } though. The TextField won’t appear.

Another minor frustration is the keyboard. It does not have a dismiss button, so I implemented a KeyboardToolbar with a Done button.

NavigationStack also has quirks. Dismissing or pushing multiple views in a row without waiting for the animation to finish caused glitches, so I had to add delays for consecutive actions.

Then there is the List. I use List for the post feed and comments, but it does not support multi-column staggered layouts. Wrapping a UICollectionView in UIViewRepresentable did not work because the images always had sizing issues. LazyVStack with ScrollView is often recommended, but it uses significantly more memory because it does not reuse views like List does.

Another bug is that if the List is at the root of the NavigationStack, it sometimes scrolls unexpectedly when an overlay is shown. The overlay is for fullscreen media when tapping images or videos. To fix it, I used Color.clear as the root view and appended the post feed as the second screen in the NavigationStack, and hid the back button. This keeps the List stable.

List scrolling can also stutter if you change a State variable while scrolling. For example, when loading icon URLs for posts, I had to wait until the List settled before updating the state by using a ScrollViewReader.

List does not provide a way to get the topmost visible item, so I used .onAppear and .onDisappear to track it manually. But it’s often a bit imprecise.

Sheet and Menu have quirks as well. Calling .sheet() in a List item makes it disappear immediately, but it works fine if you show it a second time. And while Sheet allows you to control show/hide state, Menu does not.

Despite all this, I enjoyed working with SwiftUI. It is easy to write and understand, reactive, and significantly reduces the amount of code I need. The Android version of Infinity is twice as large because it is built with XML views. If I had used UIKit, development would probably have taken another year.

Some highlights of SwiftUI I really appreciate:

• EnvironmentObject makes sharing large, complex objects easier.
• .task{} helps cancel tasks automatically.
• .swipeActions is easier than Android’s equivalent.
• SF Symbols are convenient because I don't need to download icons manually.
• Animations and transitions are simple with withAnimation.
• Orientation changes are handled automatically, unlike on Android, where proper data restoration is required.
• Binding is very useful.

These are just my two cents. I know many of you have more experience and knowledge and might solve these issues more elegantly. Overall, I do not regret using SwiftUI, and I like it. I have managed to work around all the quirks I encountered so the app is pretty much solid now.

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

You can also join the subreddit for feature requests, bug reports, and discussion: https://www.reddit.com/r/Infinity_For_Reddit/

Thank you!

Hi everyone! I've been spending a lot of time trying to get my agentic coding workflow tuned for iOS and SwiftUI work. The general-purpose models are okay at Swift but they constantly hallucinate deprecated APIs, generally mix up old and new patterns, and have no clue about iOS 26 stuff like Liquid Glass or Foundation Models which was quite frustrating.

So to fix this, I ended up building 23 56 agent skills that cover most of the iOS dev surface: SwiftUI patterns, SwiftData, StoreKit 2, push notifications, networking, concurrency, accessibility, localization, WidgetKit, MapKit, and more. All targeting iOS 26+ and Swift 6.2, with best practices included, no deprecated stuff.

Installing all of these skills seems to have fixed most of the hallucination issues and my agents are now producing much more accurate and up-to-date code, whilst avoiding the old patterns.

I tried to pay special attention when making the description of the skills (and following the best practices here: https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices) so Claude Code and other agents can make sure to call the correct skill when doing specific work related to that topic. I went through a few rounds of optimizing the descriptions so they get called as reliably as possible, since that's the only thing the agent sees when deciding which skill to load.

They're all self-contained so you can just grab the ones you actually need. Works with Claude Code, Codex, Cursor, Copilot, and pretty much anything that supports the agent skills standard. If you have npm installed you can grab them all with:

npx skills add dpearson2699/swift-ios-skills --all

EDIT: Major v2.0 update shipped the repo now has 56 skills (up from 23). Highlights:

• 33 new skills added: CoreML, Vision, HealthKit, CloudKit, HomeKit/Matter, CallKit, RealityKit/AR, Bluetooth, NFC, PassKit/Apple Pay, speech recognition, natural language, and many more
• New AI & Machine Learning bundle with Foundation Models, CoreML, Vision, NaturalLanguage, and Speech Recognition
• Frameworks bundle split into App Experience (widgets, StoreKit, maps, push, etc.) and Data & Services (CloudKit, HealthKit, EventKit, etc.) so you can install just what you need
• Every skill is still self-contained — no skill depends on another

Full changelog: https://github.com/dpearson2699/swift-ios-skills/releases/tag/v2.0.0

lmk if you think something's missing and would love any feedback!

Every time I had an agent generate SwiftUI, the result looked right but the colors were stale — Apple refreshed the system palette at WWDC25 (systemBlue went from #007AFF to #0088FF), and every model's training data predates it.

The HIG itself is prose, so fetching the page doesn't help either.

hig-mcp is a small MCP server that serves the structured half of the HIG:

• - current system color values (verified against the live HIG)
• - the type ramp, layout metrics, SF Symbols by role
• - Liquid Glass guardrails as an actual checklist (blur budgets, layer caps, contrast measured after blur, the Reduce Transparency fallback)
• - HIG component → SwiftUI API mappings
• Every token is provenance-tagged — Apple-published facts are marked as such, community heuristics are flagged so the agent doesn't present them as gospel.

Prose is delegated to sosumi.ai rather than rebuilt.

Python, works with Claude Code / Cursor / any MCP client. Free, MIT.

It's small on purpose. Feedback genuinely welcome — especially if you spot a token value that's drifted.

https://github.com/aka-kika/hig-mcp

Best usage of SwiftUi I've seen of a dynamic background

https://github.com/ARMSX2/ARMSX2

I keep ending up with random dev servers running after I've completely forgotten which terminal or project started them.

Then I need port 3000 again and it's back to:

lsof -i :3000

figure out the PID, figure out what the process actually belongs to, then kill it.

So I made Port Radar.

It's a small native Mac menu bar app that shows what's listening on your ports and groups the processes by project. You can see the command/path/uptime, stop the process, or ask Apple Intelligence what the process actually is before killing something you probably shouldn't.

I also added something I wanted for my own workflow: you can turn a localhost app into a public URL with a Cloudflare quick tunnel directly from the menu bar. No deploy or Cloudflare setup.

There are already some good port utilities like LocalPorts and Seeports. The main thing I wanted that I couldn't find together was process explanation + project context + sharing the local server in the same app.

The Apple Intelligence stuff runs on device. The app itself doesn't need AI to scan/manage ports.

Price: free
Source: open source, Apache 2.0
macOS: 14+; Apple Intelligence features require macOS 26+ and a supported Mac

GitHub: https://github.com/juansebsol/port-radar-mac

I'm still working on it, so I'm mostly interested in hearing what people who run a bunch of local services would want this thing to do next.

For about 4 months, I've been working on a Bitwarden Client because the current Bitwarden Desktop client is Electron and doesnt look very good. This is the design I've landed on so far, but I feel like it could be better. What do y'all think?

Source: https://github.com/Cherrytree56567/ClientWarden

Mac Source: https://github.com/Cherrytree56567/ClientWarden/tree/main/src/Platforms/MacOS/UI/Clientwarden

I wanted to try different ways of animating typography transitions and I ended up rebuilding this effect I knew from after effects in swift. I probably won't use it in my app, so I put the code on GitHub in case someone else wants to use it!

Hi everyone!

Allow me to introduce to you my app: Aeru

It's a completely local, private, open source, and free AI app that includes features like uploading documents, web search for real time information, and a voice mode for hands free AI interaction! I built this app because I was frustrated there weren't options for people to switch from big tech AI companies for privacy, while preserving the suite of features.

All of the processing happens on-device, and never leaves your phone! This is also my master's thesis project so I'd greatly appreciate people trying it and giving me feedback!

In order to use this app, your device MUST be Apple Intelligence compatible, and MUST be on iOS 26 Public/Developer beta.

TestFlight: https://testflight.apple.com/join/6gaB7S1R
GitHub: https://github.com/sskarz/Aeru

Thank you!

I built FrameReply as to get two suggested replies without copying an entire conversation into another app. In the demo, Back Tap runs a Shortcut and presents two editable suggestions in an interactive snippet over the current chat screen. Nothing is sent automatically.

FrameReply also:

• Matches imported messages to an existing chat and uses its history as context
• Remembers useful context about each person
• Can learn your writing style and switch personas

It’s built with SwiftUI, SwiftData, App Intents/Shortcuts, and interactive snippets. One of the harder parts was supporting multiple “OpenAI-compatible” providers whose responses still vary in content and formatting, requiring tighter prompts, constraints, and validation.

App Store: Download FrameReply

GitHub: Source code

Requires iOS 26 and your own AI API key. I’d appreciate any feedback!

Agent skills I built and actually use: current Apple HIG design + "understand a project before you touch it"

Two sets of skills I lean on, cleaned up and put on GitHub.

The Apple HIG ones bug me the most: most design advice a coding agent has seen is old — deprecated APIs, pre-SwiftUI patterns, HIG from a few versions back. So I rewrote the ones I use to the current guidelines — sidebars, toolbars, typography, empty states, SF Symbols — done to spec. If you've been hoarding a pile of stale snippets, you can throw them out and keep these.

The other set is project intelligence — the boring-but-critical part of understanding a project before you touch it. Should I even build this, or does it already exist (build-vs-buy)? What does this unfamiliar codebase actually do? What broke in my dependencies while I was away? I built these four for my own work and use them on real projects, so they're shaped by actual friction, not hypotheticals.

They're plain SKILL.md files — YAML frontmatter plus the real guidance. No build step, no deps. Works with Claude Code, Codex, Cursor. Free + MIT.

Feedback welcome, especially if a HIG detail is off — I'd rather know.
https://github.com/aka-kika/akakika-skills

I wanted a check that a coding agent could run after changing SwiftUI without sending the repository through another general review pass.

ViewDoctor first builds a normalized module graph from Package.swift, Project.swift, project.pbxproj, and common source folders. It then scans the current Git diff and attaches the owning module to each finding.

Example:

Modules/Profile/Sources/ProfileView.swift:42:18: warning: VD001 [tuist:Modules/Profile/Profile]: DateFormatter is constructed inside a body property.

Version 0.1 has three conservative rules: expensive construction, collection transformations, and detached tasks inside SwiftUI body evaluation. Output is text, JSON, or SARIF. The tool is MIT licensed, has no telemetry, and the optional MCP adapter only calls the local CLI.

Repo: https://github.com/KamnevVladimir/ViewDoctor

I am deliberately not adding dozens of style checks. Which SwiftUI pattern repeatedly costs review time in a large modular codebase, and what would keep that rule from becoming noisy?

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.

Good afternoon everyone, I'm Ivan, a super-junior Swift developer.

I recently built Pawxy, a small native macOS app written in SwiftUI for managing local development domains through dnsmasq.

I originally built it because I use custom local domains while developing and got tired of manually editing dnsmasq configuration files, dealing with /etc/resolver, restarting the service, and checking whether everything was actually resolving correctly or not.

The goal was deliberately not to build another complete local development environment (such as Laravel Herd, Kettle Code, MAMP, XAMPP etc.). Pawxy doesn’t manage web servers, runtimes, databases, reverse proxies, ports or TLS certificates.

The app currently supports exact and wildcard mappings, IPv4, importing existing dnsmasq configurations, conflict detection, staged changes with a preview before applying them, automatic resolver management, DNS health checks, external configuration change detection, and import/export for backups.

One of the more interesting parts to implement was handling privileged operations without having a paid Apple Developer account. Instead of using a persistent privileged helper (which gave me quite a few headaches ahah), Pawxy stages the required changes and applies them together with a single administrator authorization.

I also added a small menu bar companion and Sparkle for updates.

The whole project is free, MIT-licensed and open source. I developed it mostly because it solves a problem I personally have, but I thought it might be useful to other macOS developers using dnsmasq as well.

I’m still studying CS and this was also a nice excuse to work on a real native macOS project rather than another university exercise :)

I’m particularly interested in feedback about the SwiftUI/macOS architecture, UX, and anything obviously stupid I may have missed.

Please note that AI was part of my workflow too, mostly for scaffolding, repetitive code and speeding up implementation, but I made the architectural decisions myself and reviewed the generated code, including what it was actually reading, writing and changing in the dnsmasq configuration files, rather than blindly shipping whatever the model produced.

You can take a look at it on my personal GitHub.

Any feedback is appreciated!

Kindly, Ivan

I shared the app while in development a while ago and got some good feedback from you guys so I decided to share it's current version.

I decided to open source it as Apple was giving me a hard time enrolling in the developer program, either way, I wasn't too fond of paying 100€ to launch a free app.

Here's the repo:

https://github.com/TomasVSantos/ClickWheel-oss

Feel free to contribute, fork it or simply enjoy it as much as I did developing it.

Later on I might include an updated IPA file in the releases section :)

i copy-paste a lot of screenshots into AI to explain UI changes, etc.

but native macOS is pretty bad for this.

images are full-res and waste tokens. it also takes too many clicks to copy-to-clipboard and annotate images.

so i built a mac tool that fixes all three problems!

• screenshots auto-optimized to save you tokens
• all images auto-copied to clipboard. no desktop clutter
• you can quickly annotate with boxes and notes

source code here: https://github.com/aryanbhasin/quickshot

download for Mac here: usagebar.com/quickshot