John Ternus talks iPhone Duo, ‘cheap and crappy’ foldables in new interview

The iPhone Duo is a strategic repositioning of Apple's modular ecosystem - but at what cost? In May 2023 - John Ternus, the former executive behind Apple's Vision Pro platform, made a surprising appearance in an interview with 9to5Mac where he spoke candidly about the future of foldable displays. This isn't just news for consumers; it's technical insight for engineers evaluating hardware-software convergence. When discussing devices like the iPhone Duo, Ternus referenced "cheap and crappy" folding technologies that still dominate the lower-end smartphone market. While some may see this as a critique of form factors, we must interpret Ternus's comments through a lens of engineering pragmatism: hardware limitations aren't insurmountable-only economically feasible. This post dives into how Apple's modular ecosystem might be reshaped by real-time user feedback models, platform stability engineering, system-level performance metrics. And API evolution for dual-screen applications. Understanding Ternus's perspective is key to grasping what lies ahead in mobile OS design, hardware-software collaboration. And software reliability. ---

Apple's Shift Toward Modular User Interfaces: A Platform-Level Perspective

The modular architecture concept has long been a staple of modern operating systems like Android and iOS - but Apple's approach remains uniquely nuanced. Ternus highlighted the iPhone Duo as a case study in how user interface design and device flexibility intersect. For example, UIKit and SwiftUI frameworks must evolve beyond fixed layouts if Apple wants to support dynamic screen configurations like those in foldables or dual-screen devices. In large-scale deployments, this means implementing adaptive routing through component reusability and layout constraints using reactive programming paradigms - such as those found in RxSwift, Combine. Or even Flutter's reactive model.

Engineering Reality: If you're managing a 10K-line SwiftUI app, reworking the layout logic to handle two independent screens without performance degradation becomes a critical SRE concern. Tools like SwiftUI Layout and iOS Auto Layout aren't just design tools - they're platforms for scalability.

---

Foldables Beyond Consumer Market: Enterprise Hardware Strategy

Foldable phones are moving beyond the consumer space, especially in enterprise or industrial sectors where durability and flexibility matter more than sleekness. The "cheap and crappy" devices Ternus references often fail at software-level compatibility - but that's not a fatal flaw if engineers are prepared for edge-case scenarios. In systems engineering, robustness is measured by fault injection testing, Chaos Engineering practices. And real-time observability via Prometheus or GrafanaThese are critical for apps running across multiple screen sizes, with volatile rendering stacks. For enterprise teams building cloud-native apps, dual-screen experiences can be handled through container orchestration workflows, like Kubernetes's Horizontal Pod Autoscaler (HPA). Which dynamically adjusts app replicas depending on screen usage patterns (i e., whether a user is switching between full and split views). The key engineering challenge: How to ensure that legacy apps remain stable when exposed to new hardware states without breaking backward compatibility. ---

Software Reliability in Flexible Display Environments

Software reliability engineering (SRE) becomes more complex when the boundary between screen size, orientation, and resolution isn't fixed. This introduces variability at the operating system level where iOS 17, with its support for dynamic interfaces, needs to be robust enough to account for device state transitions. Apple's UIWindowScene model allows apps to adapt across multiple connected displays - but in practice, that means apps need state management. And engineers must anticipate changes in rendering contexts. This is especially important for mobile UIs built with Swift Package Manager (SPM) or custom libraries like RxSwift, which are used to monitor layout change events. In our production environments, we've seen apps crash when transitioning from 1080p to a 2K split-screen interface - not because of raw code errors. But due to memory leaks tied to retained views and non-optimized lifecycle callbacks. Engineers need to consider memory-pressure mitigation strategies at the platform level, especially when handling screen transitions under dynamic load. ---

Performance Metrics Across Dual-Screen Devices

What happens when an app runs on a device with dual screens that differ in resolution, refresh rate,? And CPU/GPU load? For performance tracking, systems must be built around metrics-based monitoring, which includes tracking UI updates per frame, total GPU utilization, and memory consumption during layout transitions. Tools like Chrome DevTools and Apple's Instruments help monitor these parameters. In mobile apps, rendering overheads can spike when switching between modes - particularly under low-power CPU mode or during UI animations. When designing for dual-screen environments, developers must consider the performance penalty of running two independent renderers within a single app, similar to how modern browser tabs run independently but still share system memory. This leads us to examine platform policy mechanics for dynamic resource allocation, such as how an OS determines when to reduce frame rates or switch between CPU cores while maintaining responsive UI feedback. These decisions shouldn't be arbitrary - they need to be data-driven, informed by real metrics, especially under heavy visual load. ---

