A new design language will always trigger opinions. That’s normal.
What matters for us is what the platform enables: stronger hierarchy, more system surfaces to integrate with, and genuinely shippable on-device intelligence.
Apple didn’t just ship a new coat of paint this cycle — it shipped a new baseline. With iOS 26, iPadOS 26 and macOS Tahoe 26, Apple is aligning platforms around:
- A shared design language (Liquid Glass)
- A bigger “do things *from anywhere*” story (Spotlight actions, App Intents, controls).
- A real developer unlock: on-device foundation models you can call directly from your app
And yes — people are debating the look. That’s part of every major Apple UI shift. But in practice, the platforms are giving us new primitives that can make apps feel more modern,more usable, and more capable—if we adopt them intentionally.
---
Why “26” across the board?
The “26” versions make Apple’s release cycle easier to reason about across devices. As someone maintaining apps for iPhone + iPad + Mac, that consistency actually matters: fewer “wait, which OS introduced this?” moments, cleaner SDK targeting, and clearer parity across platforms.
---
Liquid Glass: not “a theme,” a hierarchy system
Liquid Glass is best understood as a **layering tool**. It’s Apple’s way of saying:
- This area is navigation.
- This is an action surface.
- This control needs priority — without boxing the content into heavy panels.
If you treat it like decoration, it becomes noise. If you treat it like hierarchy, it becomes clarity.
What Liquid Glass is good at
- Elevating your app’s most important UI chrome (navigation, key controls)
- Helping content feel edge-to-edge and “present”
- Making interaction surfaces feel alive and responsive (without you hand-crafting shader stacks)
SwiftUI: start simple, then compose
Keep it boring at first. Seriously. Let the system handle the heavy lifting, then selectively layer on glass where it helps.
\`\`\`swift
Text("Ship it")
.font(.headline)
.padding(.horizontal, 14)
.padding(.vertical, 10)
.glassEffect()
UIKit + AppKit: use the platform’s glass types
If you’re building custom UI chrome, prefer the system’s glass APIs over rolling your own blur/shader soup. Why?
• You inherit Apple’s performance tuning
• You get consistency as the design evolves
• You reduce the chance of subtle readability regressions
A note about accessibility (and why it’s not a “fallback”)
Translucent UI always intersects with accessibility. Users who reduce transparency should still get a readable, solid hierarchy.
Build the opt-out path like it’s a first-class design.
Your app shouldn’t become “less usable” just because someone prefers clearer contrast.
⸻
The real story is what ships alongside Liquid Glass
If you only talk about the material, you miss the upgrades that actually shift user behavior — and give developers new system surfaces to plug into.
⸻
iOS 26: fewer interruptions, richer conversations, a new Games hub
Phone and Messages are quietly more powerful
iOS 26 pushes usability in the places people live all day:
• Call Screening and Hold Assist reduce spam/hold friction
• Messages can screen unknown senders
• Conversation UX gets polls and custom backgrounds
These aren’t “developer APIs” in the immediate sense — but they shape user expectations. People are getting more control, more filtering, more personalization, and less tolerance for interruptions. Your app’s notification and comms UX should match that trajectory.
Apple Games: a system-level home for play
Apple Games is positioned as a dedicated destination for discovery, library, and social play. If you ship a game (or even game-adjacent experiences), this matters because the OS is signaling: “we want a unified place for this.”
⸻
iPadOS 26: the iPad finally gets windowing that feels pro without losing iPad-ness
This is the iPadOS update I’ve been waiting for.
A windowing system that respects how people actually work
iPadOS 26 brings a stronger multitasking foundation: windows you can resize fluidly, tiling, Exposé-style switching — without turning iPad into a mini-Mac cosplay.
The new menu bar (and why devs should care)
A menu bar users can reveal (with search!) makes iPad apps feel immediately more “tool-like.” For pro apps, the menu bar becomes a discoverability engine: commands, workflows, shortcuts — without burying everything in nested toolbars.
Real work support: Preview + background tasks
Two more signals that iPadOS is serious about “work”:
• Preview arrives on iPad for PDF/image workflows
• Background Tasks get a refreshed story, plus improvements around audio input selection and local capture
If you build productivity, creator, or document-heavy apps: this is your cue to revisit your iPad experience.
⸻
macOS Tahoe 26: Spotlight becomes an action layer
Spotlight isn’t just search anymore — it’s becoming an execution surface.
Spotlight actions + quick keys = fewer context switches
Spotlight can execute actions directly, offers browse views (including clipboard history), and supports quick keys. The developer-relevant part: apps can provide actions via App Intents.
That’s the story: the OS is rewarding apps that expose their core capabilities in a system-friendly way.
⸻
App Intents: moving from “nice-to-have” to “table stakes”
App Intents are becoming the glue across:
• Spotlight
• Widgets
• Controls
• Siri-style system actions
• Cross-device continuity experiences
If you’re still treating App Intents as optional, iOS 26/macOS Tahoe 26 is the moment to change that mindset.
Rule of thumb:
If a feature is important inside your app, it should be discoverable outside your app.
⸻
Foundation Models framework: local intelligence you can actually ship
Here’s the part I’m most excited about: Apple is opening on-device intelligence through the Foundation Models framework.
The shift is subtle but huge:
• No cloud dependency
• Stronger privacy posture
• Lower latency
• Better offline support
• Less operational cost
This isn’t “add a chatbot.”
This is “add smart, contextual micro-features”:
• Turn messy input into structured data
• Summarize and rewrite user content safely on-device
• Generate suggestions that feel native, not bolted-on
• Help users do the next step with less friction
If you’ve been hesitant to add AI because of cost, latency, or privacy… Apple just removed a lot of that friction.
⸻
Xcode 26: faster feedback loops, smarter assistance
Xcode 26 leans into AI-assisted development with Coding Tools, and the direction is clear: reduce the time between “idea” and “working code,” without forcing you into a single model/provider.
Swift 6.2: the language keeps tightening the bolts
Swift 6.2 continues the push around concurrency, performance, and interoperability — the kind of improvements you don’t celebrate on Twitter, but absolutely feel in mature codebases.
Containers on Mac: a huge quality-of-life upgrade
Apple also introduced a Containerization framework for running Linux containers on macOS with secure isolation and Apple silicon optimization.
If your workflow touches Docker, CI images, dev environments, or reproducible tooling — this is a genuinely meaningful platform move.
⸻
Metal 4 + Games: more headroom for performance and polish
For game and graphics-heavy developers, Metal 4 and the growing Apple Games surface matter because they reinforce the same theme: Apple wants higher-end experiences to feel native on its hardware.
Even if you don’t ship games, the knock-on effect is real: more performance infrastructure tends to benefit pro apps too.
⸻
Adoption guidance: a sane, low-drama plan
Here’s a practical way to approach the “26” era without rewriting your app in a weekend:
1. Build with Xcode 26 and do a UI pass to see what you get “for free.”
2. Treat Liquid Glass as hierarchy, not decoration.
3. Invest in App Intents — it’s how system surfaces discover your features.
4. Pick one Foundation Models use case that makes your app feel smarter (not noisier).
5. If you’re iPad-heavy: rethink multitasking UX around the new windowing + menu bar.
6. Test accessibility paths (especially transparency reductions) as a first-class experience.
⸻
Closing: don’t let the glass distract you from the platform
The loudest arguments are about aesthetics.
The lasting impact is about capability.
Apple is standardizing design, expanding system surfaces where your app can show up (Spotlight, controls, intents), and making on-device intelligence a practical tool you can ship without a cloud bill.
That’s a genuinely optimistic direction — not because it’s shiny, but because it gives developers more leverage.
The future of Apple development isn’t just here.
It’s integrated.
⸻
TL;DR
• Liquid Glass is a hierarchy material, not a gimmick — use it to clarify the UI layer.
• Spotlight + App Intents means your app’s features can be used outside your app.
• Foundation Models brings local AI features that are fast, private, and shippable.
• iPadOS 26 is a big “pro iPad” moment: windows, menu bar, background workflows.
• Xcode 26 and the new container story reduce friction across modern dev workflows.