Sunday afternoon, I was preparing Monday’s weekly newsletter as usual. The moment I stood up, my right pinky finger seemed to bump into something, and then it wouldn’t straighten.
Somewhat bizarre—no pain, no swelling, but just couldn’t extend. The ER doctor’s initial assessment was pinky extensor tendon injury. I scheduled further examination for Monday, and surgery will likely be needed for repair.
It was only then that I realized how important this usually low-profile pinky finger is. Now wearing a finger splint, typing has become significantly difficult. Fortunately, it shouldn’t be anything serious, just that I’ll be typing less for a while.
Life is unpredictable; face it with a smile.
Monday Update: After further examination today, they found no fracture requiring reduction, just a simple tendon rupture. This means no surgery needed—just wearing the finger splint for 6 weeks should restore it to normal.
Recent Recommendations
From YaoYao to Tooboo: watchOS Development Pitfalls and Practical Tips
As the creator of popular watchOS apps YaoYao, Tooboo, and DunDun, Haozes shares high-quality practical experience in watchOS development, covering version compatibility, app wake-up communication, data synchronization, restart recovery, memory leaks, and battery optimization. This article encompasses a complete guide from HealthKit to WCSession, from HKWorkoutSession to TimelineSchedule, providing invaluable reference for developers who are building or planning to build Apple Watch applications.
As a long-time Apple Watch user and Swift blogger, I often marvel at the “mystique” of watchOS development—countless details beyond the documentation, with very few truly in-depth practical articles available online. For this reason, I specially invited Haozes, a leading independent developer in the watchOS space, to share his development insights.
My journey to Swift 6 and Strict Concurrency
A crash that “only appeared on real user devices” forced Irving Popovetsky to migrate an entire production iOS app to Swift 6 + Strict Concurrency. This article comprehensively documents the journey from the initial 76 errors and 238 warnings, through the gradual introduction of @preconcurrency, actor, @MainActor, Sendable, and nonisolated(unsafe), to verification with real devices and Thread Sanitizer. Irving points out that Swift 6’s runtime validates actor isolation the moment a closure is called—even if you use Task { @MainActor in } inside the closure, it may be too late. The article provides clear, reusable patterns for addressing this behavior.
Monitoring app performance with MetricKit
MetricKit is a system-level performance diagnostics framework introduced by Apple in iOS 13, designed to provide developers with app performance and stability data from real user devices. It only works in real device environments, with data sourced from long-term sampling and aggregation by the system in the background, thus more accurately reflecting app behavior in actual usage scenarios.
In this article, Majid Jabrayilov demonstrates how to subscribe to system-level performance data through MXMetricManager, progressively extracting and reporting key metrics from background abnormal exits, CPU/memory resource limits, to crash diagnostics, thereby building a more complete and traceable app performance monitoring dashboard. Majid also specifically reminds readers that MetricKit data is typically aggregated and delivered daily rather than in real-time callbacks, and actual analysis requires understanding the time range covered by each payload in combination with timestamps.
Rebuilding MistKit with Claude Code - From CloudKit Docs to Type-Safe Swift
When Leo Dion rebuilt MistKit, his long-dormant CloudKit server-side library, he discovered that swift-openapi-generator could significantly reduce refactoring complexity: by simply converting CloudKit’s REST documentation into OpenAPI specifications, he could automatically generate large-scale, type-safe Swift client code. To this end, he brought in Claude Code, specifically responsible for the translation work “from Apple documentation to OpenAPI YAML.”
The most valuable aspect of the article isn’t “how much code AI generated,” but rather how Leo uses AI. He didn’t let Claude directly implement MistKit, but positioned it as a “documentation translator and pattern amplifier,” while keeping the truly complex parts requiring engineering judgment and architectural trade-offs under his own control. Rather than having AI directly “write code,” it’s better to have it turn complex problems into generatable, verifiable problems—this is the most valuable lesson from this MistKit rebuilding process.
I Reverse Engineered ChatGPT’s Memory System, and Here’s What I Found!
Through extensive conversation experiments, Manthan Gupta reverse-engineered ChatGPT’s “memory” behavior and found its implementation far simpler than imagined: no vector database, no RAG across historical conversations, but rather composed of four layers of context—one-time injected Session Metadata, explicitly stored long-term user memories, lightweight summaries of recent conversations, and a sliding window of the current session. Manthan believes this design has obvious advantages in performance, latency, and token costs: trading pre-computed summaries and explicit fact injection for “good enough” continuity, rather than expensive full historical retrieval. Manthan also has another study on Claude’s memory system.
When using ChatGPT, I’m often surprised by how much it knows about me. Although I understand this “familiarity” comes from its memory and context mechanisms, this is also one of the important reasons why I’ve long preferred using the official client. Of course, if you’re particularly sensitive about privacy, this capability itself might be exactly the part you’re unwilling to accept.
Swift Configuration 1.0 released
Honza Dvorsky announced the official release of Swift Configuration 1.0 on the Swift official blog. This library provides a unified, type-safe configuration reading abstraction for Swift applications and libraries. The key isn’t about supporting how many configuration formats, but completely separating “how configuration is read” from “where configuration comes from.” This design is particularly important for library authors—libraries can accept configuration without binding to specific sources, thus maintaining good composability across different deployment environments. With the 1.0 release, Swift Configuration’s API has entered a stable phase and is being explored for integration by projects like Vapor and Hummingbird.
At first glance, introducing such an abstraction layer for configuration management seems somewhat “heavyweight,” but once configuration sources are no longer limited to a single file, or when code needs to be reused across different environments and projects, the advantages in structural clarity and extensibility quickly become apparent.
TCA Architecture: A Glorified Antipattern
This is an extremely opinionated long-form article. Lazar Otasevic systematically argues against TCA’s Action enum + Reducer core design from the perspective of functional programming and SwiftUI’s runtime model, considering it a classic antipattern of “encoding behavior as data” that unnecessarily takes away SwiftUI’s inherent state ownership. Unlike many “anti-TCA” discussions that remain at the emotional or preference level, this article provides a complete, runnable alternative approach: treating State as pure data, Logic as stateless implementation details, and exposing behavior through closures (capabilities), thereby maintaining testability and composability while better aligning with SwiftUI’s declarative data flow model.
Considering the period when TCA first emerged, many developers still struggled with
ObservableObject’s insufficient response granularity, lack of@MainActorandTasktools, and heavy reliance on Combine for asynchronous calls—TCA effectively solved a series of pain points at that time. However, as Swift and SwiftUI continue to evolve, some of TCA’s once-prominent advantages are no longer as obvious, and its composability model still has considerable learning and usage costs for many developers. Nevertheless, TCA remains a development paradigm that many developers and teams have adapted to and love—ultimately, what suits you is what’s best.
Tools
FluidAudio: Local Audio AI Toolkit for Apple Platforms
FluidAudio is a Swift audio AI SDK designed specifically for Apple platforms, providing fully local speech recognition, speaker diarization, voice activity detection, and other features, primarily developed by Brandon Weng and Alex Weng. All inference runs on the Apple Neural Engine (ANE), achieving low-latency, low-power audio processing capabilities.
Core Features:
- Fully Local: All models run on-device, no network connection required, fully protecting user privacy
- ANE Optimized: Leverages Apple Neural Engine, avoids GPU/MPS usage, reducing CPU usage and power consumption
- Open and Transparent: Based on MIT/Apache 2.0 licensed open-source models, available on Hugging Face
- Easy Integration: Install via Swift Package Manager, with clean and intuitive API design
- Production Ready: Adopted by well-known apps including Voice Ink, Spokenly, Slipbox, and BoltAI
FluidAudio supports automatic speech recognition (Parakeet TDT v3, 25 European languages), speaker diarization (offline/online dual modes), voice activity detection (Silero VAD), and text-to-speech (Beta). On M4 Pro, speech recognition achieves a real-time factor of approximately 190x, processing 1 hour of audio in just 19 seconds.
If you’re developing iOS/macOS applications involving speech processing, FluidAudio is definitely worth trying.
Navigable: Unified SwiftUI Navigation Management
A major pain point in SwiftUI is how to uniformly manage multi-level routing, sheets, full-screen covers, and alerts across different navigation and presentation mechanisms. Navigable, developed by Corey Davis, provides a more centralized and testable solution: it consolidates all navigation behavior into an observable NavigationState as the single source of truth.
Through this approach, Navigable maintains type-safety and modern Swift (@Observable, Swift 6) features while extracting navigation logic from views, supporting complex flows, deep linking, and unit testing. Additionally, it supports both declarative view construction and imperative APIs (like push / pop) for driving state changes, offering more controllability in complex scenarios similar to traditional routing systems.
The library is still in early development, but its implementation approach is worth continued attention.