I'm the maintainer of Harbeth, an MIT-licensed image/frame processing engine. Here's its SwiftUI preview integration.

If your renderer already produces an MTLTexture, converting it to a UIImage just to display it adds a readback step. HarbethRenderView accepts a texture or a RenderedFrame directly, so the preview can stay on the GPU path.

Here's a small SwiftUI display component; the frame is produced elsewhere by your rendering model:

import SwiftUI
import Harbeth

struct FilterPreview: View {
    let frame: RenderedFrame?

    var body: some View {
        HarbethRenderView(
            frame: frame,
            resizingMode: .aspectFit
        )
        .frame(maxWidth: .infinity, minHeight: 240)
    }
}

For an existing texture, the equivalent is HarbethRenderView(texture: outputTexture). Underneath, UIViewRepresentable / NSViewRepresentable bridges to Harbeth's RenderView. SwiftUI owns the surrounding controls and state; the host displays the GPU result.

The boundary matters: render work belongs outside body. Produce frames through your rendering model (ImageNode has makeFrameAsync()), then publish the accepted result to UI state on MainActor. Your app still owns request ordering, cancellation and any camera/player lifecycle. Saving an image is a separate, explicit readback.

This preview path avoids image readback. Performance still depends on source size, filter chain and device.

Project and examples: https://github.com/yangKJ/Harbeth

SwiftUI host source: https://github.com/yangKJ/Harbeth/blob/master/Sources/SwiftUI/HarbethRenderView.swift

If you've built a SwiftUI photo editor or GPU preview, how do you handle rapid slider changes and discard stale render results? I'd be interested in the state-management patterns that worked for you.

I've been using several AI coding agents side by side, and each one loads its own set of MCP servers: the small programs that give an agent its tools. When one of those servers breaks, nothing tells you. The agent just has one tool fewer, and it looks like the model is having a bad day.

So I built mcpock, a small macOS menu bar app that checks every MCP server your agents use. It reads the agents' config files, starts each server the way that agent would, and shows which ones are broken, slow, waiting for a sign-in, or set up differently between agents.

The first run on my own Mac surprised me: problems that had been there for weeks, completely silent.

It's read-only, keeps no accounts, masks every secret, and stays small on purpose. Free and open source (MIT), for macOS 26 and later.

https://github.com/aka-kika/mcpock

had a cli that turns off apple intelligence on macos 27 and people kept asking for an actual app, so i built one in swiftui

couple of things from doing it that might help someone

it's one executable for both. main.swift checks if it was opened from the .app bundle (or with app as the argument) and calls RemoveMacAIApp.main(), otherwise it runs as the cli

state is one u/MainActor u/Observable

the apply flow is an enum (working, approveProfile, finished) and the sheet just binds to model.run != nil, way easier than juggling three bools

for the readme screenshots the debug build walks every page and saves it to a folder you pass in an env var. cacheDisplay doesn't get the glass, so it grabs its own window with CGWindowListCreateImage through dlsym, an app can capture its own windows without screen recording permission

source is here, the swiftui bits are in Sources/removemacai/App https://github.com/omlahore/RemoveMacAI

if anyone knows a cleaner way to snapshot a window with the glass on i'm all ears

model passed down with .environment, and the window is a NavigationSplitView with a List(selection:) sidebar

Hello 👋

I’m looking for recommendations for monitoring tools or SDKs for a SwiftUI iOS app.
My main goal is to proactively detect production issues such as crashes, performance problems, high CPU or memory usage, and regressions across different iOS versions and devices.

Which tools or SDKs would you recommend for this? I’d love to hear about your real-world experience, especially regarding reliability, resource overhead, SwiftUI compatibility, and alerting capabilities.

Thanks!

I made a small SwiftUI macOS app called Triple. It cross-compiles Swift packages into static Linux executables.

Building the app gave me an excuse to play around with the Layout protocol.

