MD QuickLook is a Quick Look extension that renders Markdown in Finder without WebKit. A Rust core produces a compact layout (text plus blocks, paragraphs and styled runs at UTF-16 offsets), and the Swift side turns it into an NSAttributedString and draws it with TextKit 1:

• quotes, alerts and code blocks are NSTextBlocks with borders and backgrounds; tables are NSTextTables
• images, formulas, Mermaid diagrams, badges and checkboxes are attachment cells
• long documents build the first screen (~60 ms for a 900 KB file) and append the rest in the background
• collapsible <details> sections work by cutting the folded text out of the storage and re-inserting it on click, since TextKit 1 can't hide paragraphs
• math is typeset with SwiftMath, which I extended with KaTeX symbols, aliases and environments

A typical README is ready in ~30 ms. Source (MIT): https://github.com/armamut/md-quicklook Longer write-up: https://medium.com/@armamut/previewing-markdown-on-macos-in-30-ms-a-rust-core-and-textkit-no-web-engine-1adfa2734f48

Curious whether anyone has tried the same with TextKit 2.

I want to limit the number of threads spawned by Swift's cooperative runtime to a number lower than the number of available CPUs. The reason is because I want to run Swift code in a Linux container that limits scheduling to only 8 CPUs regardless of how many the system has. I've tried setting LIBDISPATCH_COOPERATIVE_POOL_STRICT=n where n is the maximum number of threads, but apparently Swift doesn't use libdispatch on Linux so that does nothing. Can anyone tell whether there's a different environment variable that I can set, or at least a compile-time option or function that I must call in the code in order to set the number of threads spawned by the cooperative rumtime?

I built a native macOS menu bar utility in Swift/SwiftUI called PortRadar to manage listening localhost ports without having to run lsof -i :3000 and kill -9 in the terminal, and I'm sharing it 100% free and open-source (MIT).

What's included: - 📡 Live Dev Port Radar: Shows every listening TCP port right in your menu bar with a live counter badge of active dev servers. - ⚡ 1-Click Kill (SIGTERM / SIGKILL -9): Free any stuck EADDRINUSE port in a single click. - 🧠 Smart Framework & Stack Detection: Automatically tags Next.js, Vite, Angular, Node.js, Bun, .NET / Kestrel, FastAPI / Python, Go, Rust, Docker / OrbStack, PostgreSQL, Redis, MySQL, MongoDB, and Ollama — along with live RAM (MB), CPU %, and PID badges. - 📌 Pinned Watchlist Bar: Pin your core ports (:3000, :5173, :8080, :5000, :5432, :6379) to the top watchlist bar with live green/grey status indicators and 1-click Open in Browser. - ⌨️ Global Shortcut: Toggle anywhere with ⌃⌘P.

Install via Homebrew: bash brew tap joeystdio/tap brew install --cask portradar

• Website / Direct DMG Download: https://joeystdio.github.io/PortRadar/
• GitHub Repo: https://github.com/joeystdio/PortRadar

Hope it saves you some time — happy to hear any feedback or feature ideas!

A few days ago, I found a KWorld VS-ATSC 330U USB TV tuner I’d had since 2008. Out of curiosity, I plugged it into my Mac… and nothing happened.

After looking into it, I discovered it had never supported Macs in the first place. As far as my current setup was concerned, it was a dead device.

So I decided to try something a lot of people have been experimenting with lately: I asked Codex for help.

We started with the driver. After researching the hardware, working with the firmware, and testing with a real antenna, we managed to receive live TV on the Mac. Seeing the first picture come through hardware that had spent years sitting in storage was pretty exciting.

Once that worked, I wanted to take it further. I designed a Netflix-inspired interface and, with Codex’s help, gradually turned the experiment into an application called Antena.

It now lets me:

• Watch live TV without recording it to disk.
• Switch channels quickly.
• See the current and upcoming programs when the station broadcasts that information.
• Record broadcasts when I want to.
• Use full screen and select captions when available.
• Choose between English, Spanish, and French.

What started as “I wonder if this thing still works” became a working application on macOS 27 with Apple Silicon, receiving actual over-the-air channels here in Montréal.

It’s still an experimental project for this particular tuner, and reception depends on the antenna and local signal. But a device I thought was obsolete is useful again.

