JSBridge is a bidirectional communication layer that lets hybrid mobile apps combine native performance with web flexibility by allowing JavaScript to invoke native functions and native code to call back into the WebView, using techniques such as URL schemes, injected APIs, and platform‑specific evaluateJavascript methods.
An in‑depth guide shows how to build a client‑side dynamic degradation framework for iOS and Android that monitors CPU, memory, battery and network speed, classifies them into levels, and notifies the business layer to adapt UI and network usage for smoother user experience.
This article details the process of introducing React Native 0.72.10 into an existing mobile application, covering the rationale for selection, project structure adjustments, iOS and Android integration challenges, script modifications, dependency management, and solutions to common issues such as path configuration, Gradle compatibility, and library conflicts.
This article details how to create iTaTools, a macOS app and Xcode Source Editor Extension that integrates ChatGPT via AIGC to generate code, UI, and documentation directly in Xcode, complete with implementation steps, Swift code samples, and plugin architecture.
This article walks through the design, security considerations, and step‑by‑step implementation of fingerprint and face‑recognition login for an iOS driver app, covering biometric enable/disable, server‑side verification, auth‑code replay protection, ECDSA signing, keychain management, and common pitfalls.
Firefox for iOS version 124 stripped the night‑mode setting from half its users in a gray‑scale data‑gathering test, prompting fierce backlash from light‑sensitive users, while the three‑engineer team blamed a deteriorated codebase for the month‑long effort and pledged a full refactor by year‑end despite Apple’s restrictive iOS ecosystem.
This guide explains why Intel‑based macOS libraries need architecture conversion for Apple Silicon simulators, compares XCFramework and Rosetta solutions, and provides a step‑by‑step method using lipo, ar, and custom Swift code to replace load commands and rebuild arm64 binaries for simulator use.
In 2023 NetEase Cloud Music’s membership team overhauled its payment link by optimizing React‑Native checkout pages, pre‑fetching iOS IAP data, updating Android third‑party SDKs, and adding failure‑reminder SMS, boosting FCP and LCP scores, purchase UV, conversion, and overall payment success rates.
This article explains the DWARF debugging information format, its role in iOS development, how dSYM files store DWARF data, the structure of compilation units and DIEs, key DW_TAG and DW_AT attributes, UUID matching, and practical dwarfdump commands for symbolication.
Mach‑O is the macOS and iOS binary format whose header, load commands, and __TEXT/__DATA sections define executable, library, and symbol information, enabling developers to understand loading, linking, and startup performance, and to implement custom initialization hooks or modular launch tasks via custom data sections.
This article details NetEase Cloud Music's engineering solution for gradually upgrading its iOS React Native version using a dual dynamic‑library gray‑release strategy, covering background, challenges, symbol handling, code modifications, and practical issues to enable zero‑impact, data‑driven rollouts.
From March 2024, Apple will roll out EU‑only rules that permit iOS sideloading, open browsers, default‑browser choice, and alternative stores and payments, while requiring sideloaded apps to pass Apple’s certification, and limiting the feature to verified EU users through Apple‑ID billing address, device region, type and location data, with a special detection check for mainland‑China models based on known iOS code and community guesses.
Apple announced a series of iOS, browser, App Store, alternative payment, and developer fee changes required by the EU Digital Markets Act, introducing new APIs, security safeguards, alternative app store options, and revised commission structures that will roll out with iOS 17.4 in the European Economic Area.
The article describes how Bilibili created OneSDK and a macOS packaging tool that automatically selects and inserts the appropriate regional game SDKs, unifying APIs, eliminating manual configuration, and cutting integration effort by roughly 60% through Ruby‑based project manipulation and a Flutter UI.
This article shares a three‑month experience of developing and maintaining a uniapp multi‑platform project, detailing challenges such as Android camera crashes, in‑app notifications, iOS side‑swipe back, Xiaomi browser swipe conflicts, background timers, keyboard height detection, and proposes practical solutions and refactoring ideas.
Discover TheRouterSwift, a Swift-based routing framework from Huolala that offers lazy registration, dynamic route handling, service injection, interceptors, caching, and redirection, enabling seamless navigation across iOS modules and facilitating cross‑platform compatibility with Android through flexible URL mapping and remote configuration.
This article details how SoulAPP reduced its iOS clean‑build time from around 30 minutes to just a few minutes by applying precompiled headers, Xcode build‑setting tweaks, component‑based architecture, binary caching with Rugby, and targeted CI optimizations.
This tutorial explains how to use SwiftUI’s ContentUnavailableView to display empty, error, or unavailable states, covering basic usage, custom layouts, search integration, manual query handling, and a complete runnable demo with full code examples.
This guide explains how iOS 13’s UICollectionViewCompositionalLayout, together with Diffable Data Source, lets developers define items, groups, and sections using flexible size specifications, nested groups, orthogonal scrolling, custom and supplementary views, and background decorations to build complex, dynamic collection view layouts.
This guide explores Swift's advantages for iOS development, outlines suitable migration scenarios, and provides detailed solutions for common issues such as string handling, error management, access control, JSON parsing, initialization rules, Objective‑C interop, modulemap configuration, and Library Evolution constraints.
This article explains how to prevent screenshots and screen recordings on Android by using FLAG_SECURE and on iOS by monitoring screenshot and capture notifications, detailing the Baidu Account SDK’s cross‑platform implementation and emphasizing the importance of such protections for apps handling sensitive user data.
The app crashed on launch because a third‑party SDK swizzled NSString’s stringByAppendingString: with a method whose name conflicted with the app’s own swizzle, causing recursive calls through the __NSCFString class‑cluster and a stack overflow; renaming the methods with a unique prefix and excluding __NSCFString from swizzling resolves the issue.
This guide walks you through re‑signing an iOS IPA with a personal developer account—download and unzip the IPA, change the bundle identifier, replace the embedded provisioning profile, re‑sign the app and any frameworks using your certificate and generated entitlements, re‑zip the payload, and install the new IPA via Xcode.
To meet NetEase Cloud Music’s tight regression schedule, the team built Athena, a one‑stop UI automation framework that combines record‑and‑play case entry, Dawn telemetry‑based stable element locating, white‑box communication for efficiency, and integrated network‑mock and multi‑account support, delivering 73% coverage, over 90% success, and cutting regression time by more than 60%.
The Kuwo Music team shares practical iOS 17 widget‑extension lessons, detailing container‑background adaptation, borderless button styling, AppIntent communication and hidden shortcuts, Link‑based navigation, lyric animation, refresh‑rate throttling, and splitting WidgetBundles to bypass the ten‑widget limit, all with ready‑to‑copy SwiftUI code.
This article demonstrates how to bridge Swift and Kotlin in a Compose‑Multiplatform iOS app by using Swift view modifiers to detect orientation changes and call Kotlin functions, while exposing Kotlin callbacks that Swift registers to change device orientation, enabling seamless two‑way platform‑specific logic integration.
A high‑severity Bluetooth vulnerability (CVE‑2023‑45866) discovered by SkySafe researcher Marc Newlin allows attackers to bypass authentication, pair a fake keyboard, and execute code on Android, iOS, Linux, and macOS devices, with Google’s December Android security update already addressing the issue.
This article explains the principles of iOS application hardening, covering source‑level obfuscation, Bitcode‑based protection, binary‑only reinforcement, the Mach‑O loading process, rebase and bind mechanisms, and modern fixup‑chain techniques for robust mobile security.
This article details the MCube dynamic‑UI solution for mobile apps, covering the background of high development costs, the reasons for choosing MCube, the implementation of single‑floor and full‑page dynamic transformations, data‑structure redesign, common pitfalls, and best‑practice recommendations for both iOS and Android.
This article introduces a virtual routing framework for mobile applications that unifies page navigation across Android, iOS, and mini-programs, enabling dynamic URL distribution, platform-specific configurations, version-based routing, and reduced maintenance, while detailing architecture, implementation steps, and code examples.
This article introduces APPAnalyze, an open‑source script that scans iOS .ipa binaries to automatically detect package‑size problems, generates detailed size reports, and provides configurable rules and fixes to help developers efficiently reduce app bundle size.
Airbnb’s three‑stage migration from its custom Epoxy/UIKit stack to SwiftUI involved extensive evaluation, rebuilding the design system with flexible style protocols, bridging UIKit and SwiftUI, adopting one‑way data flow, extensive testing and training, resulting in six‑fold code reduction, comparable performance, widespread production adoption, and higher developer productivity despite remaining framework challenges.
This article details Baidu APP’s iOS package‑size optimization series, focusing on compiler tweaks (GCC, Swift, LTO, symbol stripping, dead‑code removal, asset catalog settings, C++ virtual‑function reduction, third‑party SDK slimming), instruction‑set pruning, Xcode‑14 improvements, and Swift dynamic‑library handling, together with concrete Xcode configuration steps and measured size gains.
This article explains the fundamentals of audio‑video concepts and demonstrates how to use Android's MediaCodec, EGL, MediaMuxer and iOS's AVAssetWriter, GPUImage, and related native APIs to render OpenGL transition effects on images and combine them with audio into a final video file.
This guide explains how to use Swift's UserDefaults for persisting preferences, share data across apps with App Groups, handle supported data types, monitor changes in real time, and consider alternatives like Keychain and iCloud for sensitive or cross‑device storage.
This article explains a complete design for uploading multiple video files from mobile apps, covering task management, resumable (MD5‑based) upload, chunked multipart form‑data handling, dynamic concurrency, memory‑efficient file streaming, error‑case handling, and provides concrete iOS code examples.
By reverse‑engineering the iOS 16 WKWebView image‑analysis crash, the team identified a nil‑buffer bug in VisionKitCore’s CGImage creation, then mitigated it by runtime‑hooking VKCRemoveBackgroundResult’s createCGImage (returning NULL) and suppressing the image‑analysis gesture, reducing crashes from thousands to near zero.
This guide walks developers through setting up Compose‑Multiplatform, implementing a Ktor‑based network layer, designing shared data models, building a LazyColumn UI, and explains Android rendering internals—from LayoutNode creation to Skiko drawing—while comparing the framework to Flutter and highlighting its low learning curve.
This article explains how to correctly use the iOS 14 PHPicker API to let users select a limited set of photos without requesting full library permission, covering component basics, configuration, common pitfalls, proper data loading, handling special formats, and progress monitoring with Swift code examples.
This article explains how to use Python scripts to automate the analysis and refactoring of iOS configuration data items in Baidu App, detailing the extraction of public properties, usage detection across modules, CSV reporting, and the overall refactoring workflow to improve maintainability and reduce risk.
This article details the end‑to‑end design, technical selection, and implementation of a lightweight map solution for the mobile game King of Glory, covering cross‑platform UI framework, Unity‑native view integration, data transmission via JCE, handling of Android/iOS click events, immersive mode, and nine‑patch image support.
An OOM crash in the K‑song iOS karaoke app was traced to a configuration that swizzled several NSMutableArray methods, causing each observer lookup to autorelease objects, rapidly filling autorelease‑pool pages and exhausting memory; converting the protection code to manual reference counting eliminated the leak and stopped the crashes.
An iOS engineer shares the challenges, tools, and insights gained while transitioning to Windows desktop development, covering language hurdles, IDE quirks, UI frameworks, encoding issues, debugging techniques, and broader thoughts on cross‑platform development and the mindset of a true technologist.
This article details how the WeChat client team identified excessive GPU usage caused by like‑animation frames in iOS video‑channel live streams and applied iOS 15's preferredFrameRateRange API along with custom animation handling to lower frame rates, reduce power consumption, and maintain user experience.
The article examines the recurring wave of shell apps on the App Store, highlighting how disguised learning tools with illicit content climb the free‑app rankings, why Apple's removal process is sluggish, and what challenges the current review system faces in curbing such violations.
This article details Hema's technical implementation of iOS Live Activities and Huawei HarmonyOS real‑time notifications across delivery and in‑store dining scenarios, covering background, deployment timeline, notification content design, integration steps, push token handling, activity ID generation, UI adaptations, edge‑case handling, and future expansion plans.
This guide walks through installing Kivy on macOS, Linux, and CentOS, creating a simple Hello‑World Python app, testing it locally, and using Buildozer to package the app into an Android APK (or iOS app), including troubleshooting tips and a virtual‑machine option.
The iOS live‑stream app was crashing from out‑of‑memory due to high‑resolution images and CPU‑based Gaussian blur, so the solution reduced download size, skipped downloads during fast scrolling, limited cached blurred images, and switched to GPUImage‑accelerated blur with a custom composite shader, cutting memory use and processing time.
Baidu reduced the iOS app package by over 350 MB by discarding dead code, replacing unreliable Mach‑O analysis with a source‑level AST approach built on LLVM libtooling and the Swift compiler, and implementing a multi‑layer static‑analysis pipeline that extracts, transforms, stores, and filters method usage data.
The article explains how to create, parse, and use NinePatch (.9.png) images by extracting the custom “npTc” chunk from a PNG file, building a PNGNinePatch object in Objective‑C, and converting its stretchable region data into UIEdgeInsets for resizable iOS UI elements.
An Ant Group engineer reverse‑engineered a severe iOS 16 keyboard crash affecting the Alipay app, traced it to a faulty lock in UIKeyboardTaskQueue, and implemented an assembly‑level patch that eliminated the bug across millions of devices.
To globally block all user interactions—including touches, motion, remote control, and press events—developers can subclass UIApplication and override its sendEvent: method, providing a disableUserInteraction: API with timed re‑enabling and a counter to safely manage concurrent disable requests.
This article details how a hidden memory‑management bug in iOS 16’s keyboard component caused massive crashes in the Alipay app, explains the reverse‑engineering process that identified the faulty UIKeyboardTaskQueue logic, and describes the assembly‑level patch that eliminated the issue across millions of devices.
The article analyzes IO‑intensive bottlenecks in mobile apps, explains how MMKV’s mmap‑based storage, rewrite, and expansion mechanisms cause main‑thread stalls, and presents concrete optimizations such as value comparison before write, pre‑expansion, compression, expiration handling, and proper instance management to dramatically reduce latency.
TheRouter-iOS is a lightweight, annotation‑driven routing middleware that brings Java‑style dependency injection, hard‑code elimination, dynamic redirection, interceptors, and flexible navigation to iOS, offering a unified solution for complex mobile architectures and seamless integration with Android and web components.
The guide shows how to shrink a Baidu iOS app by converting PNGs to HEIC within Asset Catalogs—leveraging Xcode’s actool for compression, avoiding pngquant‑induced alpha issues, and employing combined static LinkMap/Mach‑O parsing and runtime isa‑flag checks to prune never‑instantiated classes.
This article explains how front‑end developers can run AI locally on web, Android, iOS and Raspberry Pi devices using TensorFlow Lite MoveNet for real‑time pose estimation, walks through setup, model variants, Python code examples, and practical applications such as yoga‑pose classification.
This article explains how Qunar integrated iOS 16 Live Activities to display real‑time travel updates on the lock screen and Dynamic Island, covering background, feature comparison, requirements, system design, Swift implementation, push‑based updates, debugging tips, and lessons learned.
The article details Baidu’s iOS bundle‑size reduction strategy by converting PNG/JPG assets to HEIC using macOS tools or ImageMagick, storing them in Asset Catalogs for iOS 10+ compatibility, handling alpha‑channel quirks, and employing combined static‑link‑map and runtime class‑initialization analysis to safely prune unused Objective‑C classes.
This article explains how to analyze Link Map files and apply code‑level optimizations—such as removing unused classes, modules, methods, duplicate code, and AB‑test branches—to significantly reduce the binary size of Baidu’s iOS app, providing scripts, commands, and practical tips for each step.
Bilibili’s iOS team migrated from the cumbersome WORKSPACE model to Bazel Modules, adopted the community‑maintained rules_xcodeproj to replace Tulsi, and built a custom Fastbuild rule that hashes source files to reuse binaries, cutting incremental build times from dozens of minutes to under two.
This article explains the fundamentals of character encoding, covering Unicode’s universal character set, the structure of its planes and surrogate areas, the variable‑length UTF‑8 and UTF‑16 encodings, Chinese‑specific GBK encoding, and practical iOS code examples for handling Unicode, emojis and regular‑expression based Chinese character detection.
This article examines the evolution of long‑connection technology for mobile apps, outlines Baidu’s unified long‑connection service architecture, details the iOS SDK’s design choices—including protocol selection, DNS optimization, token handling, heartbeat and reconnection mechanisms—and demonstrates its real‑time messaging use cases within the Baidu App.
The article explains how Baidu App reduces its iOS package size by analyzing Link Map files and applying six code‑optimization techniques—unused class and module slimming, unused method pruning with LLVM, duplicate‑code detection, utility‑method consolidation, and A/B‑test hardening—yielding up to 8 MB of savings.
The article introduces a lightweight, protocol‑oriented iOS animation framework that uses type erasure and declarative animators to replace nested callback code, providing simple factory methods, serial and parallel execution support, and clearer, more maintainable animation sequences.
This article examines the differing behaviors of soft keyboards on iOS and Android in both H5 and React Native environments, identifies the challenges they cause for popup and textarea components, and presents cross‑platform solutions using KeyboardAvoidingView, resize listeners, and RN keyboard events to ensure input fields remain visible.
Sweep‑light loading effects, such as skeleton‑screen and logo sweeps, improve perceived performance by overlaying a moving translucent gradient mask, and can be implemented on iOS using Core Animation layers and timers, while Android uses shape drawables, ObjectAnimator or Canvas PorterDuff blending, with theme and performance considerations.
The article details ByteDance's transition from CocoaPods‑based component management to a Bazel‑driven monorepo build system, describing the problems faced, the two‑stage migration process, the BitSky build service architecture, custom plugin mechanisms, and the performance gains achieved after the migration.
This article examines how enabling system-wide large‑font mode on Android and iOS can distort Webview layouts for driver‑focused apps, presents data on user font‑size usage, compares approaches from other apps, and offers practical CSS and code solutions to reliably disable or adapt to large fonts.
This article explains the principles, usage, and internal mechanisms of CADisplayLink and NSTimer in iOS, compares their advantages and drawbacks, discusses common pitfalls such as retain cycles, explores RunLoop modes and sources, and provides code examples and solutions for reliable timer handling.
The article explains how Baidu’s iOS app reduces package size by examining Mach‑O binaries with tools like otool and MachOView, then applying Python scripts to locate oversized assets, eliminate unused configuration files, and deduplicate resources, achieving a 12 MB reduction and a repeatable optimization pipeline.
Swift inserts the high‑level SIL intermediate representation between source code and LLVM, exposing type declarations, method blocks, and virtual tables, while supporting three dispatch strategies—direct for value types and final methods, VTable for regular class methods, and Objective‑C message dispatch for @objc dynamic methods—crucial for debugging mixed Swift/Objective‑C and protocol‑extension behavior.
This article explains how Baidu's iOS app analyzes Mach‑O binaries and applies systematic resource‑optimization techniques—including big‑resource detection, unused config removal, and duplicate asset elimination—to shrink package size by over a dozen megabytes.
This case study details the performance bottlenecks of the iQIYI Kids feed on low‑end devices and presents a series of engineering solutions—including async card rendering, preloading strategies, image pre‑decoding, and cache optimizations—that reduced scroll hitch time to 1.4 ms, dramatically improving user experience.
This article explains how to enable and use iOS Picture-in-Picture for both system and custom video players, create a timer‑based PiP view, and integrate PiP into an English listening app, while comparing two implementation approaches and offering performance tips.
This article explains how to play custom voice prompts in iOS push notifications by downloading MP3 files to the app’s Library/Sounds directory or a shared app‑extension group at runtime, avoiding the need to bundle the audio in the app or submit a new version for review.
The article explains common Swift optional pitfalls—such as forced unwrapping, misuse of implicitly‑unwrapped optionals, and unsafe type casting—and shows how proper optional binding, explicit Objective‑C nullability annotations, and cautious casting can prevent runtime crashes and improve code maintainability.
OpenAI has released a free iOS ChatGPT app with Whisper‑powered voice input and syncable chat history, promises an Android version in the coming weeks, and highlights speed improvements, privacy features, and its impact on third‑party alternatives.
The guide explains Apple’s four in‑app purchase types, how to create and configure products in App Store Connect, implements the StoreKit purchase flow (including product request, payment, transaction observation, and receipt verification on server), addresses common pitfalls, and introduces NetEase’s NEStoreKit wrapper for easier integration.
This article explains the workings of SwiftLint, a static code analysis tool for Swift, covering its architecture, built‑in rules, configuration options, custom rule creation, UIWebView deprecation detection, and advanced build‑time optimizations to improve linting efficiency in mobile development projects.
The article details a cross‑platform solution for embedding the King of Glory map into Unity, describing a native Android view integration, a three‑layer UI framework with JCE definitions, data‑driven method calls and callbacks, coordinate scaling, immersive mode handling, and Nine‑Patch rendering to achieve rapid, lightweight map deployment.
The article outlines frequent memory‑leak pitfalls in Android (such as anonymous inner classes, static singletons, unregistered listeners, unclosed streams, and lingering animations) and iOS (including block retain cycles, strong delegate references, NSTimer retention, unmanaged CoreFoundation objects, and dispatch_after), and provides concrete code‑level remedies to prevent out‑of‑memory crashes.
This technical guide details how to set up iOS dependencies, publish KMM libraries, build a GitLab CI/CD pipeline, and resolve common integration problems for Kotlin Multiplatform Mobile projects, providing code examples and best‑practice recommendations for mobile developers.
The article details how a mobile app’s scanner was re‑engineered from single‑code to multi‑code detection by overhauling the logic pipeline, adding UI overlays, implementing a rotation‑and‑scale transformation algorithm, integrating iOS Vision alongside the existing SDK, applying confidence filtering, deduplication, edge‑intelligence prediction, and memory‑optimized caching, ultimately boosting recognition rates by over 30 percentage points and reducing miss‑detections.
The article explains how iOS’s lack of native GIF/WebP support leads to crashes when decoding all frames, and describes an optimized per‑frame loading component (QMAnimatedImageView) that uses CADisplayLink, NSCache, downsampling and memory‑limit tuning to dramatically reduce CPU, memory usage and jank while preserving smooth animation.
This article introduces a live‑whiteboard demo built with OpenGL ES for iOS and Android, explains the implementation of multi‑channel rendering and multi‑texture approaches, compares their performance and flexibility, and provides complete GLSL and OpenGL code snippets for developers.
The article details Baidu’s iOS image‑size reduction strategy, combining automated detection and removal of unused PNG/WebP assets, migration to Xcode’s Asset Catalog for lossless compression, and selective conversion to HEIC format, which together shaved roughly 9.75 MB from the app bundle.
The iPhone 13/14 Pro Max near‑field blur was fixed by the Paizhil Tao team by replacing the deprecated AVCaptureDevice call with AVCaptureDeviceDiscoverySession, calibrating videoZoomFactor thresholds and leveraging the virtualDeviceSwitchOverVideoZoomFactors API to automatically switch between wide, telephoto and ultra‑wide lenses under suitable zoom, lighting and focus conditions, thereby restoring close‑up image clarity and boosting recognition performance.
This article provides a comprehensive guide to Kotlin Multiplatform Mobile (KMM), covering its concepts, advantages over other cross‑platform frameworks, detailed setup steps, project structure, Gradle configuration, code examples for shared and platform‑specific modules, and an in‑depth explanation of the Android and iOS compilation pipelines.
This guide explains how to improve development efficiency by selecting appropriate cross‑platform technologies such as Uni‑app, Taro, or Kbone combined with JSBridge, outlines suitable scenarios, compares Android and iOS WebView kernels, and provides practical code examples for implementing bidirectional communication.
This article walks through the complete workflow of building an iOS object‑detection model with Apple’s CreateML, covering data collection, JSON annotation, using Roboflow for labeling, configuring training parameters, exporting the model, and integrating it into a Swift app via the Vision framework.
Facing a 420 MB iOS bundle that hurt download conversion, Baidu APP launched a comprehensive size‑optimization project—covering compiler flags, image and resource slimming, code deduplication, and build‑architecture upgrades—that trimmed 50 MB (≈12 %) of the package, boosted conversion rates, and set a benchmark for industry‑wide iOS app size management.
The article describes a modular refactor of Bilibili’s feed‑stream inline video playback, introducing a central ModuleInlineManager, ViewHandler, ViewFetcher, and an InlineController that encapsulate player logic, eliminate duplicated code, simplify maintenance, and enable flexible feature testing across diverse feed pages.
The article explains how to improve slow iOS list pages by using prefetch and preload techniques, caching network responses, handling new‑user scenarios, and implementing a hash‑based cache‑validation system to minimize unnecessary reloads and boost rendering performance.
Switchquery is a high‑performance mobile configuration delivery platform that achieves second‑level real‑time updates through a novel header‑based versioning scheme, eliminating push notifications and long‑lived connections while supporting Android, iOS, and hybrid clients with low cost and high reliability.
A comprehensive battery endurance test using Geekbench 4 on six iPhone models (iPhone 8, SE2, XR, 11, 12, 13) shows that iOS 16.4 dramatically reduces runtime for all devices, with iPhone 12 and 13 losing about an hour compared to earlier iOS versions.
The team’s second‑phase Flutter upgrade details why they moved to Flutter 2.x for null‑safety and performance gains, outlines the migration steps and common fixes, describes how they resolved a FlutterEngine destroyContext crash by cherry‑picking a fix, and provides a complete guide to building the iOS engine and gen_snapshot binaries, while previewing future expansion into Flutter Web and cross‑platform front‑ends.
The article explains how to implement iOS system‑wide screen recording using ReplayKit, covering its evolution, extension setup, sample‑buffer handling, communication between host app and extension, user‑friendly activation via RPSystemBroadcastPickerView, privacy‑mode safeguards, memory‑limit management, and practical tips for robust live streaming.
This article presents an iOS OpenGLES 2D experiment that demonstrates a face‑slimming photo‑editing demo, explains the mesh‑grid warping algorithm, shader debugging techniques, perspective and affine transformations, and provides full source code and usage instructions.
This article walks through the complete workflow of building an iOS object‑detection model with Apple CreateML, covering data collection, JSON‑based annotation (using Roboflow), training configuration, evaluation metrics, model export, and integration into a Swift app via the Vision framework.
