I'm the developer of WebKitUI MCP at LorisLabs. I wanted to review what an agent was about to do in a browser without approving it through another chat message.

It gives an MCP client a persistent WKWebView on your Mac. For actions that need approval, a native dialog shows the requested navigation, click or fill operation. Afterward, the client can check the resulting page state against an explicit postcondition.

The 0.6.6 preview is available as a notarized download for Apple-silicon Macs running macOS 15+. This release fixes confirmation keyboard handling: initial focus, accidental Escape/Return during the first second, and Tab + Space.

Some Apple sign-in flows still require manual completion in Safari; the MCP cannot take control of Safari afterward. Page-state verification also doesn't prove a server-side change was saved.

Source-available under BUSL, with evaluation and commercial terms in the repository.

Download and source: https://github.com/lowrisk75/webkitui-mcp/releases/tag/v0.6.6 Details: https://lorislab.fr/developers/webkitui-mcp/

I'd appreciate feedback on the approval flow and on websites where the result is hard to verify.

Hey everybody 😄

I just published my first open-source package:

https://github.com/AppitStudio/Talk.swift

This package allows macOS app developers to create an "API Contract" for their app, publish it on the SDK repo, and other app creators can use this API to create fast integrations between their app and the provider app without the need to change the codebase of the "provider" app.

During this year, I got a few requests from developers to integrate my app with theirs, and it was super hard to implement,

I don't have access to their codebase, and they don't have mine,

I find Apple solutions outdated and difficult to implement.

Also, integration between my own apps was such a pain.

Hard to create a general solution, and every app needed some adaptation and custom code to work with each other.

This solution makes that simple.

Just use the SDK skill, tell your coding agent what functionalities you want to make public, and that's it,

It will install everything needed, configure the SDK and the settings screens (which you can always change later), and publish your API to the SDK repo.

And on the other side, you get the same workflow.

Install the skill, tell your agent "Create integration with dockflow using Talk SDK" and describe how you want to integrate it, and that's it.

DockFlow developers don't need to change a single line to support this new integration.

I hope more macOS developers can enjoy this package for both internal integrations between their apps and with third-party ones.

Let me know what you think, and I can't wait to see more apps join 😃

Hey everyone! I’m building Piko, a native macOS app for transferring files between your Mac, Android phones, and cameras that support MTP.

You can drag and drop files and folders, browse photos with thumbnail previews, and manage multiple connected devices in one window. Everything runs locally, with no internet connection needed.

GitHub + download: https://github.com/morishuz/piko

It requires Apple Silicon and macOS 14 or newer. It’s still early and not signed/notarized yet, so after trying to open it, you may need to go to System Settings → Privacy & Security → Open Anyway.

I’d love feedback, especially on device compatibility. If you try it, let me know which phone or camera you’re using and what worked—or didn’t!

Also please note: Piko is new and hasn’t been thoroughly tested across devices yet, so please back up important files and try it with disposable copies first. Moving or deleting files—including moving them to the Bin—can cause data loss or break apps that depend on them. Avoid system or app-managed folders.

I wanted a simple way to control my Mac from my phone without relying on a cloud service, so I built Taptiva.

It lets you use your phone as a remote trackpad with:

• Trackpad gestures
• Keyboard input
• Scrolling
• App switching
• Media controls
• Direct connection to your Mac over the local network

No account required and no cloud connection is needed for the control session.

I made it free for Mac.

I’d really like feedback from people who use a Mac regularly: what would you want a remote control like this to do?

https://taptiva.tech

When I first started app development, I made a skeuomorphic stopwatch app that had titlebars and commenters said I should remove them. I spent time experimenting and learning how to get rid of them, and learned a few other things along the way. Here is everything I learned about macOS title bars for using Swift, SwiftUI, and NSView.

Hey!

I've been using TorrServer on my Mac for a while, and although it works great, I never really liked having to manage everything through Terminal + the Web UI.