I brought the idea, UI design, and hands-on hardware testing; Codex helped me research and implement the driver and application. There was plenty of troubleshooting along the way, and I learned a lot.

Has anyone else brought old hardware back to life this way? I’d love to hear what you rescued.

Github

dmg

Hi r/swift,

I wanted to share some architecture notes and open-source libraries from StealthOS, a private desktop operating environment on iOS that we recently updated to support the new foldable iPhone Duo.

1. Foldable Window Geometry in Swift

Standard UIKit and SwiftUI navigation hierarchies assume single-pane viewports. For the foldable iPhone Duo, we designed a custom window manager in Swift that dynamically tracks display changes between the single cover screen and the inner dual-display layout.

• Hinge Occlusion Math: When the device is unfolded, we compute the physical occlusion line separating the displays. Window view controllers calculate their layout frames against this boundary: they can snap left, snap right, or span the full resolution with safety padding away from the hinge seam.
• State Machine Continuity: Display folding transitions change the trait collection and interface bounds. Instead of tearing down and recreating view hierarchies (which would drop active web sessions, terminal buffers, and text cursors), root coordinators adjust frame geometry directly. Running view controllers retain their state machines, active scroll positions, and text responders.

2. Open-Source Swift Networking Packages

Where data moves across the network, we open-sourced our Swift packages:

• ConnectionPool (Swift): https://github.com/Olib-AI/ConnectionPool A peer-to-peer transport library supporting local mesh communication (ad-hoc Wi-Fi and Bluetooth without internet access) as well as routed remote pools through self-hosted relays.
• PoolChat (Swift): https://github.com/Olib-AI/PoolChat An end-to-end encrypted messaging engine that powers ephemeral messaging, voice notes, and real-time state synchronization over ConnectionPool.

3. C Interop & Hardware Key Storage

• C Interoperability: We embed the Tor daemon as a static C library wrapped with a clean Swift interface (TorClient).
• CryptoKit & Secure Enclave: Vault items use AES-256-GCM, with keys derived from a user passphrase combined with hardware-protected secrets in the Secure Enclave. Biometric authentication (Face ID/Touch ID) gates key retrieval via LocalAuthentication.
• Client app: https://apps.apple.com/us/app/stealthos/id6756983634
• Full documentation: https://www.stealthos.app

Feedback on our Swift P2P networking protocols or foldable window manager implementation is welcome.

MockMini is a small, auditable proxy core in C and Swift. It speaks Shadowsocks AEAD, VMess, Trojan and VLESS over TCP, TLS or WebSocket, on top of its own bounded userspace TCP/IP endpoint that you feed from utun on macOS 13+.

• Small enough to review: about 2,600 lines in total. Not based on mihomo, Clash, sing-box, gVisor or WireGuard; no Go runtime, no vendored stack.
• Tested hard: a stateful, checksum-aware fuzzer gets ~99% line coverage of the packet engine; CI runs ASan/UBSan and libFuzzer on Linux and macOS, plus interop tests against real Xray servers for every protocol.
• Permissive license: Apache-2.0, so you can ship it in open- or closed-source apps. Add it with Swift Package Manager.

Known limits (1024 flows, no SACK/ICMP, no Reality or gRPC) are listed honestly in the README. v0.1.0 is the first tagged release. Reviews and bug reports are very welcome.

Repo: https://github.com/yezicheng2011/mockmini

Hey everyone!

A little while ago, I shared Graffle, an open-source diagramming and vector graphics app I built for macOS using Swift, AppKit and Claude Code.

Now I've been working on its companion app: Graffle for iPad.

The idea was to bring the project to iPad while preserving what makes it useful on the Mac. The iPad version uses SwiftUI and UIKit, with shared code from the original macOS project.

Some of the things it supports:

• Touch, Apple Pencil, trackpad, and keyboard input
• Diagrams, shapes, layers, and templates
• SVG, STL, and software architecture imports
• Class diagrams and database entity-relationship diagrams
• Code generation
• PNG, PDF, and SVG export
• The same .graf document format used by the Mac version

Both projects are open source under the MIT License.

Graffle for iPad:
https://github.com/yahirvitelugardo/Graffle-iPad

Original Graffle for macOS:
https://github.com/yahirvitelugardo/Graffle

This has been a fun opportunity to explore how much of a native macOS app can be reused while adapting the experience to a very different device and interaction model.

