This article explains how Kotlin Multiplatform (KMP) can be integrated into iOS apps by covering local and remote integration methods, build and packaging steps, Swift/Objective‑C interop details, debugging, testing, and practical recommendations for when and how to adopt KMP in mobile development.
Cocoapods‑sled is a lightweight CocoaPods plugin that caches Xcode build artifacts and automatically converts reusable pods to binary form, offering low‑cost integration, local caching, binary handling, and full pod reuse to accelerate iOS development workflows.
The article demonstrates how detailed Mach‑O and LinkMap analysis combined with custom CocoaPods hooks, Swift‑syntax refactoring, and indexed symbol mapping can systematically shrink an iOS app’s bundle—from 289.3 MB to 259.3 MB—while cutting CI build time and simplifying debugging.
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.
This article details the challenges and step‑by‑step solutions the NetEase Cloud Music iOS team used to modularize legacy Objective‑C libraries, enabling seamless Swift interop through modulemap generation, CocoaPods configuration, and custom build scripts while addressing macro, header, and static‑library issues.
This article introduces iOS componentization using CocoaPods, detailing the drawbacks of manual code copying, explaining the creation of local podspec libraries, configuring source files, resources, access levels, and integration steps, while also covering sub‑specs, resource bundles, and practical code examples for Swift projects.
This article describes ByteDance's cloud‑based CocoaPods dependency analysis service, explaining its background, architecture, caching mechanisms, material pruning, and decision‑making strategies that together reduce iOS build dependency resolution time by over 60% while maintaining correctness and low integration cost.
This article details Beike's comprehensive Flutter integration approach for existing iOS and Android projects, covering official module templates, the challenges of the native integration process, and the company's source‑code and binary‑mode solutions that streamline podspec configuration, plugin handling, SDK automation, flavor support, and build efficiency.
The article introduces ARK, a dynamic development mode for iOS that replaces traditional CocoaPods‑Xcode workflows with a lightweight 2 MB repository and real‑time library conversion, dramatically cutting pod install and compile times, improving build success, and enabling fast, component‑focused development using ByteDance’s MBox tool.
The article introduces ARK, a dynamic iOS development mode that replaces traditional CocoaPods‑Xcode workflows with a lightweight repository and on‑demand component fetching, dramatically cutting pod install, compile, and index times while preserving full development capabilities.
This comprehensive tutorial explains how to use CocoaPods for iOS and macOS development, covering installation, project initialization, dependency management, podspec creation, private repository setup, version control, caching, and troubleshooting, enabling developers to efficiently manage third‑party libraries and create reusable modules.
This article describes a complete workflow for iOS UI development that centralizes color definitions in a JSON palette, synchronizes them via a CocoaPods post‑integrate hook, and automatically generates Objective‑C/Swift color constants and Xcode code snippets using Ruby and ERB templates, dramatically improving efficiency and reducing manual errors.
This article shares the Kuaishou overseas client team's practical experiences and solutions for improving compilation efficiency through Swift/Objective‑C binary mixed compilation, covering single‑target and multi‑target strategies, moduleization challenges, binary compatibility, and future directions for mobile development.
Learn how to manually create an iOS component library using CocoaPods, automate the process with the pod lib create scaffold, customize private templates, and develop a CocoaPods plugin to streamline library generation, complete with code examples and project structure details.
This article explains how Swift and Objective‑C can be mixed in iOS projects, covering prerequisite settings, CocoaPods module configuration, name mangling, compilation differences, dynamic features, method replacement techniques, and the underlying Swift runtime metadata that enable seamless inter‑language calls.
This article explains how A‑Station adopted Swift for iOS, details the prerequisites and CocoaPods configuration for mixed Swift‑Objective‑C projects, explores module usage, name mangling, dynamic features, method replacement techniques, and provides practical code examples and tooling references.
The article presents Meituan’s cocoapods‑hmap‑prebuilt plugin, which creates per‑pod and shared header‑map files to replace CocoaPods’ default header search paths, eliminates duplicate headers and disables Xcode’s native map, delivering over 45 % faster builds and more than 50 % shorter packaging times in large iOS projects.
This article describes how the iOS team reduced build times by binaryizing nearly 100 CocoaPods components, detailing macro handling, packaging with cocoapods‑packager, storage strategies, dependency switching mechanisms, and CI integration to streamline development and deployment.
This article details JD's transition to Swift mixed compilation, covering ABI stability, module stability, library evolution, the required Xcode configurations, bridging techniques for Swift‑ObjC interaction, component‑level mixing approaches, and solutions to static and dynamic linking issues across iOS versions.
To address the growing build times of the Fire Shopkeeper iOS client caused by nearly 100 components, the team implemented component binaryization using custom CocoaPods plugins, static‑framework packaging, binary storage, and CI integration, dramatically cutting compile duration from forty minutes to around twelve minutes.
This article provides a comprehensive overview of CocoaPods' Podspec file, explaining its purpose, supported formats, core data structures, attribute handling, subspec hierarchy, dependency validation, and practical steps for creating, linting, and publishing pods, with detailed Ruby code examples and best‑practice recommendations for iOS/macOS projects.
This article explains how CocoaPods Core manages Spec repositories, including the structure and initialization of Source, Metadata handling, shard-based indexing, version resolution, CDN migration, and the mechanisms for updating and searching PodSpecs across Git and CDN sources.
The team accelerated the QMusic live‑streaming SDK by converting large source modules and external pods into pre‑compiled binaries, tuning Xcode build settings, and automating CI caching, slashing full‑build times from roughly 400 seconds to 40 seconds and packaging duration from over 50 minutes to three minutes.
The article describes how 58.com evolved from a single‑team iOS app to a multi‑team, multi‑app architecture, introduces the App Factory concept with entry projects and pod pools, defines dependency rules, and presents tooling for dependency analysis, pollution detection, and incremental compilation to enable vertical business migration and rapid innovation.
This article outlines the preparation, framework redesign, and common challenges of integrating Swift into an existing Objective‑C iOS client, covering ABI stability, mixed compilation, module configuration, code standards, and future migration plans.
The article details how the Anjuke iOS client was transformed into a platform‑shared architecture through the “Jupiter Plan”, describing background challenges, multi‑endpoint reuse, shell project separation, build‑speed optimizations, and supporting tools that together boosted development efficiency.
The article explains how to integrate Flutter into existing iOS projects using both source code and product (binary) approaches, detailing scripts, Podfile modifications, and build processes to enable seamless debugging and minimal native impact.
This article analyzes the pain points of iOS development at Xianyu—complex environment setup, massive CocoaPods downloads, and slow branch‑switch builds—and details a hybrid Docker‑based solution plus artifact caching that reduces build time from half an hour to under five minutes.
This guide walks through preparing an Xcode project with CocoaPods, adding a Flutter module as a dependency, implementing the required platform router in Objective‑C, binding it in AppDelegate, and using Flutter Boost’s open and present APIs to navigate between native and Flutter pages.
The article explains how, with Swift 5.1’s ABI stability, teams can combine Swift and Objective‑C in iOS apps by preferring CocoaPods‑based modular development over bridging headers, detailing the LLVM module system, modulemap setup, namespace and linking issues, and best‑practice steps for a smooth migration.
Facing a 24‑million‑line codebase with over 100 third‑party pods, the team tackled slow Xcode compilation, lengthy packaging, and merge‑request bottlenecks by applying build‑setting tweaks, RAM‑disk compilation, CCache, and a custom binary‑pod workflow that automates packaging, publishing, and integration without altering source projects.
This article examines current iOS modularization using CocoaPods, explains binary pod strategies to dramatically reduce build times, compares manual and automated approaches, addresses debugging challenges, and presents a practical solution that toggles between source and binary modes via environment variables and Development Pods for flexible development and fast CI builds.
CocoaPods 1.9 introduces XCFramework support, configuration‑based podspec dependencies, test‑spec code coverage, Swift version variant handling, and a static‑linkage option for use_frameworks!, providing iOS developers with enhanced dependency management and build flexibility.
The NetEase Media Advertising SDK was refactored to meet source‑code and static‑library integration needs by splitting into Core and Demo modules, converting Core into a Development Pod, centralizing build settings in xcconfig files, and adding CocoaPods post‑install hooks that automate header copying and configuration, enabling seamless use across the News client and other products.
This article explains why modern iOS apps need modular dependency analysis, compares common approaches such as CocoaPods, header scanning, and symbol tools, and then details a source‑level LLVM‑based solution that uses Clang plugins to generate precise method‑level dependency metadata for each bundle.
Meituan’s iOS team introduced the CocoaPods sub‑command zsource, which extracts source‑file paths embedded in binary components’ DWARF data and automatically fetches the corresponding code, letting developers instantly replace a binary with its source for fast, source‑level debugging without rebuilding the whole project.
This article explains what CocoaPods is, its evolution, core components, and provides detailed step‑by‑step instructions for installing, uninstalling, and managing multiple versions using tools like Homebrew, RVM with gemsets, and Bundler, helping iOS developers maintain consistent development environments.
This article presents a comprehensive component‑based architecture for iOS navigation apps, detailing layered design, responsibility division, integration methods, MGJRouter communication, H5‑Native interaction, dynamic configuration, and insights from Taobao's large‑scale componentization practice.
Meituan Waimai iOS achieved an 84 % code‑reuse rate across its standalone app, Meituan channel, and Dianping channel by progressively componentizing business logic into layered CocoaPods, flattening dependencies, using binary pods for fast builds, and employing a robust toolchain and coordination among PM, RD, and QA.
This article explains how the Egg Roll Fund iOS project migrated its mixed CocoaPods and Carthage dependencies from dynamic frameworks to static libraries using CocoaPods 1.5’s use_modular_headers! flag, manual bridging‑header adjustments, and a Carthage static‑library script, resulting in faster startup and smaller app size.
This article outlines JD's iOS modular development strategy, covering background, goals, code decoupling, custom routing protocols, AppDelegate hooking, Cocoapods management, the iBiu system, configuration tables, automation scripts, CI integration, and practical deployment steps.
This article explains why using Swift or mixed Swift/Objective-C for business logic in componentized iOS projects is discouraged due to ABI compatibility issues, dynamic library loading overhead, and development complexity.
This article presents a comprehensive guide on accelerating iOS project compilation by binary‑izing common libraries, detailing three approaches—separate repository management, podspec macro handling, and prepare_command with Carthage/CocoaPods packager—along with their usage, advantages, drawbacks, and a complete workflow for creating, debugging, and publishing binary frameworks.
This article describes how the Qunar iOS team integrated and extended CocoaPods to streamline dependency management, simplify testing workflows, and resolve team‑wide development issues, thereby improving overall development efficiency and code quality across multiple mobile projects.
The article traces the progressive evolution of a mobile app's architecture—from an initial MVC structure that quickly becomes tangled, through modular designs using CocoaPods, to advanced decoupling techniques like the middleman pattern and URL routing—highlighting practical lessons for small teams and larger enterprises.
This guide introduces Google’s open‑source EarlGrey iOS UI testing framework, explains its key features, walks through environment preparation, shows both CocoaPods and manual installation methods, and demonstrates how to configure and run the first test case with detailed troubleshooting tips.
This article walks developers through the motivations, technical differences, and practical steps for creating, using, and publishing iOS frameworks, covering static vs. dynamic libraries, dependency managers, API design, versioning, CI, and release strategies to help produce robust, reusable components.
This guide walks you through enabling hidden files on macOS, exploring the .cocoapods directory structure, creating a private spec repository on a Git server, adding it to CocoaPods, writing and validating a podspec, and finally integrating the private pod into an iOS project with version tagging.
This step‑by‑step guide shows how to set up a GitHub repository, add the required source, podspec, demo, README and LICENSE files, validate the pod, push the code, and finally submit the podspec to the official CocoaPods Specs so others can use your Swift library.