So I ended up building a native macOS app around it.

It's called TorrServe Silicon and it's written in SwiftUI specifically for Apple Silicon Macs.

At first it was basically just a nice Start/Stop button for TorrServer.

Then I got slightly carried away 😅

Now it can:

• start, stop, update and configure TorrServer
• add magnet links and .torrent files directly
• keep everything in a proper media library
• automatically fetch posters, descriptions, ratings, genres, etc.
• search torrents through Jackett
• open streams in QuickTime, IINA, VLC or Infuse
• control and monitor the server from the macOS menu bar
• work without having to open the TorrServer Web UI for normal usage

I'm trying to keep the whole thing feeling like an actual Mac app rather than a web interface wrapped in a window.

It's free and open source.

GitHub:
https://github.com/HolyMayhem/TorrServe-Silicon

The project is still pretty young, so I'd genuinely appreciate feedback — especially from people who already use TorrServer on macOS.

If something feels awkward, unnecessary, or you think I'm missing an obvious feature, tell me. I'm still actively working on it.

As a single-display user, and since macOS Spaces are a mess to use for multiple reasons. I have been looking for a horizontal window manager like Niri for macOS but none quite worked for me.

So I decided to build Defi.

It arranges windows in scrolling columns with virtual per-display workspaces, keyboard navigation, overview and main focus has been to make it fast, smooth, and reliable.

It's all native, free, and open source.

https://github.com/qeude/Defi

This is the first public version. I've mostly been building it around my own workflow, so I'd love to hear how it works for yours and what feels missing.

PS: "Defi" means "challenge" in French. I named it like this after multiple attempt with working with macOS accessibility stuff and it made that name appropriate 😅

We have gotten to a state where setting last baseline in NSStackView will cause high CPU. It's 0% on firstBaseline. Apple doesn't care... FB24359677.

class ViewController: NSViewController {
    
     @IBOutlet weak var useLastBaseline: NSButton!
    
     @IBAction

 func showSavePanel(_ sender: Any) {
        let panel = NSSavePanel()
        
        let button = NSButton(title: "Hello World!", target: nil, action: nil)
        let stackview = NSStackView(views: [button])
        stackview.orientation = .horizontal
        if useLastBaseline.state == .on {
            stackview.alignment = .lastBaseline
        } else {
            stackview.alignment = .top
        }

        let accessoryView = NSView(frame: NSMakeRect(0, 0, 300, 100))
        accessoryView.addSubview(stackview)
        
        panel.accessoryView = accessoryView
        panel.runModal()
    }
}

Subject

I built a native macOS app for monitoring real LM Studio/Bionic tokens/sec

Text

I wanted to see LM Studio/Bionic inference performance without keeping Terminal open, so I built LM Speed Monitor, a small native SwiftUI app for macOS.

It reads the actual tokensPerSecond value reported by:

lms log stream --source model --filter output --stats

It does not estimate performance from CPU or GPU utilization.

Features include:

• Latest and rolling-average tokens/sec
• Prompt, generated, and total token counts
• Time to first token
• Model detection
• Recent-generation graph
• Menu-bar display
• Optional always-on-top floating window
• Copyable Markdown reports for comparing models
• Automatic reconnection when LM Studio restarts
• No telemetry, cloud services, Electron, or third-party dependencies

It’s open source under the MIT license:

https://github.com/Xombie2000/lm-speed-monitor

The current release is source-only and requires macOS 15+, Apple Silicon, and the LM Studio lms CLI. I haven’t published a Developer ID-signed/notarized binary yet.

Feedback, bug reports, and contributions are welcome—especially results from different Apple Silicon models and LM Studio versions.

Hi r/macosprogramming,

I spend most of my day moving commands, links, code, and structured text between Terminal, Xcode, and browsers. Clipboard history helps you recover something you copied, but it does not remove the repetitive work that comes next.