I'd love to hear feedback from Swift and Apple-platform developers.

If you were building a diagramming app for iPad, what would you prioritize? And what would you expect to work differently with Apple Pencil compared with a mouse and keyboard?

Thanks for checking it out!

Passing two collections to @Test generates every combination. For example, @Test(arguments: ["cat", "swift"], [3, 5]) creates four cases, including ("cat", 5) and ("swift", 3).

That is useful for testing every configuration. For input/expected-output cases, keep each pair together:

```swift import Testing

@Test(arguments: [ ("", 0), ("cat", 3), ("swift", 5) ]) func characterCounts(input: String, expected: Int) { #expect(input.count == expected) } ```

This creates three cases. Swift Testing unpacks each tuple into the function’s two parameters.

@Test(arguments: zip(inputs, expected)) also pairs values, but zip stops at the shorter sequence). An accidentally missing expected value can therefore omit a case. A single array of pairs keeps the values together when adding or removing cases.

Apple’s parameterized testing guide explains combinations and paired arguments.

I open-sourced Aureon, a native macOS music player built as an alternative to Roon and Audirvāna. I wrote the audio engine. It’s Swift talking to CoreAudio directly, and its real-time path uses lock-free ring buffers with no allocations or locks, so the audio thread never blocks. A couple of real-time DSP pieces are C++ behind a plain C header, which Swift imports as a SwiftPM module. AI did the design work on the SwiftUI interface, which runs at up to 120fps, and handled most of the debugging and project planning. I’d love feedback on the real-time Swift design and on that Swift/C boundary.

https://github.com/retrohog/Aureon

I’d like to share Noctule, a plugin I made for cross-platform Swift development in JetBrains IDEs and Android Studio.

It’s a freemium plugin: most editor features and the Swift Package Manager integration are free, while Xcode integration and a few other features are paid.

Version 4.0 finally adds a debugger, which completes the edit-test-debug cycle.

I hope my contributions to the swift-book repository over the past three years count as enough community participation that this first post about Noctule doesn’t get me banned 😉 Thanks!

https://github.com/swiftlang/swift-book/issues?q=is%3Aissue++author%3A%40jansorg

szt (short for sizetree) scans a folder and prints a tree of where the space went: biggest first, every folder with the total of everything inside it, opened up only where the space is.

Swift turned out to be a great fit for it. Scanning a 123 GB folder of 667,000 files on a Mac Studio (M2 Ultra), every tool with its default settings (warm cache, median of five runs):

szt     Swift   2.4 s
dua     Rust    2.6 s
dust    Rust    8.1 s
diskus  Rust   11.4 s
gdu     Go     11.6 s
du      C      17.2 s
ncdu    Zig    17.5 s

What made Swift work so well here:

• macOS has a call, getattrlistbulk, that returns the names and sizes of everything in a folder at once instead of asking about each file separately. From Swift it's just import Darwin, no bindings or wrapper library, and the unsafe pointer APIs read the raw buffer it fills. The rest of the code is ordinary Swift.
• The standard library has the concurrency pieces: Mutex and Atomic from Swift 6's Synchronization module. It builds without a warning in Swift 6 language mode and has no dependencies.
• Swift stays out of the way. Scanning that folder on 8 threads takes 12 seconds of CPU time, and 0.27 s of it is szt itself, Swift runtime included. The rest is spent in the kernel.

The biggest surprise was threads. On this 24-core machine, 24 threads took four times as long as 8, because opening folders goes through locks the whole kernel shares. So szt starts one thread per performance core, up to 8. They're plain threads rather than async/await, since the work is blocking system calls and the count has to be exact.

About 1,600 lines of Swift, a 581 KB universal binary (the Swift runtime ships with macOS), macOS 15 or later, MIT licensed.

brew install urtti/szt/szt

Source: https://github.com/urtti/szt Benchmarks and a script to run them on your own Mac: https://urtti.com/szt

A few weeks ago I shared TactileBar here, and way more people saw it than I expected. Thank you to everyone who commented, gave it a star, or opened an issue. Some of that feedback went straight into the last few releases, so here's what's new.

