A week ago, OpenAI released the Sora 2 model along with a new Sora app that carries distinct social-platform features. For now, users can generate videos with Sora 2 only through its iOS app. In terms of visual detail, character rendering, environmental texture, and audio-visual synchronization, Sora 2 represents a substantial improvement over earlier versions. Within days, social media feeds were flooded with short clips created using the model.
The launch of the Sora app marks OpenAI’s attempt to pursue a new business direction — transforming itself from a foundational-model provider into a platform for video creation, sharing, and aggregation, in hopes of expanding its revenue streams. Yet this transition is bound to be challenging. Initially, OpenAI adopted an opt-out policy that allowed users to generate content involving copyrighted material unless rights holders explicitly withdrew their works. Following widespread backlash, however, Sam Altman announced just three days later that OpenAI would be shifting toward an “opt-in-like” system, promising finer-grained control for copyright owners and exploring a potential revenue-sharing model.
Even with mature copyright-management systems like YouTube’s Content ID, it will be extremely difficult for OpenAI to replicate such a framework within Sora and gain rights-holder approval. YouTube can build an opt-in system based on precise fingerprint matching because it deals with concrete, identifiable works; Sora, by contrast, generates outputs that are only statistically similar to existing materials rather than direct copies. In other words, YouTube addresses the question “Has an existing work been used?”, whereas Sora faces the far trickier question “Is a generated video too similar to a particular work?” — a challenge that is both technically and legally far more complex.
Even if OpenAI manages to navigate the copyright issue, Sora 2’s business model remains constrained by its costly structure. Altman has admitted that user-generated video volume has far exceeded expectations, with each ten-second clip consuming significant computational resources while serving only a small audience. Introducing a “copyright-aware model” during generation could mitigate infringement risks but would inevitably constrain creative freedom; performing similarity detection after generation, on the other hand, would substantially increase operational costs.
This dilemma exposes a peculiar reality in today’s AI industry: hardware companies like NVIDIA are reaping huge profits, while device manufacturers like Apple have created clear value-addition paths by deeply integrating AI capabilities on-device and reinforcing their ecosystem lock-in, yet the model builders themselves are still struggling to justify their lofty valuations.
Sora 2 is, without doubt, an experiment worth watching—both technologically and commercially. It may well become a milestone in generative video, but if its user experience and business returns fall short, it will only further magnify the underlying paradox of the AI economy—forcing companies and investors to reconsider where the true value of AI services lies: in capability, in content, or in the context in which they are applied.
Recent Recommendations
Waiting for an Async Result in a Synchronous Function
Developers sometimes face the need for synchronous functions to wait for async results. Apple DTS engineer Quinn “The Eskimo!” states clearly in this article: there’s no good way on Apple platforms for a synchronous function to wait on an asynchronous function’s result. Common DispatchSemaphore-based implementations have serious flaws:
- Priority Inversion: The system cannot identify thread dependencies, potentially causing UI freezes
- Thread Pool Exhaustion: Can lead to thread explosion or deadlock
Quinn’s recommended solution is using Swift async/await or refactoring the architecture to avoid synchronous waiting. This reflects Swift Concurrency’s design philosophy—fundamentally changing asynchronous programming patterns rather than patching flawed synchronous blocking approaches.
AsyncSequence for Real-Time APIs: From Legacy Polling to Swift 6 Elegance
Wesley Matlock explores with humor and clarity how to modernize traditional polling APIs using Swift 6’s AsyncStream. By comparing three approaches to real-time data updates (traditional Timer, Combine, and AsyncStream), the article demonstrates AsyncStream’s advantages: elegant cancellation, structured concurrency support, improved testability, and composability. AsyncStream not only makes polling code concise and robust but also provides a smooth migration path to true real-time solutions like WebSocket.
Adopting Liquid Glass: Experiences and Pitfalls
Clearly, many developers have encountered issues when adopting Liquid Glass, even Apple’s native apps aren’t exempt. JuniperPhoton (Weichao Deng) shares five practical problems and solutions from his adoption experience, including: rotation animation anomalies (requiring UIKit bridging), Menu morphing animation glitches, SF Symbols variant tips, performance optimization through GlassEffectContainer (reducing offscreen rendering), and button hit area corrections.
Notably, using GlassEffectContainer can merge multiple glass effects into a single CALayer, significantly reducing offscreen rendering passes while achieving smoother morphing animations.
The File Importer in SwiftUI
While SwiftUI’s fileImporter allows developers to easily build file import functionality, the import process may not work as smoothly as expected in practice. Gabriel Theodoropoulos not only covers basic fileImporter usage but emphasizes the critical technical point—security-scoped access: Since imported files reside outside the app sandbox, you must request temporary access permission via startAccessingSecurityScopedResource() and release it with stopAccessingSecurityScopedResource() when done. Gabriel recommends using defer statements to ensure permissions are always properly released, avoiding omissions due to early returns in complex code.
Foundation Models Profiling with Xcode Instruments
Xcode 26 adds Instrument support for the Foundation Models framework, helping developers analyze and optimize model performance. Artem Novichkov demonstrates its usage, covering: performance monitoring, Tool Calling optimization, session prewarming, and optimization comparisons. Note that token counting currently only works on physical devices. Additionally, Artem provides the TranscriptDebugMenu open-source library for debugging and inspecting language model session transcripts.
Testing Private Members in Swift with @_private
While the private keyword creates richer encapsulation layers, a practical frustration is the inability to effectively unit test private code. Kyle Ye introduces a testing technique in this article: using the @_private(sourceFile:) attribute to bypass access control, allowing test code to verify private member state without breaking encapsulation.
This technique is practical but requires caution. For projects needing deep internal state testing, it provides a balance between maintaining encapsulation and test coverage.
Tools
Swift Configuration - Unified Configuration Management
In real projects, we might encounter scenarios where JSON provides default settings, but users can override via environment variables, while configurations might also be modified remotely. Managing this configuration fragmentation is clearly challenging. Apple released the Swift Configuration library to address this pain point.
The library’s highlight is its hierarchical configuration system: combining multiple configuration sources (environment variables, command-line arguments, JSON/YAML files, etc.) with clear priority override mechanisms. Key features include:
- Unified configuration reading API usable by both applications and libraries
- Hot reload support for configuration updates without restarts
- Built-in access logging and sensitive data redaction
- Support for synchronous, asynchronous, and reactive access patterns
AsyncItemProvider - Timing-Safe Async Loading
In iOS’s UIDropInteraction, if you don’t synchronously start loading content before performDrop returns, the system may terminate the drop session, causing silent load failures. With concurrent programming increasingly popular, this frustrates many developers. Harlan Haskins developed AsyncItemProvider to elegantly solve this using Swift 6.2’s Task.immediate API (backward compatible to iOS 17 via Task.startOnMainActor). The library’s returned ItemLoadTask object contains: an actively loading Task (awaitable) and an observable Progress object for tracking progress.
The library offers practical value, and its implementation provides guidance for similar scenarios. This represents a practical application of the async/await refactoring approach Quinn recommends in “Waiting for an Async Result in a Synchronous Function”—though it solves a more specialized timing issue.