OS-Level Design for Adaptive Interfaces

Apple's ecosystem has always emphasized tight integration between hardware and software. So supporting a dual-screen experience means revisiting how the OS itself behaves. With iOS 17's introduction of Adaptive Layouts, there are more hooks into scene lifecycle management, which allows apps to react dynamically to screen changes. We've encountered issues in our own internal projects where apps failed to adapt gracefully to layout changes unless scene delegate was properly updated. For developers, this means rethinking how they structure their view controllers, perhaps adopting MVVM or MVP architectures. Where the data flows remain abstracted from physical UI components. The SceneKit framework is another example; it's used extensively in AR experiences on mobile but also has to adjust for different rendering contexts when a screen splits - which introduces new challenges in frame synchronization and depth buffer handling. Apple's UIScreen API gives engineers control over device state, but only when you add event handlers for screen size changes. Which is often overlooked by less experienced developers. ---

User State Management Under Dynamic Configurations

The most critical part of mobile app design in flexible displays is state tracking. When a user switches between full-screen and split-screen modes, all data needs to be preserved - especially if you're dealing with complex, multi-step flows like e-commerce transactions or document editing tools. We've implemented solutions involving Redux-style state management libraries, like RxSwift or Swift Composable Architecture, to isolate UI logic and maintain consistency across screen size changes. One real-world challenge was with an iOS banking app that required secure form handling. Each time a layout transition occurred, the state machine had to reinitialize views safely - a process that. While simple in theory, often failed due to asynchronous layout updates. In our engineering practices, we use unit test scaffolding with simulated screen transitions. And even perform UI automation tests using XCTest or LaunchKit for robustness. The takeaway is: design statefulness in a way that scales across hardware states, not just app states. ---

Developer Tooling and Framework Compatibility

Supporting flexible displays forces developers to reconsider tooling. Apple provides many useful tools, including Xcode, Preview Canvas, SwiftUI Preview - but they aren't thorough for all dynamic scenarios. There's a gap in support for testing full-screen vs. split-screen interactions before release. We've adopted tools like Frankenstein UI and custom Xcode plugin scripts that simulate layout changes via command-line automation. This gives teams visibility into real screen behaviors without needing physical devices - especially useful in CI/CD environments using Jenkins or GitHub Actions. In practice, developer expectations around preview accuracy often fall short - especially when handling real-time screen transitions. One thing we noticed was how poorly SwiftUI Previews behave under dynamic configuration settings; hence, engineers must move beyond previews and write functional UI specs using snapshot testing frameworks, like SnapshotTesting by pointfreeco. This is crucial to maintaining quality across platform versions - especially given the rapid pace of iOS updates tied to newer screen technologies. ---

Future Considerations for Cross-Platform App Compatibility

While we focus primarily on iOS here, dual-screen development introduces a wider ecosystem challenge - how apps behave across platforms. If an app works great on iPhone with a split-screen layout today, how well will it scale to Android or Windows devices using similar concepts? This cross-platform friction points to the need for abstraction layers like Flutter or Xamarin, which allow developers to code once and deploy across multiple device types. Even with shared logic, however, engineers must design for specific screen capabilities. There's a growing push toward native-to-cross-platform abstraction (e g, and, React Native, SwiftUI),Where apps can scale while maintaining fidelity for screen changes and transitions. This means platform policies - like those outlined in Apple's Human Interface Guidelines - will continue evolving to reflect real-world usage scenarios that push software boundaries. ---

The Cost of Innovation: A Reality Check on Foldables

Ternus's comments about "cheap and crappy" foldables offer a sobering reminder: innovation isn't just about technical capability - it's about economic feasibility. Foldable manufacturers are pushing the limits not just of screen durability. But also of software adaptability. In our own experience working with edge devices, we've found that performance optimizations tied to flexible displays are often secondary to cost-sensitive manufacturing decisions, especially in early-release product cycles. The hardware constraints translate into software compromises - a trade-off that makes or breaks app stability in the real world. So while Apple may be cautious about investing in foldables initially, engineers must prepare their apps for scenarios where screen reliability is uncertain. For SREs, this means monitoring for unexpected device behavior and preparing alerts for layout errors, crash logs. And failed screen transitions. ---