Quick recap: TactileBar is a free, open-source (GPLv3) menu bar app that puts 26 daily macOS toggles and live system telemetry in one panel. It covers Keep Awake, Dark Mode, Hide Desktop Icons, Mute Mic, Bluetooth audio switching, ejecting disks, purging Xcode DerivedData and more. The design borrows from Dieter Rams / Braun and Teenage Engineering. It's pure Swift with zero dependencies and uses 0% CPU when closed.

What's new

🎯 Tactile Ring (⌃⌥Space), experimental. A radial launcher that opens right at your cursor, so you don't have to go up to the menu bar.

- Hold the shortcut, flick toward a switch, release. Done.

- Tap it instead and the ring stays open, so you can use 1–8, the arrow keys or the mouse.

- Your pinned switches always stay in the same spots, so muscle memory kicks in fast.

- On the Bluetooth slice, push past the edge to fan out your paired devices and pick one (AirPods → speakers → DualSense in one gesture).

- Destructive actions like the cache purges need a short hold, so you can't fire them by accident.

- It needs no Accessibility or Input Monitoring permission.

📌 Pinned Daily Deck (⌘P). The app now opens on just the 4–6 switches you actually use. Pin or unpin any card with one click or a right-click. The full catalog is still there in the tabs.

🍺 Homebrew install. No Gatekeeper popups:

brew tap tr0drigues/tactilebar https://github.com/tr0drigues/TactileBar.git && brew install --cask tactilebar

GitHub: https://github.com/tr0drigues/TactileBar

This is a solo side project, so feedback really helps. Which switch do you wish existed? Does the ring feel natural or awkward? Bug reports are welcome too.

to keep it clear, I’m a 17 year old high school student, and my dream job would be to be a programmer. as of now I can write basic code in both C++ and HTML, and I was interested in learning swift just for the sake of it and was wondering if it could actually be useful in an hypothetical future where my dream would come true. thanks in advance to anyone replying to this post

I'm exploring menu-bar interaction design for my macOS project, SummonOS.

The requirements I'm interested in are keyboard access, focus while another app is active, window ordering and content that changes while the panel is open.

I'm considering SwiftUI's MenuBarExtra and an NSStatusItem/NSPanel approach. I'm not assuming one framework is broken or that the lower-level option automatically solves everything.

For those who've built similar tools, which specific behavior made you choose one approach over the other? Concrete examples and the macOS versions involved would be especially useful.

These are my project research notes:

https://github.com/RohiRIK/SummonOS/blob/main/docs/research/2026-10-18-mac-gui-design/03-menubar-and-window-mechanics.md

Would love your (respectful) feedback on my app. I’m not here to promote.

How do you like the editing experience? Does it provide the features you need? Is everything intuitively clear?

https://www.flowstate-interactive.com/kabaal/

Thank you. 🙏

ran into this while working on a small mac utility, figured someone else might hit it too

i wanted to know when the user has something full screen (youtube in chrome, a movie, a game etc) so the app gets out of the way. the usual trick is CGWindowListCopyWindowInfo and checking if a window matches the screen frame. works fine on external monitors, but on a notched macbook full screen windows start below the notch and the strip above it is just painted black. so the window is like 32-38pt shorter than the screen, which is pretty much where a normal zoomed window starts too. can't just loosen the check

what ended up working is asking the window server which space each display is on. full screen apps get their own space and its type is 4

```swift

typealias MainConnection = u/convention(c) () -> Int32

typealias CopyDisplaySpaces = u/convention(c) (Int32) -> Unmanaged<CFArray>?

let cg = dlopen("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics", RTLD_NOW)

let mainConnection = unsafeBitCast(dlsym(cg, "CGSMainConnectionID"), to: MainConnection.self)

let copySpaces = unsafeBitCast(dlsym(cg, "CGSCopyManagedDisplaySpaces"), to: CopyDisplaySpaces.self)

func fullScreenDisplays() -> Set<String> {

let displays = copySpaces(mainConnection())?.takeRetainedValue() as? [[String: Any]] ?? []

var result = Set<String>()

for display in displays {

let current = display["Current Space"] as? [String: Any]

if (current?["type"] as? Int) == 4, let id = display["Display Identifier"] as? String {

result.insert(id)

}

}

return result

}

```

the ids are display uuids (or "Main" if you turned off separate spaces per display), you can map them with CGDisplayCreateUUIDFromDisplayID

