Horizon for Bluesky

I was fascinated by the potential of decentralized social media, particularly the AT Protocol that powers Bluesky. Coming from years of iOS development, I saw an opportunity to create something that the ecosystem was missing: a truly native, premium iOS experience for decentralized social networking. Most clients were web-based or felt like ports from other platforms. I wanted to build something that felt genuinely iOS-native, leveraging the latest SwiftUI features like Liquid Glass effects and iOS 26's advanced capabilities. The idea of combining cutting-edge UI with decentralized protocols really excited me. I had to unlearn a lot of old patterns and embrace SwiftUI's true nature. Instead of fighting the framework with ViewModels everywhere, I learned to use @Observable, @State, and @Environment as intended. The biggest revelation was understanding that views should own their state unless sharing is truly necessary. Reactive Programming with AsyncStream Building the multi-account system taught me how powerful AsyncStream can be for reactive architecture. Instead of complex state management libraries, I learned to let data flow naturally through the app using Swift's native concurrency features. AT Protocol Deep Dive Working with ATProtoKit forced me to understand decentralized identity systems, did:plc: identifiers, and real-time WebSocket connections. It's fascinating how different this is from traditional REST APIs. Advanced iOS Platform Integration I dove deep into WidgetKit, CloudKit, StoreKit, and push notifications. Learning to coordinate between the main app and extensions while maintaining data consistency was eye-opening. How I Built It Architecture Decisions I organized the project into feature-based packages rather than the typical MVC folders. Everything lives under /packages with clear separation:

Features: UI-focused, feature-specific modules Model: Core networking, auth, and data Shared: Reusable components like DesignSystem

This made the codebase much more maintainable as it grew. The Multi-Account Challenge The most complex part was implementing clean account switching. I discovered that the key insight was using SwiftUI's view identity system: swift.id(auth.currentAccountId) // Forces complete view recreation This ensures that switching accounts completely resets the view hierarchy, preventing data leaks between accounts while leveraging the existing reactive flow. State Management Strategy Instead of complex state management patterns, I built everything around AsyncStream and Swift's Observation framework. When auth state changes, it flows through the entire app naturally: swiftconfigurationContinuation.yield(configuration) Challenges I Faced Fighting SwiftUI (Then Learning to Work With It) Early on, I was trying to impose patterns from other frameworks onto SwiftUI. I had ViewModels everywhere and was fighting the framework constantly. Learning to embrace SwiftUI's declarative nature and built-in state management was a game-changer. Real-time Social Media Complexity Building a social media app involves so many moving parts:

WebSocket connections for live updates Efficient media loading and caching Complex notification routing Deep linking from widgets and notifications Background processing for timeline updates

Cross-Platform State Synchronization Getting widgets, the main app, and iCloud sync to work together seamlessly required careful architecture. Data needs to flow between app groups, CloudKit, and local storage without conflicts. AT Protocol Learning Curve The AT Protocol is sophisticated but different from traditional APIs. Understanding concepts like DIDs, lexicons, and the XRPC system took time. The real-time nature of social feeds also required rethinking how I handle data updates. Performance at Scale Social media apps can have massive amounts of data flowing through them. I had to learn advanced techniques for:

Efficient list virtualization in SwiftUI Image loading and caching strategies Memory management with large media content Battery optimization for real-time features

What I'm Proud Of The final result feels genuinely iOS-native in a way that many cross-platform or web-based clients don't. The Liquid Glass effects, smooth animations, and deep platform integration make it feel like an Apple app. The multi-account system is particularly elegant—it provides complete isolation between accounts while maintaining the reactive architecture throughout. Users can switch accounts instantly with no data leaks or stale state. The comprehensive widget support with multiple sizes and real-time updates shows the kind of polish that makes iOS apps special. Looking Forward This project taught me that modern iOS development is about embracing the platform, not fighting it. SwiftUI, when used properly, is incredibly powerful. The combination of @Observable, async/await, and feature-based architecture creates apps that are both maintainable and delightful to use. Building for decentralized protocols is the future, and I'm excited to be part of that movement while creating truly native mobile experiences.RetryClaude can make mistakes. Please double-check responses.

Built With

• atproto
• swift
• swiftui