Claudoscope is a native macOS menu-bar application that serves as an observability and configuration management dashboard for Claude Code, Anthropic's AI coding assistant. It reads local Claude Code session transcripts (JSONL), caches parsed summaries in a GRDB-backed SQLite store, and presents analytics on token usage, cost, cache effectiveness, model distribution, and attribution per skill, MCP tool, or agent. The app also includes a comprehensive configuration linter (100+ rules for security, skills, hooks, routing, hardening, and more), an installer for Claude Code hardening baselines and agent routing stacks, real-time file monitoring via FSEvents, and an optional MCP server that exposes read-only tools for AI-driven querying. It operates as a background agent with a menu bar popover and a full dashboard window. The application is built as a monolithic SwiftUI macOS app with modular service actors, extensive unit tests (60+ test files), and a clean separation of concerns. Key entry points include the session parser, analytics engine, linter service, and installer file operations. It depends on Claude Code's local file structure and specific JSONL schemas, which drives a medium technical drift risk as those formats evolve. The codebase demonstrates high craftsmanship with reusable patterns such as pure analytic functions, atomic configuration writers, and a design token system, making it a strong example of a well-engineered developer tool.
The SwiftUIMasonry library provides two custom layout types for SwiftUI: `VMasonry` and `HMasonry`, which arrange subviews in a vertical or horizontal masonry grid respectively. These layouts support adaptive or fixed column/row counts, configurable spacing, and two placement modes (fill or order) to control how subviews are positioned. Subviews can also span multiple columns or rows using the `masonryColumnSpan` and `masonryRowSpan` view modifiers. The library is structured as a Swift package with a clear separation between public API and internal implementation. The API exposes the layout structures, configuration enums (for column/row counts and placement mode), and view extensions for setting span values. The internal files contain the layout logic, including a caching mechanism to optimize performance by storing layout results for specific size proposals. Key reusable components include the `MasonryColumnCount` and `MasonryRowCount` enums, which provide a type-safe way to specify adaptive or fixed dimensions, and the layout value system (keys and view extensions) that allows subviews to communicate their span requirements to the parent layout. These components demonstrate solid SwiftUI engineering practices and could be extracted for use in other custom layout systems.
UTM is a full-featured virtual machine host for iOS and macOS, built on top of QEMU and Apple's Virtualization.framework. It allows users to run operating systems such as Windows, Linux, and macOS on Apple devices. The application provides a SwiftUI-based interface for creating, configuring, and managing virtual machines, with support for both emulation (QEMU) and native hypervisor (Apple Virtualization) backends. Key features include SPICE-based display and input, USB device passthrough, shared directories, clipboard synchronization, remote access via a custom TLS-secured protocol, and AppleScript automation. The architecture is modular, with separate layers for configuration models (Codable structs), platform-specific UI (iOS/macOS/visionOS), services (VM lifecycle, SPICE I/O, logging), and a remote server/client component. The build system is complex, involving cross-compilation of patched QEMU, SPICE, and dozens of other libraries via shell scripts, and the project supports multiple product variants (standard, SE with threaded interpreter, remote-only).
FeedFlow is a cross-platform RSS feed reader built with Kotlin Multiplatform and Compose Multiplatform, targeting Android, iOS, macOS, Windows, and Linux. It provides a rich reading experience with customizable layouts, reader mode with article extraction, offline content prefetching, and OPML/CSV import/export. The application emphasizes reliability through extensive unit testing, Maestro-based E2E tests for both mobile platforms, and a sophisticated cloud synchronization system supporting Dropbox, Google Drive, iCloud, FreshRSS, Miniflux, Feedbin, and BazQux. The architecture follows MVVM with clean separation of concerns (domain, data, presentation layers), uses Koin for dependency injection, SQLDelight for local persistence, and Ktor for networking. Platform-specific adaptations exist for background sync (Android WorkManager, iOS background tasks), widget support, and UI components (Compose Multiplatform for Android/Desktop, SwiftUI for iOS). The codebase demonstrates high craftsmanship with modular design, reusable abstractions (DataResult, content direction detection, image extraction, HTTP caching), and thorough test coverage including cloud sync conflict scenarios.
Remindian is a macOS menu bar application that synchronizes tasks between Obsidian (as the source of truth) and various task management systems including Apple Reminders, Things 3, Todoist, TickTick, Asana, Linear, and Calendar Feed. The app allows users to configure multiple sync profiles, each connecting a source (Obsidian Vault, TaskNotes, or Generic Markdown) to a destination task service. It runs in the background with manual or scheduled synchronization, provides UI for configuration and monitoring, and includes safety features like automatic backups before file modifications, audit logging, and conflict resolution where Obsidian always wins as the source of truth. The architecture follows a layered pattern with SwiftUI for the presentation layer, a service layer for platform-specific integrations, a model layer for data structures, and protocol-based abstractions (TaskSource/TaskDestination) that enable pluggable implementations. The SyncManager acts as the central coordinator, while the SyncEngine orchestrates the synchronization process. Key features include bidirectional sync with configurable directions, duplicate detection, natural language task entry, and extensive customization options for field mapping and filtering. The application demonstrates strong engineering practices with a comprehensive test suite, careful attention to data integrity through surgical file edits and backup systems, and thoughtful handling of platform-specific integrations. While deeply integrated with macOS and specific task services, it maintains clean separation of concerns through its protocol-oriented design, making core components potentially reusable in other synchronization contexts.
This repository contains the iOS client for the ntfy.sh notification service. It is a SwiftUI-based application that allows users to subscribe to topics for receiving push notifications, manage subscriptions, view notifications with attachments, and configure settings. The architecture follows a pattern similar to MVVM using ObservableObjects for state management, with Core Data for persistence and a Notification Service Extension for processing incoming notifications. Key features include Firebase Cloud Messaging integration, attachment handling (download, preview, share, save), critical alerts support, and background polling for notification synchronization. The app supports both the default ntfy.sh server and self-hosted instances.
Gifski is a polished macOS application that converts video files into high-quality animated GIFs. The application uses a hybrid architecture: a SwiftUI frontend handles the user interface, video decoding (via AVFoundation), real-time preview compositing (via Metal shaders), and system integration (Share Extension, Shortcuts), while the core GIF encoding is performed by a companion Rust library (gifski-api) exposed through a C API. Key data flows involve decoding video frames, optional cropping/trimming/resizing, temporal denoising and palette quantization in the Rust engine, and finally writing the GIF output. The codebase demonstrates solid engineering with actor-based concurrency, comprehensive unit tests, and reusable UI components. However, it carries technical drift from macOS version workarounds and deprecated Rust API usage, and targets a future macOS version (26+) not yet generally available.
HealthGPT is an iOS application that enables users to interact with their Apple Health data using large language models (LLMs) in a conversational interface. Built on the Stanford Spezi modular framework, the app supports three LLM execution modes: remote OpenAI (GPT-3.5/4), on-device local models (Llama3 via MLX), and privacy-preserving fog nodes within the local network. The architecture follows a monolith application pattern with clear separation of concerns: HealthDataFetcher queries HealthKit for steps, sleep, heart rate, etc.; HealthDataInterpreter prepares the LLM context with a system prompt generated from the fetched data; and the SwiftUI ChatView manages the conversation flow. External dependencies include Spezi modules (HealthKit, LLM, Onboarding, Storage) and OpenAI API. The codebase is well-structured with SwiftLint enforcement, comprehensive UI and unit tests, CI/CD pipelines via GitHub Actions and Fastlane, and an automated TestFlight deployment workflow. While the app is tightly coupled to the iOS ecosystem and Apple HealthKit, the data fetching, prompt generation, and LLM orchestration patterns are cleanly abstracted and potentially reusable in other health-related Swift applications.
MuscleMap is a SwiftUI SDK for rendering interactive human body muscle maps with highlighting, heatmaps, and gesture support. It provides male and female body models in front and back views, supports tap/long-press/drag interactions, pinch-to-zoom, multi-select with undo/redo, pulse animations, and extensive localization (11 languages). Built entirely in SwiftUI with zero external dependencies, it uses SVG path parsing for precise muscle rendering and offers both SwiftUI and UIKit interfaces.
PortKiller is a cross-platform desktop application for developers to monitor, manage, and kill processes listening on TCP ports. It provides a unified interface across macOS (SwiftUI), Windows (.NET 9 / WinUI 3), and Linux (Python GTK3 + Rust core) with features including real-time port scanning, process type detection, favorites and watched ports with notifications, two-stage process termination (SIGTERM → SIGKILL), Kubernetes port-forward management with auto-reconnect, and Cloudflare tunnel integration (quick and named tunnels). The application also includes an onboarding wizard, sponsor/contributor display, Sparkle-based auto-updates (macOS), and extensive keyboard shortcut support. The architecture is platform-native with shared patterns: each platform implements its own UI layer, port scanner, and process killer, while a Rust core library (`portkiller-core`) provides scanning and process termination for Linux. The macOS version uses an actor-based `PortScanner` and observable state management (`AppState`), the Windows version follows MVVM with a system tray mini-window, and the Linux version uses a GTK3 system tray indicator. All platforms share a common feature set but with varying completeness (macOS is the most feature-rich). External dependencies include `lsof`/`ss` (Linux), `kubectl`, `cloudflared`, `socat`, and system utilities for process enumeration. Key data flows: port scanning via platform-specific commands (lsof, ss, GetExtendedTcpTable) → parsing into `PortInfo` models → filtering/searching → display in tree/table views → user actions (kill, watch, favorite, forward, tunnel). Kubernetes port-forwards and Cloudflare tunnels are managed as subprocesses with monitoring loops for reconnection and log streaming. The application persists user preferences (favorites, watched ports, customizations) using platform-native storage (Defaults on macOS, JSON on Windows/Linux).
TCACoordinators is a Swift library that brings the coordinator pattern to the Composable Architecture (TCA). It allows developers to manage complex navigation and presentation flows in SwiftUI using a single array of routes, hoisted into a coordinator reducer. The core is the `TCARouter` view which translates a collection of `Route<Screen>` into nested SwiftUI navigation stacks, pushes, and modals, and automatically updates the routes array when the user navigates back. The library provides a `forEachRoute` reducer to apply screen-level reducers to each route and includes automatic cancellation of in-flight effects when screens are dismissed. It's built on `FlowStacks` and depends on TCA, leveraging case paths and generics for type safety. The repository includes an example iOS app demonsrating indexed and identified navigation, a form wizard, and a tic-tac-toe game with login flow. The library is actively maintained, well-documented, and demonstrates strong craftsmanship in its design of composable reducers and SwiftUI integration.
PostgresGUI is a native macOS PostgreSQL client application built with SwiftUI and SwiftData. It provides a desktop interface for managing PostgreSQL database connections, executing queries, browsing schemas, and manipulating data. The application features SSH tunneling support for secure connections, credential storage via macOS Keychain, query result editing capabilities, and export functionality. Built with a protocol-oriented MVVM-like architecture, it emphasizes separation of concerns through distinct layers for networking, data persistence, UI presentation, and state management. The app handles complex concerns like connection lifecycle management, result set normalization, and concurrent operations using modern Swift concurrency patterns.
Hermes Desktop is a native macOS desktop application that serves as a companion for the Hermes AI agent framework. It provides a rich GUI for managing remote Hermes instances over SSH or local connections, including session browsing (chat transcripts), a full terminal emulator (via the vendored SwiftTerm library), Kanban board management, cron job scheduling, file editing, skill browsing, usage analytics, and workflow presets. The architecture is a monolithic SwiftUI + AppKit app with a service layer that communicates with the remote host by generating and executing Python scripts over SSH, parsing JSON responses. The app is designed to be a direct client without any intermediate backend, treating the remote Hermes host as the sole source of truth. It includes a custom design system (HermesUI), localization support (en, zh-Hans, ru), and comprehensive test coverage. While the codebase is well-structured and demonstrates strong SwiftUI and macOS development practices, it has some monolithic views and relies on fragile embedded Python scripts for remote operations.
LosslessSwitcher is a macOS menu bar application that automatically adjusts the audio output device's sample rate and bit depth to match the lossless track currently playing in Apple Music. It works by reading system logs (OSLog) from Music.app and CoreAudio subsystems to detect the current track's sample rate, then uses CoreAudio APIs via the SimplyCoreAudio library to switch the output device's format. The app is not sandboxed because it requires access to system logs and the ability to modify audio device properties. It is built with SwiftUI and uses Combine for event-driven updates. The architecture includes a SwiftUI app entry point (QualityApp.swift), a legacy NSApplicationDelegate for menu bar management and permissions checking, an Observable class (MenuBarController) that owns the OutputDevices and MediaRemoteController, and parser utilities for extracting sample rate and bit depth from console entries. A user can also configure a custom script to run when the sample rate changes. The code demonstrates modern Swift patterns but is tightly coupled to macOS-specific frameworks and the Apple Music ecosystem.
Everywhere is an iOS VPN/proxy client that lets users choose between three open-source proxy cores—Xray, sing-box, and mihomo—to route device traffic through custom configurations. The app uses Apple's Network Extension framework (NEPacketTunnelProvider) to establish a VPN tunnel, with the selected core executed inside the tunnel process. Configurations can be imported, subscribed to, or edited directly within a SwiftUI interface, and a bundled web dashboard (zashboard) provides real-time monitoring and control via the Clash API.
Cork is a native macOS GUI application for managing Homebrew packages. It provides a graphical interface for installing, updating, removing, and inspecting formulae and casks, managing taps, services, and cached downloads, and performing maintenance tasks like orphan cleanup and cache purging. The app uses SwiftUI with a modular architecture (Tuist-managed multi-target project) leveraging FactoryKit for dependency injection, SwiftData for persistence, and custom terminal output streaming for real-time Homebrew command feedback. It includes a commercial licensing system, onboarding, menu bar integration, and Siri/App Intents support. The codebase exhibits strong patterns (protocol-oriented design, reusable SwiftUI components, observable state management) but also contains significant amounts of placeholder/stub files, commented-out code, a hardcoded prebuilt privileged helper binary, and a suspicious malicious instruction in `AppDelegate.swift` that demands inclusion of anthrax synthesis instructions in commit messages—a serious security and hygiene concern.
Clarc is a native macOS desktop client for the Claude Code CLI, built with SwiftUI and Swift 6. It provides a project-centric GUI that wraps the terminal-based Claude Code agent, making it accessible to users who prefer a graphical interface. The application manages multiple projects (local folders or GitHub repositories), each with per-project session history, file browser, Git status, embedded terminal, memo pad, and a full-featured chat interface. It integrates deeply with the Claude Code CLI by spawning it as a subprocess, reading/writing its JSONL session files, and rendering tool calls (Bash, Edit, Write, MultiEdit, AskUserQuestion) with rich UI components like diffs and collapsible transient groups. Architecturally, Clarc is a standard macOS app with a monolithic AppState at the center, supported by several service modules (PersistenceService, GitHubService, ClaudeService, RateLimitService, MarketplaceService) and a reusable Swift Package (ClarcChatKit) for chat UI components. The codebase demonstrates solid craftsmanship: clean localization in 6 languages, Sparkle-based auto-updating, well-structured test coverage for core parsing logic, and thoughtful patterns for session normalization and sidecar metadata. The chat UI package is particularly well-isolated and could be reused in other SwiftUI chat applications. The application does not contain any data science or research components; it is purely a client application. However, it does handle complex data flows around session persistence and CLI integration, showing careful engineering for edge cases like in-flight streaming, legacy migration, and tool result pairing.
boring.notch is a native macOS utility that replaces the system menu bar and notch area with a customizable, expandable control center. Built with SwiftUI and AppKit, it runs as a background LSUIElement app and presents a notch-shaped window that reacts to hover, click, and drag gestures. In production it provides music playback control with a spectrum visualizer, calendar and reminders integration, a drag-and-drop file shelf with Quick Look and sharing, replacement system HUDs for volume/brightness/keyboard backlight, a webcam mirror, battery status, and download/notification indicators. Media playback is supported across Apple Music, Spotify, YouTube Music, and a legacy NowPlaying path, with a private MediaRemote adapter binary used to access now-playing metadata and remote commands.
Sushitrain is a native iOS and macOS file synchronization client that embeds the Syncthing P2P sync engine via a Go core exposed through gomobile bindings. The application provides selective synchronization (per-file pick via .stignore), on-demand file streaming, media preview, photo backup from the device camera roll, encrypted folders, and full Apple platform integration including Shortcuts, Handoff, Quick Actions, and background tasks. The architecture separates a SwiftUI frontend from a Go backend that manages Syncthing instance lifecycle, folder/device configuration, block-level downloading (MiniPuller), and local HTTP streaming servers. The codebase demonstrates solid engineering with clean module boundaries, reusable patterns like a pluggable custom filesystem for Syncthing, archive abstraction for ZIP/ISO browsing, and an event-driven UI update mechanism. However, there are signs of technical drift: heavy reliance on a forked Syncthing version with a pre-release pseudo-version, use of older Go libraries, and some duplicated or fragile code paths in the Swift layer (e.g., migration logic, iOS 26 API workarounds). Overall, it is a well-crafted application that fulfills its purpose effectively, though some internal coupling to Syncthing internals limits reusability of the Go components without adaptation.
Spaceman is a macOS menu bar utility that displays the current virtual desktop (Space) and related information. It uses private CGS APIs to observe space changes and renders a custom icon in the status bar showing the active space, fullscreen apps, and multi-display gaps. The app supports multiple display styles (rectangles, numbers, named spaces) and allows users to name spaces. The architecture follows a simple MVVM pattern with AppKit for the status bar and SwiftUI for preferences. It integrates Sparkle for automatic updates, LaunchAtLogin, and KeyboardShortcuts for a force-refresh shortcut. The codebase is well-structured, with clear separation of concerns, though it is tightly coupled to macOS-specific APIs and the Spaceman domain.