Snapp Technology
Snapp iOS Weekly
Hi folks, Swift is stretching again this week, and not in one neat direction. We have Swift running cloud backends, tiny kernels, smarter macros, Duo-aware interfaces, and agents that need less vibes and more deterministic feedback. That’s the thread for me: abstraction is still worth it, but our tools have to make it observable, testable, and cheap enough to keep using. Whether we’re shipping iOS apps, wiring Google Cloud, or teaching an agent not to inhale a full Xcode log, the work is the same old work with sharper edges: make intent clear, then prove the code followed it.
Enjoy!
Articles
Swift
What’s new in Swift: September 2026 Edition
Swift 6.4 gets the headline here, but the fun is how wide the Swift world feels right now: Vapor 5 cutting loose from EventLoopFuture, Google shipping official Cloud clients, Wasm getting faster, and Embedded Swift sneaking into places we used to reserve for C. It’s a good reminder that Swift is no longer just “the language for our app UI,” even if most of us still meet it there every morning. If your codebase has been client-only so far, this roundup makes server-side, tooling, and embedded work feel a lot less like side quests.
Advanced macro technique #1: Static type information
Macros still can’t casually ask the compiler for a full type-checked universe, which is annoying, but not the dead end it first looks like. The trick here is using overload resolution and attached macros to surface just enough static type information to make diagnostics land where developers actually need them. That matters for our libraries and, increasingly, for our agents too: a sharp compiler error on the right property beats a mystery failure buried in generated code every time.
Introducing the Server Side Cloud Swift SDK
Karl Weinmeister, Carlos O’Ryan
Google’s official Cloud SDK for Swift is one of those releases that quietly changes the “can we do this in Swift?” conversation. Built on SwiftNIO, async/await, gRPC, and Swift’s concurrency checks, it gives backend services and CLI tools native access to Cloud Storage, IAM, Secret Manager, Gemini, and a long list of Google Cloud APIs. I still wouldn’t ship service credentials inside an iOS app — please don’t — but for our Cloud Run backends, internal tools, and shared Swift models, this is a very real door opening.
A minimal kernel in Swift, running in QEMU
A tiny Swift kernel booting in QEMU is absolutely not something most of us need for shipping apps, which is partly why it’s so much fun. The walk-through gets from Embedded Swift to a bare-metal AArch64 target, a hand-written boot entry, a linker script, putchar, memmove, and eventually a little UART echo loop. It makes Swift feel delightfully weird again: no app lifecycle, no OS safety net, just our code talking straight to the machine.
AI/ML
How to reduce token usage in Claude Code, Codex, and Cursor
The useful punchline is blunt: stop obsessing over short agent replies and start controlling what the agent reads. The measurements from real Swift app sessions are painful in a familiar way — raw xcodebuild logs, repeated full-file reads, duplicate skill loads, and cache reads eating nearly everything. For our own setups, the global hook that pipes Xcode and SwiftPM output through xcsift feels like the kind of boring fix that saves money every single day.
AI-Friendly Frameworks: As Abstraction Moves Up, How Can Verification Keep Pace?
The easy take is “agents prefer UIKit because it’s explicit,” but that’s too small. The sharper point is that SwiftUI’s abstraction is fine only if observation and verification rise to the same level: stable semantic models, structured diagnostics, snapshots, validators, tools the agent can call and trust. As our apps get more agent-written code, the frameworks that win won’t just be concise; they’ll be the ones that can prove, deterministically, when the generated thing matches our intent.
UI/UX
Presenting SwiftUI sheets on iPhone Duo
Sheets on iPhone Duo are not just “the same modal, wider screen.” SwiftUI can move them away from the fold, switch toolbar bars from horizontal to vertical, and adjust behavior depending on the display and folded state, all before we add a single custom branch. The practical bit for our apps: test existing sheets early, then reach for presentationPlacement(_:), presentationDetents(_:), and toolbarVerticalBehavior(_:) only when the default adaptation fights the content.
Utils
HIGAgentSkills
Apple’s Human Interface Guidelines are useful, but they are not exactly light reading for an agent in the middle of a design pass. HIGAgentSkills packages source-reviewed HIG references, updated for iPhone Duo and OS 27, into an agent skill with a /duo workflow for adapting existing iOS apps. I like the direction here: less “paste the whole HIG into context,” more targeted guidance, staged review, and native SwiftUI or UIKit changes our projects can actually absorb.