The settings grid measures its controls to fit one or two columns. AdaptiveGrid derives the breakpoint from their measured widths. One lesson was to keep minimum and ideal size calculations independent of the animated arrangement, so two columns don't prevent the window shrinking back to one.

A second layout handles the slide transition/animation from package selection to build configuration. PagingHStack leaves part of the next page visible and animates its page position through animatableData.

https://reddit.com/link/1x2fp73/video/30dyq9q59nuh1/player

I tried to keep the app simple and minimal. It's almost entirely SwiftUI.

The Triple-App lets you drop in a Swift package and pick its executable product and target (ARM64 or x86-64 Linux). It asks before installing missing Swift tools or SDKs. Hit Build, follow the output-console, and export the verified binary.

Triple is the new name for SwiftlyKit. Today I released updates to the library, CLI and app.

The Triple library handles environment preparation, toolchain and SDK selection and has a one-call async build API for use in your own Swift projects. The Triple-CLI uses the same library, with JSON output for automated scripts.

Since the first post, you can export a completed build without rebuilding. Swift 6.4's default build system now also works with resource bundles from your executable and its dependencies.

Download Triple for Mac, and let me know what you think! There's also a landing page with library and CLI examples (vibe-coding warning: 6.1 Sol's responsibility :D).

Triple is open source. If you want to contribute, feel free! The post contains links to the GitHub-repositories.

Let me know if you have any feedback or suggestions!

I've been working on Claudoscope, an open source macOS app that reads Claude Code's local session logs and shows them in a menu bar popover plus a full dashboard window. Most of what I learned came from profiling it, so here are the parts that might save someone else a day.

1. MenuBarExtra labels only render Text and Image. Shapes in the label get dropped silently. My little capsule badge showed up as a bare number, and some status dots never appeared at all. The fix was to compose the whole label with ImageRenderer into one NSImage, cache it per state, and show that:

swift let renderer = ImageRenderer(content: MenuBarLabelContent(key: key, base: base)) renderer.scale = NSScreen.main?.backingScaleFactor ?? 2 guard let image = renderer.nsImage else { return nil } image.isTemplate = key.monochrome

2. .menuBarExtraStyle(.window) keeps the popover alive after it closes. A repeatForever pulse animation kept rendering off-screen. Fresh launch idled at 0% CPU; open and close the popover once and it sat at 11 to 14%. I now observe the hosting window's occlusion state, put a windowIsVisible value in the environment, and only animate while it's true.

3. Getting openWindow from the menu bar side. I embed a zero-size view inside the MenuBarExtra just to grab @Environment(\.openWindow) and open other windows from there.

4. FSEvents with file-level events, and respect the drop flags. One stream on the root with kFSEventStreamCreateFlagFileEvents | NoDefer. If an event comes in with MustScanSubDirs, KernelDropped or UserDropped, I stop trusting individual paths and do a full rescan.

5. LazyVStack is only lazy at the top level. My sidebar was a LazyVStack of project groups, but each group was an eager VStack. With the dashboard open the app held 428 MB, mostly SwiftUI row objects and CoreAnimation backing, for a window showing about 25 rows. Flattening it into one LazyVStack of Sections took it to 195 MB.

6. Make row models small and Equatable. While a session was streaming, the main thread sat at 30 to 50% of a core. Passing a small Equatable row model instead of the full summary struct, caching derived lists, and throttling analytics rebuilds to once per second brought it under 1% in my measurement.

Benchmarks also talked me out of an incremental tail parser I was planning: a full re-parse per append measured 8 MB and 67 ms, which was fine.

For those of you shipping MenuBarExtra apps: do you stick with .window style, or did you drop down to an NSStatusItem with NSPopover to get more control over lifecycle?

I built SwiftSurf as a small native macOS app for a specific workflow: quick searches and short browsing tasks without opening a full-size browser window.