I built Clipboard Router, a free and open-source macOS app written in Swift for Apple silicon Macs running macOS 14 or later.

- Paste Stack lets you copy several items, switch apps once, and paste them in sequence.

- Actions and Auto Organize rules let you transform copied content and prepare automation for review.

- Clipboard Health keeps likely secrets out of ordinary history.

- Private Sessions keep new clips only in memory, while Vault stores sensitive clips encrypted.

- Base64 export and recipient-key encryption help you move or share protected clips intentionally.

- The bundled cr CLI brings Clipboard Router into shell workflows.

Everything is local by default and there is no telemetry.

Source: https://github.com/ibrolord/clipboard-router

Download: https://ibrolord.github.io/clipboard-router-releases/

Homebrew: brew install --cask ibrolord/tap/clipboard-router

Disclosure: I built Clipboard Router.

I would especially value feedback on where clipboard automation should require review and where it should just run.

I’ve been working on an open-source macOS tool called Monad Design. The idea is simple: when a coding agent is changing native UI, the running app should be the canvas.

The macOS workspace connects an existing Xcode or Expo iOS project to Simulator. You navigate to the real screen, select a view or annotate an area, and send that visual context to the local coding agent you already use. The agent still edits the actual repository; Monad Design handles the handoff, rebuild, and review loop.

The trickier part hasn’t been drawing over Simulator. It’s keeping the selected screen state, the source change, the rebuilt target, and the review result connected. For subjective work, I also wanted the original to remain visible beside a few source-backed variants until one is chosen.

The current preview runs locally on macOS. It isn’t an App Store product or a separate app generator, and there’s no waitlist.

Source and setup notes:

https://github.com/Monadix-AI/monad-design

Short demo:

https://watchclueso.com/embed/pio8jqfcg4ivj0r1

I’m building Monad Design and would be interested in feedback from people who have worked on Xcode, Simulator, or other macOS developer-tool integrations.

Two of us just graduated and we kept firing off half-typed terminal commands with voice dictation, so we built our own.

Hold a key, talk, let go, and the text lands at your cursor. Everything runs on your Mac. No account, nothing sent anywhere.

The main thing it does that others don't: it checks which app you're in before typing a line break, so saying "new paragraph" won't submit an unfinished command in a terminal or send a half-written message.

Free and open source, MIT licensed. Apple Silicon, macOS 14+.

https://github.com/Nabzx/openstream

Happy to hear what breaks.

P.S. if you find it useful, a star on the repo helps more people find it. no worries if not, feedback is worth more anyway.

Hey everyone,

I wanted to share Focenda, a native macOS productivity app I have been building in Swift and SwiftUI.

The goal was to create a clean, all-in-one workspace for daily focus sessions, task management, and quick note-taking.

Here is what is included:

- Tasks & Kanban: A 3-column drag-and-drop board and list view with priority flags and focus counters.

- Scratchpad: Multi-notebook quick notes organized by folders.

- Calendar & Reminders: A monthly focus heatmap and recurring task alerts with native system notifications.

- Menu Bar Companion: Start timers, jot down quick thoughts, or add tasks directly from the menu bar without switching windows.

- Focus Timer & Floating HUD: Pomodoro and deep-work cycles with a picture-in-picture mini panel that stays visible across all your macOS Spaces.

- Local & Private: Runs completely offline, requires no account, and stores all data locally on your Mac.

It is 100% free and open source, you can check out the project here:

- GitHub Repository: https://github.com/OOMestre/Focenda

- Install via Homebrew: brew install --cask oomestre/focenda/focenda

I would love to hear your thoughts, feedback, or any feature suggestions if you give it a try.

If you've built anything on Apple's on-device FoundationModels model, you've probably hit the same wall: there's no clean way to add "fall back to Claude for the hard cases" or "run a fully local open-weight model instead, no network at inference time" without writing your own provider abstraction and wiring routing/residency by hand.