H2: How Do Design Systems Adapt to Flexibility?

Design systems are foundational in shaping user expectations. But in a world where screens can fold, pivot,? Or even detach entirely, how does the design system itself remain consistent? In our team's work, we began adopting design token-based architecture - using tools like Figma Tokens, Style Dictionary. And Storybook - to define flexible components without sacrificing cohesion. This way, UI changes across screen sizes are rendered automatically instead of manually coded. We also rely on libraries such as Tailwind CSS or React Spectrum for responsive layouts on web-based tools. But mobile development isn't just about CSS grids - it requires deeper semantic structuring and component-level reusability in native environments.

Implication: As apps evolve toward flexible displays, design systems must be state-responsive, rather than just style-driven.

---

H2: What Role Does AI Play in Flexible UI Adaptation?

At the moment, machine learning (ML) isn't deeply integrated into UI adaptation for foldables - but it will become a necessity. Imagine an app that adapts its layout autonomously based on previous usage patterns, user heatmaps, or even real-time camera input. For instance, if a developer uses Core ML models to analyze touch gestures on both display halves, the system could dynamically adjust content priority or recommend interface adjustments. We're already integrating Core ML for gesture recognition and dynamic rendering in our enterprise tools. If such systems scale to UI logic, it opens up fascinating possibilities - especially when combined with Reactive Programming models. AI can also play a role in predicting device state changes and optimizing app resource allocation accordingly - effectively turning apps into self-healing entities over time. ---

H2: How Can Observability Scale for Adaptive Hardware?

Observability in adaptive interface environments goes beyond basic crash reporting. For apps running on dual-screen or modular hardware, we must track how users interact with different screen states and correlate performance metrics accordingly. Tools like Prometheus or Elastic APM can be adapted to capture user-level events - screen size transitions, app load delays, memory spikes. But more importantly, we must instrument UI-level state changes for accurate observability. In our own projects, we instrument each screen transition with custom telemetry, logging things like:

• Layout update time
• GPU usage per view
• UI thread blocking events

We also use os_log() for structured logging and integrate into our CI pipelines with CodeClimate or SonarQube. These systems help catch layout bugs before they hit production,? And ---

What Do You Think

How will Apple's dual-screen strategy evolve Because of current ecosystem gaps? Are engineers ready to support hardware-level variability, or is it too early?

Should design systems adopt a fully flexible architecture from day one, or wait until full platform maturity is reached?

To what extent should AI be embedded into UI logic when considering modular flexibility?

--- ### FAQ Q1: What is the significance of John Ternus's comments on foldables? His commentary shows Apple's cautious optimism toward flexible hardware. He underscores technical challenges like compatibility and cost versus usability, framing dual-screen tech as a long-term platform opportunity rather than an immediate market disruptor. Q2: Does Apple have plans for dual-screen iPhones beyond the iPhone Duo speculations? Apple remains tight-lipped, but internal signals suggest modular flexibility is under evaluation. While no current roadmap outlines foldables, historical precedent shows gradual integration - especially in premium product tiers. Q3: Are developers prepared for the complexity introduced by dual-screen phones. And not yetMost apps are still built with fixed-screen assumptions. While Apple provides APIs and tools, adoption will depend on team readiness and long-term architectural shifts that prioritize adaptive state handling. Q4: What role does SRE play in adapting to flexible hardware? SREs must develop dynamic threshold monitoring, build fail-safes around layout transitions. And improve for performance under volatile screen states. They're responsible for ensuring uptime across hardware variability, which is becoming critical in modern app design. Q5: What tools support dual-screen development best? Xcode UI canvas, SwiftUI layouts, Core ML integration. And reactive frameworks like RxSwift are leading the charge. But developers must also consider custom preview automation scripts, CI/CD observability pipelines. And snapshot testing to maintain stable performance across configurations. ---

Looking for more analysis on how flexible hardware affects mobile architecture design, or want to share your own experience developing for dual-screen or modular devices? Reach out!

Subscribe to DenverMobileAppDeveloper, and com for real-world engineering insights every week.