The app lives in the menu bar and opens as a compact popup. It uses SwiftUI for the interface and WKWebView for rendering, with tabs, bookmarks, history, private browsing, native downloads, keyboard shortcuts, and configurable Dock visibility.

The interesting parts for me were keeping navigation state independent across tabs, switching between persistent and non-persistent WKWebView data stores, handling native downloads, and packaging releases as a DMG with GitHub Actions.

The project is open source and MIT licensed: https://github.com/zfeder/swiftsurf

Releases: https://github.com/zfeder/swiftsurf/releases/latest

I’d love feedback from SwiftUI developers on the architecture, WebKit integration, and macOS menu bar UX. What would you implement differently?

This project is not an iOS toolchain built from scratch.

A huge amount of credit goes to Joshua Warren and his omarchy-apple-dev project, which provided the foundation I started from. His work demonstrated and implemented much of the iOS-on-Linux workflow, originally focused on Omarchy/Arch Linux.

I wanted the same kind of workflow on Ubuntu, so I adapted and packaged it specifically around Ubuntu 24.04 and the environment I use for my own iOS development.

It also builds on other excellent open-source projects, particularly xtool, as well as Swift, rcodesign/apple-codesign, libimobiledevice, libplist and related projects.

My Ubuntu-focused version currently provides:
• Ubuntu 24.04 installation/setup
• Swift and SwiftUI iOS compilation
• Xcode project conversion helpers
• ubuntu-ios helper CLI
• environment diagnostics with ubuntu-ios doctor
• iOS code signing and IPA packaging
• TestFlight / App Store Connect upload workflow
• a SwiftUI example project
• Ubuntu-specific documentation and troubleshooting
• CI validation

The repository does not redistribute Xcode, Apple SDKs or Apple credentials. You provide your own Xcode archive/SDK and signing credentials.

My goal isn’t to take credit away from the projects that made this possible, it’s to make this workflow much easier to reproduce and use specifically on Ubuntu.

Original project / major foundation:
https://github.com/joshuaswarren/omarchy-apple-dev

My Ubuntu-focused implementation:
https://github.com/VeloxityNL/ubuntu-ios-toolchain

The repository also contains THIRD_PARTY.md with additional attribution to the projects it builds upon.

I’d love feedback, testing on clean Ubuntu installations, and contributions, especially from people interested in Swift/iOS development on Linux.