This is where 1.0.0-beta.1 of the LocalLM Lab SDK comes to the rescue: a model layer with four providers behind one API: Apple's on-device model, Claude (your own API key), a locally-run open-weight model via MLX, and Apple's Private Cloud Compute (ships in this release but not yet working TBH). You name routes (.heavy, .light, anything) and point them at models; the SDK owns which model is actually resident in memory and handles the download/preflight/capability-probe lifecycle for local MLX models. Imagine your app being able to dynamically choose which AI model to use depending on the task at hand...

```swift
lab.models.route(.heavy, to: ModelID("mlx:mlx-community/Qwen3-8B-4bit")!)
lab.models.route(.light, to: .system)
let session = try lab.makeSession(route: .heavy, tools: myTools, instructions: sys)
```

Also in this release: LocalLM Lab's own API Lab (the local HTTP server other tools/scripts can call against) is rebuilt as a native Swift server, replacing the separate Go process it used to relay through. This is one less moving part if you were scripting against it.

If you are curious about how to build AI-powered apps, the SDK also ships several working examples, including code-buddy: a real CLI coding agent. Point it at a repo and a task, it downloads an MLX model on first run (.heavy/.light routes, e.g. Qwen3-8B for the hard route, Qwen2.5-3B for quick ones), then drives filesystem tools, a read-only git tool, a test runner and a hosted MCP docs server (DeepWiki) merged into the same session.

Requires macOS 27 beta on Apple Silicon, Apple Intelligence enabled.

Feature page: thisbrain.ai/locallm/1.0.0-beta

SDK guide: https://github.com/ancientcomputing/locallm/blob/main/docs/sdk-guide.md

Hi there.
I want to use self-distribution with Sparkle updates and later put my app into the App Store.
Wondering how I can manage this without having two separate builds.

Could I just always include Sparkle and have the app auto-discover if it is app-store managed and then just disable its function?

Any experience with this?
Thx.

Fazendo alguns testes e observações no macOS Monterey, percebi que essa versão não possui, nas configurações, uma forma simples de visualizar, ativar ou desativar aplicativos que executam processos em segundo plano.

Como muita gente ainda utiliza o Monterey e até versões anteriores do macOS, decidi criar uma solução inicialmente para uso próprio. Depois, resolvi publicar o projeto no GitHub, tornando-o open source e disponibilizando também um instalador para quem quiser utilizar.

A ideia é facilitar esse gerenciamento principalmente para quem não quer, ou não tem familiaridade, com comandos no Terminal e configurações mais escondidas do macOS.

O app é relativamente leve, não mantém processos consumindo recursos em segundo plano. Você abre, faz o que precisa e fecha.

Se surgirem novas necessidades ou sugestões da comunidade, podem abrir uma Issue no GitHub ou me chamar na DM. Pretendo continuar melhorando e atualizando o projeto conforme aparecerem novos casos de uso.

Espero que seja útil para quem ainda utiliza essas versões do macOS.

Link do Repositório: https://github.com/ministrodev/macprocess/releases

SteelSeries GG stopped working for me on macOS 26+, and running a multi-hundred-megabyte suite just to control four lights already felt a little absurd—so I rolled up my sleeves and made Reflective.

It’s a free, open-source macOS menu-bar app that talks directly to SteelSeries Arena 7 speakers over USB. It’s about 1 MB and includes:

• Screen Sync using screen edges or quarters
• Automatic black-bar trimming
• Independent left/right colors
• Wallpaper palette extraction
• Brightness, power, and launch-at-login controls
• No account, cloud service, or SteelSeries GG

Reflective is a fork of Prismatic for macOS. Its creator did the hard foundational work of reverse-engineering the Arena 7 USB protocol, and deserves full credit for making this possible.

I leaned on a plethora of AI agents of multiple religions, faiths, races, and backgrounds as patient pair programmers while working through unfamiliar parts—but I reviewed, tested, and occasionally argued with everything on the actual hardware. And yes, AI helped me write this post too, because I’m that socially inept.

