Regular readers of my blog may have noticed that I haven’t published many personal pieces lately. Instead, over the past few weeks, I’ve shared a series of guest posts from developers across different domains. This is part of a special initiative I recently launched—inviting practitioners who have deep experience and meaningful accomplishments in their respective fields to share their hands-on insights, hard-won lessons, unique perspectives, and personal journeys.
As a blogger, I’ve inadvertently written hundreds of articles over the years. While I still believe my content holds value, I must admit that, like many writers who publish regularly, I have gradually fallen into a kind of “formulaic” rhythm. My articles tend to focus on API usage and internal mechanisms, but they are often constructed with a “demo mindset.” Even when discussing bug fixes or pitfalls, they typically address isolated “points” rather than connected “lines,” let alone full “planes.”
As a newsletter editor, I’ve also noticed another pattern: although the internet produces an endless stream of high-quality technical articles every week, truly deep, domain-specific, and frontline-driven content remains surprisingly rare. Over time, I realized the root cause: developers working on the front lines simply lack the time or energy to write such pieces. So, a few months ago, I began planning this initiative—reaching out to these developers, hoping to unearth these “silent experts” and make their tacit knowledge explicit.
During conversations with these authors, one scenario appears again and again: they don’t know what to write about. Even though they tackle complex engineering problems every day, long-term immersion makes these challenges feel ordinary or unremarkable to them. Many wonder, “Isn’t this just common knowledge? Would anyone really care about this?” At moments like this, I switch to the perspective of both a developer and a reader, and I tell them—yes, these are exactly the stories and insights we want to learn about. These are the “industry secrets” that rarely make it into writing.
In the era of AI, large models may well master vast amounts of API usage and coding patterns. But for humans, genuine emotion, real-world constraints, the friction of working with imperfect systems, and the lessons forged through countless failures—these remain our most precious and irreplaceable assets.
I am deeply grateful to the authors who generously carved out time from their busy schedules to share their knowledge. Many of the insights in their writing could only come from long-term engineering practice and the experience of being repeatedly “battered” by challenges.
This effort to unearth “silent experts” is still ongoing, with more articles already lined up. If the response continues to be positive, I will keep inviting more of these practitioners to share their stories.
We do this for ourselves, for the community, and perhaps to preserve a few distinct voices forged through lived experience in a world increasingly homogenized by AI.
Recent Recommendations
A Deep Dive into SwiftUI Rich Text Layout: Beyond AttributedString — Inside MarkdownView and RichText
Although AttributedString has been around for years, SwiftUI still lacks official support for full Markdown rendering, text–image mixed layout, selectable text, and fine-grained interactions. As the author of both MarkdownView and RichText, LiYanan walks through the technical journey behind solving these challenges—from early attempts with the Layout protocol, to hitting the limits of TextRenderer, and finally building an interactive, high-performance Markdown renderer on top of TextKit. This piece is both a record of persistence and growth, and one of the rare, in-depth resources available today on SwiftUI text rendering.
What Setting Should I Use?
Ten-year-old Swift has never been more powerful—nor more complex. Beyond added language features, developers now face an ever-growing list of compiler settings whose combinations effectively define different eras, philosophies, and semantics of Swift.
In this article, Matt Massicotte provides a grounded, highly practical answer to a real question: Which compiler settings should I actually enable in the Swift 6.2 / Xcode 26 era?
If you’re debating whether to adopt Swift 6 language mode, or can’t decide whether StrictConcurrency should be set to minimal, targeted, or complete, this article serves as a decision-making guide to help you migrate in a more controlled and incremental way.
Swift Enum Hidden Magic Tricks
Enums are one of Swift’s most distinctive language features, far beyond “switch cases with associated values.” For many experienced Swift/iOS developers, enums function as a modeling tool that shapes architectural boundaries, especially when managing complex state. In this article, Bruno Valente Pimentel systematically explains how enums help us make invalid states unrepresentable, illustrating how this principle evolves from a “syntax trick” into a genuine “design methodology” through real project examples.
“Make invalid states unrepresentable” is one of the core principles emphasized in type-driven design. If you’d like to dive deeper into the underlying concepts, the Type-Driven Design with Swift series by Alex Ozun is highly recommended.
Make Your App Visible with Alternative App Names
You may have noticed that some iOS apps can be found via Spotlight using multiple names—an incredibly convenient user experience. Behind this behavior is a SiriKit capability that allows developers to define up to three alternative app names in the app’s Info.plist, making the app easier to discover through different keywords. In this article, Wesley de Groot explains how to implement this feature.
With macOS 26 removing Launchpad, more users are turning to Spotlight to open apps. It wouldn’t be surprising if a similar alternative-names mechanism eventually comes to macOS as well.
Organizing SwiftUI Views with TabContent and @TabContentBuilder
In the last two SwiftUI releases, Apple significantly expanded the capabilities of tab-based navigation—extending it from classic bottom tab bars to more flexible, structured navigation patterns (such as sidebar-like behavior on larger screens). As a result, many real projects now have increasingly bloated TabView declarations: role-based screens, conditional branches, navigation stacks, label configurations, and team conventions often end up intertwined inside a single block.
Artem Mirzabekian suggests a cleaner approach: extracting tab definitions into a dedicated, composable configuration using a custom @TabContentBuilder. This greatly improves readability and scalability, making tab navigation easier to maintain in large SwiftUI projects.
Beyond
@ViewBuilder, SwiftUI provides many domain-specific result builders—such asTableColumnBuilder,CommandsBuilder,SceneBuilder,ToolbarContentBuilder, andChartContentBuilder. Using the right builder not only clarifies structure but can significantly reduce type-inference load in complex layouts (e.g., combining Charts and Table), helping avoid the infamous SwiftUI “type-checking explosion”.
LLDB Power User Guide: Essential Commands & SwiftUI Debugging
Debugging SwiftUI has never been easy. While many developers rely on sprinkling print statements throughout their code, the far more powerful capabilities of LLDB often go overlooked. In this article, Jai Krishna demonstrates—using extensive SwiftUI examples—how to inspect and modify the internal state of @State, @Binding, and @Published at runtime, trace redraw triggers with Self._printChanges(), and use targeted breakpoint strategies to pinpoint layout and interaction issues.
Identifying Hangs in iOS Apps
Many developers encounter UI hangs caused by main-thread blocking, yet identifying the exact source is often difficult. Tiago Henriques walks through a purposefully laggy demo app to show how to use Instruments’ Time Profiler to determine the nature and scope of the issue. Reproduction and identification are only the first steps—Tiago also notes that deeper performance-analysis content may follow if readers show interest.
Tools
SwiftUI Ratings
If you need to build an in-app rating/review interface or guide users more naturally toward leaving an App Store review, SwiftUI-Ratings, developed by James Sedlacek, offers a plug-and-play solution. It provides a highly customizable UI modeled after the App Store’s ratings and reviews page and allows developers to integrate any data source through the AppRatingProviding protocol (with mock and Supabase / App Store Connect examples included). A lightweight, modern, and extensible choice for implementing an in-app rating prompt.
Swift Hugging Face
Hugging Face is the world’s leading open-source AI community and model hub, offering a vast ecosystem of models, datasets, tools, and collaboration spaces—serving as essential infrastructure for building and deploying modern AI applications.
As Hugging Face’s official Swift client, Swift Hugging Face provides two major capabilities: First, it fully wraps the Hugging Face Hub API, giving Swift developers native access to models, datasets, Spaces, and more. Second, it integrates the Inference API, enabling tasks such as chat completion, embeddings, text-to-image/video generation, and speech-to-text to run directly on iOS, macOS, visionOS, as well as Linux and Windows.
In the article Introducing swift-huggingface: The Complete Swift Client for Hugging Face, Mattt explains the library’s design and usage in depth, opening the door for Swift developers to fully leverage the Hugging Face AI ecosystem.