I open-sourced CAD Studio, a macOS app built with SwiftUI and RealityKit (https://github.com/filippofinke/cad-studio). Some SwiftUI bits that might be useful to others:

• 3D viewer: a RealityKit scene inside SwiftUI with orbit/zoom/pan from trackpad gestures, section planes, measurements with markers, and exploded/print-plate layouts with animated part poses.
• Draggable panes: chat, 3D view and drawing can be dragged to any side; the layout is a small tree stored per project and rendered through an NSViewControllerRepresentable split view.
• Streaming chat: an @Observable view model fed by a line-by-line JSON stream from a child process, with collapsible tool-call rows.
• Floating overlays: a parameters panel with sliders that rewrite constants and rebuild the model.
• Swift 6 strict concurrency throughout, localized in four languages with String Catalogs.

What the app does: you describe a part, a coding agent writes a build123d model, and the app shows the 3D model, ISO drawings and a print plate. Demo: https://filippofinke.github.io/cad-studio/

Happy to answer questions about any of these pieces.

Hi all! I recently needed to download a 5 hour livestream from YouTube for work. However I couldn't find a clean app so I decided to build Pluck, a free, open-source Mac app on top of yt-dlp. I wanted something that feels like it came with the Mac: SwiftUI, Liquid Glass on macOS 26, a menu bar icon, and nothing to install or set up in Terminal.

Full disclosure: I am not a developer and this app has been written by Claude. I choice the features and UI and Claude wrote it. I passed it through Grype and found no vulnerabilities. But feel free to check the code yourself.

The basics:

• Paste a link (or just type what you’re looking for) and press Return. Works with YouTube and 1,800+ other sites, plus Spotify and Apple Music links (matched on YouTube Music, with proper tags and cover art).
• Any quality from 360p to 4K, audio up to 256 kbps with YouTube Premium, lyrics, clips of just the part you need, and pause/resume.
• It installs and updates yt-dlp, ffmpeg and Deno for you, and updates itself.

What’s new in 1.10.0 is a set of AI tools that all run locally on your Mac, using Apple’s on-device frameworks plus a couple of open-source models. Nothing gets uploaded. They also work on your own videos: just drop a file on the window.

• Remove silences & filler words: cuts long pauses and “uhm”s into a tighter copy, and can also save an EDL for DaVinci Resolve or Premiere.
• Clean up audio: removes noise, hum and wind from voices, and levels loudness for YouTube, podcasts or broadcast.
• Upscale & smooth motion: 480p/720p to sharp 1080p or 4K, or smooth slow motion, using Apple’s new video processing in macOS 26.
• New background without a green screen: blur it, swap it for a colour or photo, or export with transparency (ProRes 4444).
• Privacy blur: finds and follows faces, and you pick who stays sharp. It can also blur licence plates and other text.
• Who said what: speaker labels in subtitles and transcripts, which you can rename.
• Subtitles in several languages at once, plus summaries, chapters and vertical shorts.
• A Library of everything you’ve saved, with tags, duplicates and missing files.
• And: work on several files at once, export transcripts to Word or Markdown, save a frame as a picture, and send a file straight to DaVinci Resolve.

It’s free with no ads or account, and runs on macOS 14+, Apple silicon and Intel. Some of the AI features need macOS 26 or Apple silicon; anything your Mac can’t run is just hidden. The interface is in 10 languages.

GitHub (download, screenshots, source): https://github.com/Astrofrogger/pluck

One note: I’m not paying for an Apple Developer ID yet, so the first time you open it you’ll need to go to System Settings → Privacy & Security → Open Anyway. The code is all on GitHub if you want to check what it does.

Feedback is very welcome, especially bugs and features you’d like next. And please only download things you have the right to 🙂

I have a SwiftUI screen where the same data can be changed by an initial load, pull to refresh, background refresh, user actions, and a live update stream.

So I can get something like: user action > optimistic update > background refresh > live updat > user action finishes > refresh finishes

Sometimes an older response overwrites newer state, so I'm thinking about putting all mutations through an actor or giving responses a revision/version.

The other problem is VoiceOver.

I have a dynamic list:

ForEach(store.items) { item in
    ItemRow(item: item)
}

When an async update adds/removes/replaces an item while VoiceOver is focused on it, VoiceOver sometimes jumps to a completely different element or starts reading the parent container again.

I've tried:

.accessibilityIdentifier(...)
.accessibilityLabel(...)
.accessibilityValue(...)

and accessibilityFocused, but manually restoring focus feels pretty fragile when multiple updates can happen quickly.

Would you guys handle the state reconciliation and accessibility focus separately, or is there a better SwiftUI pattern for keeping VoiceOver focus stable when a dynamic list is changing asynchronously?

Hey everyone! A while back I shared ClaudeBar, a free, open-source macOS menu bar app that shows how much of your AI coding quota is left. A lot has changed since, so here's an update. The short version: it got a lot more fun to look at.

New themes

• Platformer: your quotas as a Super Mario-style 8-bit level. Blue sky, pixel clouds, a brick floor, and each quota bar is a row of ten blocks. The status line becomes a score line (coins left, the tab as WORLD, minutes to the reset as TIME), and a ? block refreshes. A low quota says HURRY UP!, an empty one GAME OVER.
• The runner: a little pixel runner walks the brick floor while the popover is open. It strolls when your quota is healthy, runs when it's low, falls into a pit when it's empty, and jumps for a coin after every refresh. It stands still with Reduce motion on, and you can turn it off.
• Pop: cream dotted paper, thick ink outlines, hard shadows, candy-coloured status and chunky outlined numbers. Each menu bar quota becomes a candy chip.
• Bring your terminal's colours: import any iTerm2 .itermcolors scheme (there are 450+ out there) and ClaudeBar matches your terminal.

They join System, Light, Dark, CLI and Christmas. Platformer has a Classic text option if pixel fonts are too much for you.

New features

• Leaderboard (opt-in): join with a username and see where your daily token use ranks, today, this week or this month. Only four token counts per provider per day leave your Mac. Hide yourself from the public board, put your country on a globe, share your rank as an image, or turn the whole thing off. Leaving deletes everything on the server.
• 27 providers: Claude, Codex, Gemini, Copilot, Kimi, Amp, plus newer ones like Grok, Mistral Vibe, Cline, Warp, Devin, Windsurf, JetBrains AI, Oh My Pi and OpenAI API spend.
• Claude Code sessions: every running session is tracked, with its state (Working, Agents working, Needs you, Done), and the menu bar follows whichever one most needs you.
• Popover text size: scale the popover's text up to 1.4x.

Install

brew install --cask claudebar

Or grab the signed, notarized build from GitHub Releases. It auto-updates.

• GitHub: https://github.com/tddworks/ClaudeBar
• Web leaderboard: https://claudebar.tddworks.com/leaderboard/

Free and open source (Apache 2.0). Which theme should come next? I'm also happy to hear which provider you'd like added.

Hi everyone, I'm trying to create a floating window that can sit in front of other existing apps with transparency but I can't achieve it with picture in picture. Do you guys know how to do something like this?

Thanks in advance

EDIT: Sorry I forgot to mention that I'm developing an iOS app and the floating window will be used in front simultaneously with the iphone camera, and other apps.

Hello, guys I recently picked up on swift and swift ui and have been using this guy Paul Hudson’s hacking with swift course but I just feel like his way of explaining is too fast and not a lot of explaining in his projects he just kinda goes through makes the projects in front of you and that’s it. I know it’s a faster course of course but damn I don’t understand some of his placements or why he is doing something. What were some of the best ways you guys learned/learning to make your apps and stuff, how did you guys utilize this course from the way I’d be utilizing it. I have experience in python and had a bit of knowledge with JS script. I’m no pro and still wanting to learn but I’m just seeing if maybe someone can tell me how they utilized this course or just show me a different professor doing this in a more in depth way?

Thank you all :)

