thehardwarestore.ai

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.

CrawlBar is a native macOS menu bar application and CLI tool that serves as a control plane for local-first crawler CLIs (e.g., GitHub, Slack, Discord, Telegram, Notion, WhatsApp). It discovers crawler manifests (built-in or from ~/.crawlbar/apps/), runs commands to retrieve status, freshness, and database inventory, and supports actions such as sync, publish, doctor, search, and backup. The architecture is strictly layered: a core library (CrawlBarCore) with no UI imports provides all data models, command execution, secret redaction, status normalization, and config storage, while a SwiftUI/AppKit frontend renders a menu bar status item and a settings window. A CLI (crawlbarctl) exposes the same functionality outside the GUI. CrawlBar does not crawl data itself; it orchestrates external CLI crawlers via a standardized manifest and status protocol (crawlkit.control.v1). It enforces privacy by redacting secrets from command output, storing action logs with private permissions, and keeping secrets in the macOS Keychain. The system supports remote execution via SSH and integrates with Cloudflare D1 for remote SQLite archives. 12 built-in crawler manifests are provided, covering major messaging and productivity platforms. The project also includes an extensive self-test suite, CI/CD with notarization, and a quality rubric document for code reviews. The core domain is well-abstracted, with reusable patterns for command running, status mapping, config caching, and action coordination. However, the codebase is macOS-only, relies on hardcoded fallback paths and a manual TOML parser, and has many per-crawler special cases in command argument construction. The maintenance is active (frequent releases, changelog, CI), but technical drift is medium due to ecosystem lock-in and custom infrastructure.

InjectionIII is a macOS menu bar application that enables hot reloading of Swift, Objective-C, and C++ code in iOS simulators and devices. It works by watching for source file changes, recompiling them using Xcode build logs, and dynamically loading the resulting dylib into the running app using techniques like interposing, vtable patching, and Objective-C swizzling. The app consists of a daemon with a file watcher and injection server, while the client-side code (bundled as injection bundles or via the HotReloading Swift package) handles compilation and injection. It supports standalone injection without the app running, injection on real devices, and integration with SwiftUI. The codebase is mature and actively maintained, though it contains legacy C/ObjC components and is tightly coupled to Xcode build log parsing.

Sleek is a cross-platform desktop application (Electron + React + TypeScript) that serves as a feature-rich todo.txt manager. It reads and writes todo.txt files, providing advanced filtering, sorting, grouping, and archiving capabilities. The application features a custom filter grammar (PEG.js) for complex queries, file watching for real-time updates, due-date notifications with badge support, and a Pomodoro timer integration. The user interface is built with Material-UI components, offering a clean, customizable experience with dark/light themes and color customization. Sleek supports 16+ languages and includes optional Matomo analytics, respecting user privacy by never collecting todo content.

This is a cross-platform Flutter application that serves as an unofficial client for the Pixiv illustration and novel platform. It provides a full-featured browsing experience including OAuth login, search, ranking, bookmarks, following, recommendations, comments, and a download manager with offline viewing. The architecture follows a standard Flutter app structure with custom state management (StateController), a centralized network layer using Dio to interact with Pixiv's private API, and local SQLite storage for caching images, download history, and settings. The UI is built with Fluent UI for a desktop-native look on Windows, macOS, and Linux, with platform-specific adaptations for Android and iOS. The codebase demonstrates moderate craftsmanship with reusable components like a generic cache manager, custom image provider with retry logic, and utility classes for debouncing and periodic tasks. However, it has some maintenance risks including hardcoded API credentials, reliance on undocumented Pixiv API endpoints, and a few code quality issues such as fall-through bugs in keyboard handling and non-localized strings.

BrewServicesManager is a native macOS menu bar application built with SwiftUI and Swift 6 concurrency that provides a graphical interface for managing Homebrew services (start, stop, restart, view status, detect ports, configure service links). The architecture follows a SwiftUI-first pattern with an actor-based `BrewServicesClient` for serialized shell command execution against Homebrew, an `@Observable` `ServicesStore` as the central state manager, and a modular view hierarchy for the menu bar interface. It integrates with Sparkle for automatic updates, uses `NSAppleScript` for privilege escalation when managing system-level services, and employs `lsof`/`pgrep` for port detection. External dependencies include Homebrew, Sparkle framework, and standard macOS command-line tools. The code demonstrates modern Swift practices including strict concurrency, `@Observable` classes, and clean reactively-driven UI with `@Binding` and `@Environment` injection.

AlDente is a macOS menu bar application designed to extend MacBook battery lifespan by limiting the maximum charging percentage. The application consists of two main components: a user-facing interface that runs with standard user privileges, and a privileged helper tool that communicates with the System Management Controller (SMC) to enforce battery charge limits. When the user sets a charge limit (e.g., 80%), the helper tool writes to the BCLM SMC key to prevent charging beyond that percentage. The app also monitors battery state and can prevent system sleep to maintain the charge limit when AC power is connected. The architecture cleanly separates concerns between the privileged operations (handled by the helper tool) and the user interface. Communication between components occurs via NSXPCConnection with a well-defined protocol (HelperToolProtocol). The application demonstrates solid macOS development practices including proper use of delegates for status updates, efficient polling for battery state, and clean separation of UI logic from business logic. While the repository contains legacy code from an older open-source version (as noted in the README), it includes a particularly valuable reusable component in SMC.swift. This file provides a robust, well-encapsulated interface for accessing the SMC on Intel-based Macs, handling all the low-level IOKit interactions, data type conversions, and error handling. The SMC implementation correctly manages the SMCParamStruct structure, supports various data types (UInt8, UInt32, FPE2, SP78), and includes extensions for reading temperature, fan speeds, and other sensor data.

Watt Toolkit (Steam++) is a cross-platform desktop application that serves as a multi-functional game toolbox primarily for Steam users. The system provides network acceleration via a local reverse proxy (YARP-based) with HTTPS interception, DNS analysis, and multiple proxy modes (Hosts, System, PAC, VPN, DNS intercept). It includes plugins for Steam account switching, two-factor authenticator management (import/export/recovery), game library management, ArchiSteamFarm integration for card farming, and game tools. The architecture is a modular plugin system built with Avalonia UI, .NET, and ReactiveUI, using a multi-process IPC model for privilege separation. External dependencies include WinDivert for Windows packet interception, XunYou SDK for game acceleration, and ArchiSteamFarm for automated Steam actions. The codebase demonstrates a complex but functional architecture with significant platform-specific code and some areas of technical debt.

This is a macOS desktop application that serves as an unofficial wrapper for the Google Gemini web interface. Built with SwiftUI and WebKit, it provides a native macOS experience including a main window, floating chat bar, menu bar integration, and global keyboard shortcuts. The application loads the official Gemini website in a web view while adding desktop-specific features like window management, persistent preferences, and system integration. The architecture follows a coordinated Model-View-ViewModel pattern with clear separation between UI components (Views), state management (WebViewModel), and application coordination (AppCoordinator). Notable implementation details include sophisticated window positioning logic, automatic chat bar expansion based on webpage content detection, and thoughtful handling of web view events like external links and file downloads.

This repository contains no source code. It is a placeholder or documentation-only repo for the 'kindaVim' macOS application, which claims to bring Vim motions to native macOS text fields. The only file is a README.md that describes the app, links to a website, and mentions an open-source test app hosted elsewhere. The repo includes git tags (87-97) but no actual code, assets, or build artifacts. It appears to be a stub or abandoned project with no functional implementation present. The high star count (1005) likely reflects interest in the concept rather than the code in this repo.