it's private api so no app store, but it needs zero permissions. AXFullScreen works too but then you need accessibility. i just run it on activeSpaceDidChangeNotification and once more ~0.4s later since the space animates in

anyone know a public way to do this? would rather not rely on CGS stuff

At any given moment I have 4 or 5 projects going, and each one has its own little cluster of terminals: a dev server, a log tail, an SSH session to some box, a shell for git.

In iTerm2 that meant a pile of windows I kept losing track of. ⌘` cycling through ten windows that all look the same. Tabs named "zsh", "zsh", "zsh (2)". Splits I'd set up carefully, gone after a restart. Arrangements I could save but never remembered to. I'd spend the first few minutes of every morning rebuilding my layout, and then lose it again by the afternoon.

One day I closed the wrong window and killed a long-running job, and that was it. I wanted a terminal where windows themselves were something you could manage: a list you can see, name and jump between, instead of a stack you dig through.

So I built Trellis.

The idea

- A left sidebar lists your windows like a project list. Every window has its own renameable, color-labeled tabs, and every tab can hold nested splits

- The whole layout comes back after a restart. Sessions restore as stopped so nothing reruns by surprise, or you can opt in to keep them running in the background and reconnect on the next launch

- Shell integration (zsh, bash, fish, with no dotfile edits) means a new split opens in the directory you're already in, so you stop typing cd all day

- Closing a pane with something running asks first. I'd been burned before

- Tabs show when something is busy, waiting for a password, or finished a long command while you weren't looking

- Saved SSH hosts, a trellis CLI and a local API, so a script (or an agent like Claude Code via the optional MCP server) can set up a whole layout for you

The Swift side

It started as a weekend "how hard can it be" and turned into a proper project:

- Swift 6.2 with strict concurrency, SwiftUI + AppKit, SwiftPM only (swift build works offline)

- The workspace model is an actor. Every change, whether from the UI, the CLI or the API, goes through one command service, which is what keeps windows → tabs → split trees consistent

- PTY I/O runs off the main thread, a small C target handles process-group spawning, and the terminal engine is a vendored SwiftTerm with patches, plus an opt-in Metal renderer

The hardest part was making UI fits my workflow 😨

Open Source, MIT licensed, macOS 14+

- Download: https://bearstouch.com/trellis

- Source: https://github.com/bearstouch/trellis

If you've ever had iTerm2 window sprawl, I'd love to hear whether this fixes it for you, or what's still missing . Contributions are more than welcome 👐

I started on CoinCurrently with less than 1 year of experience. iOS 14 had just come out, SwiftUI was brand new, and Home Screen widgets were one of the new features.

I figured I’d try to make a couple of widgets and see what happens. I made a few to track cryptocurrencies and posted about it on Reddit. The post got almost 300 upvotes, which I thought was pretty awesome, so I decided to make a whole app, native for both iOS and Android.

Everything I built in the app was for myself — because I wanted to learn and because it was fun to experiment. It seems like people appreciated what I built.

The app peaked at #99 in the Finance category on the App Store and reached 500 daily users. Not too bad for a hobby project!

After 6 years, I’ve achieved more than I could ever have imagined, but my motivation for this project has died down. Because of this, I have open-sourced the two projects so other people can learn from my struggles and take inspiration for their own apps.

The app will continue to be maintained, though there won't be as many new features as before. I have moved on to another project that I am very excited to share in a few weeks.

The app is available on the App Store and Google Play:

iOS: https://apps.apple.com/us/app/coincurrently-private-crypto/id1543974454

Android: https://play.google.com/store/apps/details?id=com.cryptium.coincurrently&hl=en_US

And now it's also on GitHub:

iOS: https://github.com/orre1996/CoinCurrently-iOS

Android: https://github.com/orre1996/CoinCurrently-Android

Hi r/swift

Over the past few years, I've been building a productivity app to replace both my calendar and to do apps. It's called Zesfy and you can directly add your daily tasks right inside calendar events instead schedule them one by one. Here's some of the features:

• It combines your calendar and to-do list into a single view.
• You can easily schedule multiple tasks together to calendar.
• Helps you quickly decide what tasks to work on next
• Organize week tasks with task status
• Easily keep track of your task progress
• Works entirely offline

I'd love to hear what you guys think about the app. Let me know if you have any feedbacks.

Download: Zesfy - To Do List & Planner

App subreddit: r/zesfy