It’s signed, notarized, MIT-licensed, and available through Homebrew:

brew install jezzlucena/tap/reflective

GitHub: https://github.com/jezzlucena/Reflective

Feedback, bug reports, and gentle roasting are all welcome.

Hi everyone!

So since i had a lot projects running recently and find it inconvenient to track them directly on gitlab, especially when you have a team. So I've made this repo - basically a neat app that appears under macbook notch when new pipeline appears.

If you find this useful give it a try and will be happy to get some feedback on improvement)

https://github.com/Uudg/pipeline-island

I’ve become a huge fan of my Mac mini M4 for scientific computing, its ease of use, and low power consumption, really it’s a great device to leave running 24/7. As far as software goes I only have encountered one major issue, and it seems to me that it made more prevalent with the M6.

I quickly realized when trying to leverage all 10 cpu cores that for the base model M4, there are 4 performance cores and 6 efficiency cores, simply distributing workload equally to all cores does not work. Across a synchronization barrier, performance cores finish first and await slower e cores. You will be bottlenecked by the speed of the efficiency cores. I always experience performance degradation when moving from 4 to 5 cores.

This would be fine, I suppose if you were able to explicitly target and use the cores, you could then decrease the workload on the efficiency core correspondingly and it would finish near the same time. As far as I am aware you are not and cannot explicit place work on a core selecting performance or efficiency.

I’m not that upset because I realize the remaining 6 efficiency cores don’t really represent all that much compute power, but I was looking into the new Mac mini M6 and… they have a new type of core! The super core adds another type, making it the super core, performance, and efficiency cores. This appears to me as very problematic. Given I can’t leverage p+ e cores effectively, why would I be able to leverage s+p+e, the problem seems to have gotten worse. I can’t target cores by classification, so I can’t lower the compute load for certain cores. Just avoiding the efficiency cores with the M4 isn’t that big of a loss, but with the M6, you would limit yourself dramatically to either the super cores or the performance cores and not both.

Some more specifics/provided tools or possible solutions (forgive my Mac tech knowledge):

Mac does provide some methods, Quality of Service, however this just influences where something is “likely” to run, I believe, and not guaranteed.

GrandCentralDispatch: maybe the solution, I think it can distribute tasks by size to the proper core, and work stealing to compensate for slower ones, but has narrow application and many problems aren’t well suited I think, many problems aren’t easily partitioned into smaller independent tasks.

THREAD_AFFINITY_POLICY does something I think more suggestions and not a guarantee.

An application or framework like OpenMP can try to compensate for the inability to target cores by class, actively managing and redistributing. Hard and haven’t been able to get this to behave. My work currently is with C++/ OpenMP/AMReX. All mostly the most current versions via homebrew.

It seems to me that there is fundamentally a missing api to bind a thread to a physical cpu by core class, or request a certain number of workers by core class. Additionally a tool to determine what core class a thread actually is also seems lacking.

What do people do here? Are some people really just spending lots of money on these machines and not fully leveraging them? Has anyone achieved reasonable scaling for a macmini with asymmetric cores with problems involving synchronization?

Thanks in advance!

I built QuotaWarmer, a small macOS menu bar app for people using Claude Code and Codex CLI.

Repo: https://github.com/bcanozgur/quota-warmer

The app shows rolling quota windows in the menu bar, with countdowns and recent check history. It defaults to monitor-only mode, so it watches quota without sending anything.

There is also an optional Auto-warm mode. When enabled for a tool, it sends one minimal command through your already logged-in CLI when a fresh quota window opens, then checks quota again to confirm the window actually started.

A few details:

- macOS 14+

- MIT licensed

- Homebrew cask: `brew install --cask bcanozgur/tap/quotawarmer`

- Manual DMG and source build options are in the repo

I would appreciate feedback from macOS app users on whether the menu bar UX and safety model are clear.

