Two weeks ago, taking the opportunity of attending iOS Conf SG 2026, I visited the National Gallery Singapore and had the pleasure of viewing the special exhibition “Into the Modern: Impressionism from the Museum of Fine Arts, Boston”. Although I have seen many excellent exhibitions in the past, this experience resonated with me in a distinct and unexpected way.
The National Gallery Singapore is formed by merging two historically significant national monuments—the former Supreme Court and the City Hall. Architects connected these two classical structures with a minimalist metal and glass roof, creating a striking sense of place architecturally: history and modernity intertwined within the same physical space. The ongoing exhibition “Into the Modern”, which features over one hundred original works by masters such as Monet, Renoir, Manet, Cézanne, and Degas, elevates this cross-temporal dialogue to the realm of art.
The exhibition does not simply follow a chronological timeline; instead, it uses “modernity” as its core narrative thread, unfolding layer by layer through themes like “Cities and Change”, “Light and Moments,” and “Class and Leisure”. Although the “modern” here refers to the late 19th century, the urban renewal of Paris, the evolution of lighting techniques, and the rise of new forms of leisure depicted in the paintings all demonstrate, from multiple dimensions, the rhythm of social progress in that era. In this space where time and geography cross, the exhibition goes far beyond the mere level of “viewing art.” For someone like me, who is swept along daily by the torrent of “new tech” information on social media, this was a rare moment of tranquility and introspection.
Returning to reality, in just the past few days, the names of the hottest AI projects have shifted from Clawdbot to Moltbot, and then rapidly evolved into OpenClaw. From a microscopic perspective, we seem to be living in an era of change measured in minutes and seconds. However, if we were to look back at the current AI fever from a longer time scale years from now, we might discover that the world did not undergo the radical, fundamental mutations that we perceive while caught in the current.
Immersed in this environment, it is inevitable that we feel excitement—or even anxiety—over the endless stream of new technologies and tools. Perhaps, beyond these emotions, what we need is a deeper sense of grounding. History repeatedly reminds us that any “high tech” has its temporal limitations. Just as Monet repeatedly depicted the same haystack under different times and lighting conditions: the painting techniques may evolve, but the core object remains unchanged. What truly changes is often the way of seeing, the depth of understanding, and the creator’s own state of mind.
When facing the “present and future”, perhaps we can afford to be less frantic in our pursuit of change, and more composed in our contemplation of the moment.
This Week’s Sponsor
Need to debug HTTPS on your iPhone?
Try Proxyman! The best-in-class macOS that helps you capture/debug HTTP(s) with a few clicks. Support iOS devices and Simulator.
Recent Recommendations
DebugReplaceableView and Swift 6.2’s Multiple Type Erasers
You may still find Xcode Previews less than ideal, but Apple has been actively optimizing this experience over the past few years with notable progress. Starting with Xcode 16, views are automatically converted to AnyView via @_typeEraser in preview and debug modes to provide richer debugging information. From Xcode 26 onwards, the enhanced @_typeErasernow supports multiple type erasers, converting views to DebugReplaceableView on macOS/iOS 26+ platforms. This enables hot-swapping of views without rebuilding the entire view hierarchy, further improving preview performance. In this article, Kyle Ye dives deep into the compiler source code to analyze the implementation, explaining how the compiler automatically selects the appropriate type eraser based on platform availability.
Tiered Caching in Swift
When you need to balance performance, memory footprint, and data consistency simultaneously, a single caching strategy often falls short. In this article, Kyle Browning provides a practical guide to implementing tiered caching in Swift: organizing memory and disk caches into a clear hierarchical structure, combined with flexible cache policies (such as cacheThenFetch, cacheElseFetch, etc.) to enable data to flow smoothly between different access cost tiers.
SwiftUI: Realtime, Multi-User Content Collaboration With CloudFlare +YJS-Swift
Despite the availability of numerous services and frameworks, implementing real-time collaborative editing remains a significant engineering challenge. In this article, Itsuki demonstrates how to build a low-cost, scalable, multi-user real-time collaborative content editing system in SwiftUI using Cloudflare Durable Objects + WebSocket Hibernation API + YJS-Swift.
Particularly noteworthy is the author’s detailed explanation of how to properly maintain text cursor and selection positions when receiving remote content updates in SwiftUI—this is closely aligned with real-world product development and clearly represents hard-won experience from actual implementation.
Swift Actors: 6 pitfalls that will catch even experienced developers
Actors are one of the most important—and most easily misunderstood—features in Swift’s concurrency model. Reality, however, is far more complex than it appears. In this article, Rafał Dubiel summarizes 6 Actor pitfalls that even experienced developers commonly encounter: state inconsistency caused by reentrancy, the performance cost of Actor hopping, thread-safety vulnerabilities when @MainActor interacts with Objective-C callbacks, the risks of misusing @unchecked Sendable, misconceptions about nonisolated, and the counterintuitive fact that Actors don’t guarantee execution order.
Rafał doesn’t stop at conceptual warnings—he explains through concrete scenarios why these issues genuinely exist and why they’re so easy to overlook.
Designing a Scalable App-Wide Theming System in SwiftUI
Implementing app-wide theming in SwiftUI may seem like a simple “style management” problem, but it easily touches on deeper design decisions involving state propagation, dependency injection, and view refresh boundaries. Sagar Unagarapproaches this from a real-world requirement, demonstrating a comprehensive theming system design based on SwiftUI’s Environment: using EnvironmentKey to make themes accessible like built-in environment values, and replacing scattered hardcoded values with semantic Design Tokens.
Sagar’s focus isn’t just on “how to do it,” but on “which approach is more maintainable in the long run”—this solution doesn’t depend on any specific library, with its core philosophy being “semantic + reactive,” easily extensible to fonts, spacing, corner radius, and other design elements.
Call Once
“Ensuring a closure executes only once” sounds like a basic requirement, but in real systems, it’s often not as simple as adding a boolean flag. In this article, Paul Samuels demonstrates how to encapsulate this behavior using @propertyWrapper, progressively evolving the solution: from a basic version supporting only () -> Void, to introducing generics for return values, and finally leveraging Swift’s Parameter Packs (each Argument) to support arbitrary function signatures.
This is a thought-provoking article whose value lies not only in the final CallOnce implementation, but in demonstrating how to progressively combine multiple Swift language features to solve a seemingly simple yet representative engineering problem.
Tools
SwiftUI-Agent-Skill: Making AI Write More Reliable SwiftUI Code
If you’re using AI coding assistants (like Claude Code, Cursor, or Codex), you’ve likely encountered this problem: AI-generated SwiftUI code uses deprecated APIs, or deviates from best practices in state management and view organization—even when you’ve repeatedly emphasized these requirements in your base rules.
SwiftUI-Agent-Skill, released by Antoine van der Lee, is designed to bridge this “last mile” gap. It provides AI tools with expert-level SwiftUI guidance covering state management trade-offs, modern API replacements, performance and maintainability checks, and iOS 26+ Liquid Glass usage boundaries—turning “the places where SwiftUI code most commonly goes wrong” into a reusable, executable review workflow.
In addition to this skill, Antoine also provides skills for Swift Concurrency and Core Data.
I recommend that developers don’t just configure these into their AI environment and call it done—these skill documents themselves are structured summaries of practical experience in specific domains. Reading through them carefully benefits not just your AI, but elevates your own understanding as well.
PierreDiffsSwift: Render Beautiful Code Diff Views in macOS Apps
PierreDiffsSwift, developed by James Rochabrun, helps developers render beautiful, syntax-highlighted code diff views in macOS applications.
The library provides an out-of-the-box solution: built on the @pierre/diffs JavaScript library, wrapped into SwiftUI-native views via WKWebView, supporting syntax highlighting for 40+ languages, Split/Unified view modes, inline word-level change highlighting, and automatic dark/light theme switching.