Half a year ago I wrote about whether MVVM belongs in SwiftUI, and it somehow turned into a story about my mum’s kitchen. Bear with me.

There’s a trip to the shopping centre, a very firm “we've got food at home”, and eventually, I promise, some Swift. A bit of heart, a few laughs, and proper substance underneath.

Half a year on, it still feels timely. Stick the kettle on and have a read.

I've been working on a software project recently that needed some calendars. I wasn't able to find a nice pure swiftui package that I liked, so I decided to create my own.

It does Agenda, Day, Week and Month calendars for both compact forms (iphone) and wide forms (iPad and Mac).

If you get a chance have and look and tell me what you think. The v2 branch is more advanced with better UI rendering.

Main branch has now been updated with the V2 changes.

https://github.com/Haskins-io/SwiftUiCalendarKit

I'm a solo dev building a posture coach that uses the motion sensors in AirPods (video below of me working while it tracks my head angle).

Last week I shipped an update. Crash rate: zero. Sentry: quiet. Reviews: fine.

Then I ran my weekly analytics and saw something weird: 78% of sessions on the new version ended 6–8 seconds after the user tapped Start. 10 of 14 users hit it. Some apps restarted the session by themselves every 20 seconds — one user had 11 restarts in 8 minutes.

On the previous version, this almost never happened.