This update is for folks building AI-apps on the Mac.

The LocalLM Lab SDK now ships ready-made "Tool" wrappers for every connector (Calendar, Reminders, Contacts, Location etc) and new this release, Filesystem via WorkspaceTools. Previously, you would have to write your own adapters (which remains fully supported alongside the new tools).

I ended up going the Tool wrapper route because Apple's local AI (at the macOS 26 level) wasn't reliable at mapping (to give an example) a human-readable Calendar event ("Lunch on August 25") to the event ID that the connector used to require to perform any action on that event.

Some of you will wonder: isn't that Apple's Tool protocol reimplemented? Well, it's Apple's Tool protocol used the way it's meant to be, with the annoying parts done for you. That means handling connector-level nits like the identifier problem above so you don't have to rediscover them yourselves, plus one piece Apple doesn't provide at all. This is MCPTool, which builds a Tool at runtime straight from an MCP server's JSON Schema. FoundationModels has zero MCP support of its own. Short version: we're not replicating Apple's Tools, we're using them, and taking care of the parts that were genuinely annoying to get right. At least not without spending an unholy amount of time fiddling with Calendar and Reminders...

Worth noting: filesystem access itself (the picker, security-scoped bookmarks) is still deliberately host-app territory, not part of the SDK. Everything downstream of that (once your app has a resolved folder URL) is where WorkspaceAccess/WorkspaceTools come in. This includes an async-aware access pattern (withFolderAccessAsync) that is needed since a model session can invoke several file tools across one respond(to:) call. The new example (workspace-buddy) shows it in context. Maybe it's your route to building a coding agent using the Mac's local AI ...!

Repo: https://github.com/ancientcomputing/locallm

I kept opening Activity Monitor, seeing some process eating my CPU, and having no idea what it was or why it was running. Couldn't find a tool that answered the "why," so I built one.

It's called CauseGraph — a local flight recorder for your Mac. It records what your machine does (processes starting/stopping, file changes, CPU/memory) and turns it into a causal graph. You click any process and see the whole chain: what launched it, what it launched, what likely set it off. If it turns out to be junk, you kill it right there.

The fun parts:

- It's live — the graph redraws every few seconds, and you can drag a timeline back to see what your machine was doing 10 minutes ago

- It flags the weird stuff on its own: CPU spikes, memory leaks, things that keep crashing and restarting

- 100% local — no cloud, no account, one-line install

Stack, for the curious: a small Go daemon writes events to SQLite, a Python engine builds the graph and serves a plain-JS + cytoscape UI on localhost.

Honest bit: I've only really tested it on my own Mac (Apple Silicon) so far. It's built to be cross-platform, so Linux/Windows should work — just haven't battle-tested them.

Install (needs Python 3.10+):

curl -fsSL https://raw.githubusercontent.com/NitinKumar004/causegraph/main/install.sh | sh

Repo: https://github.com/NitinKumar004/causegraph

Would love feedback — especially whether the causal links feel genuinely useful or just noisy. That's the part I'm least sure about.

I built keyclean for a very specific MacBook problem: cleaning the keyboard without triggering shortcuts or accidental typing, while keeping the trackpad available.

Under the hood it uses a session-level `CGEventTap`. Keyboard, modifier, and visible media-key events are swallowed, but pointer events are deliberately excluded. Pressing `⌃⌥⌘U` stops the run loop, and terminating the process also removes the event tap.

It is intentionally small: one Swift source file, no third-party dependencies, network access, analytics, stored input, or background service.

Install:

`brew install lan-shengchieh/tap/keyclean`

Source and technical explanation:

https://github.com/lan-shengchieh/keyclean

I am particularly looking for compatibility results across different macOS versions, Apple Silicon/Intel Macs, and terminal applications.

AI disclosure: Codex assisted with development and launch preparation. The source, CI checks, and Homebrew Formula are all public.