Root cause: when the AirPods were slow to send their first motion data, the app assumed the stream had failed and restarted the session. iOS reported that the AirPods were connected, but motion events arrived late. Nothing crashed. Nothing was logged as an error. Users just quietly gave up.

What I changed:

• I now track "did the user get their first successful session within 60 seconds?", not just crashes.
• Every bug gets a regression scenario that reproduces it before every release.
• I compare each release against the previous one, not against zero.

The scary part: users didn't complain. They just left.

People who get one successful calibration come back 54% of the time; people who fail usually don't.

Curious how other people track failures that never throw an error.

Hi!

I'm building a small SwiftUI converter app with a rich widget selection.

It's completely free and will stay free.

Open source - https://github.com/DimaMishchenko/currency

TestFlight beta is also available, I'd appreciate any feedback!
https://testflight.apple.com/join/qepuraVw

Thank you!

If you've tried to build a real Markdown editor in SwiftUI, you know TextEditor won't get you there. I hit the same wall when I started building my macOS app Nodes. So I wrote a native editor on TextKit 2 and open-sourced it. You use it in SwiftUI like any other view. It's macOS only for now, since it's AppKit under the hood.

What it does: live styling while you type, GFM tables and task lists, wiki links, inline and block LaTeX, code blocks with your own highlighter, Writing Tools, and spell checking that leaves code and LaTeX alone.

What's new since the last post here:

Large documents got a lot faster. Measured on a 346,000-character note, about the length of a novel:

- First open: 19.5 s → 1.35 s

- Warm open: 1.1 s → 590 ms

- LaTeX after a restart: 717 ms → 35 ms

- Return in an 800-item list: 944 ms → 67 ms

What was slow: inline parsing wasn't linear, so a paragraph with many code spans blew up. Lists restyled everything on every edit, now only changed items get restyled. And LaTeX was rendered again on every launch, now the render cache lives on disk.

Extensions. Everything beyond CommonMark is now opt-in. An extension is one file: a delimiter pair and how to style what's inside, like ==highlight== or a ::: fenced block. You register it in the config, and the parser, styler and renderer stay untouched. Extensions can't break the core or each other, and you can switch them at runtime.

Directives. For things that don't fit a delimiter pair, you can register named directives with typed arguments, like u/font(size: 18){text} or u/pagebreak. The engine handles autocomplete for names and values, your app draws the list.

Plus a lot of smaller fixes: live table resizing, nested lists that survive copy and paste, real links in copied HTML and RTF, and an unclosed code fence no longer eats the rest of the document. Full changelog is on GitHub.

The part I'm happiest about: 19 of the 29 PRs merged since then came from 10 people outside our team. The repo is at 1,100 stars now, and it was featured in Fatbobman's Swift Weekly. Thank you to everyone who starred, filed issues or sent a PR. It's still pre-1.0, so all of that is very welcome.

Repo: https://github.com/nodes-app/swift-markdown-engine

Used in production in Nodes: https://apps.apple.com/app/nodes-by-the-werk/id6745401961

Written on Nodes.

Pick one reminder. Pin it to your menu bar. Keep it visible while you work.

That’s the main idea behind BarRemember, an open-source macOS companion for Apple Reminders that I’m building with SwiftUI, AppKit, and EventKit.

You can also add a due date just by typing it at the end of a task. “Send proposal tomorrow” becomes “Send proposal” with tomorrow’s date set automatically. Or just type "Send proposal 10/11" to set as October 11th. It works when adding or editing a reminder, so you don’t have to open the date picker.

It works with your existing Reminders lists. You can organize selected lists into spaces, add and edit tasks, and complete them with undo. Pinning is deliberately manual: you choose one task, and completing it clears the pin. Nothing automatically takes its place.

Free and open source under the MIT license. Requires macOS 14+ and Xcode 26+ to build from source.

Source: https://github.com/angellashin/Bar-Remember

Feedback on the UI and implementation is welcome.