Tagged articles
CocoaPods
49 articles · Page 1 of 1
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.
CocoaPodsKotlin MultiplatformSwift Package Manager
0 likes · 11 min read

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.
CocoaPodsbinary podsbuild-cache
0 likes · 13 min read

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.
Bundle OptimizationCocoaPodsLinkMap
0 likes · 19 min read

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.
CI/CDCocoaPodsDependency Management
0 likes · 18 min read

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.
CocoaPodsInteropModules
0 likes · 14 min read

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.
CocoaPodsComponentizationSWIFT
0 likes · 26 min read

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.
Build OptimizationCachingCocoaPods
0 likes · 14 min read

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.
CocoaPodsFlutterGradle
0 likes · 21 min read

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.
ARKBuild OptimizationCocoaPods
0 likes · 10 min read

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.
ARKBuild OptimizationCocoaPods
0 likes · 8 min read

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.
CocoaPodsDependency ManagementObjective-C++
0 likes · 30 min read

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.
CocoaPodsColor ManagementRuby
0 likes · 12 min read

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.
CocoaPodsMixed CompilationObjective-C++
0 likes · 18 min read

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.
CocoaPodsautomationcomponent library
0 likes · 13 min read

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.
CocoaPodsInteroperabilityModules
0 likes · 25 min read

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.
CocoaPodsMixed CompilationModules
0 likes · 28 min read

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.
Build OptimizationCocoaPodsHeader Map
0 likes · 15 min read

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.
Build OptimizationCICocoaPods
0 likes · 52 min read

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.
CocoaPodsLibrary EvolutionMixed Compilation
0 likes · 17 min read

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.
CICocoaPodsbinary packaging
0 likes · 29 min read

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.
CocoaPodsRuby DSLSubspec
0 likes · 21 min read

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.
CDNCocoaPodsRuby
0 likes · 22 min read

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.
CICocoaPodsbinary packaging
0 likes · 22 min read


58 TechOct 19, 2020 · Mobile Development
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.
CocoaPodsDependency ManagementiOS
0 likes · 28 min read

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.
CocoaPodsModule SystemObjective-C++
0 likes · 12 min read


58 TechAug 10, 2020 · Mobile Development
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.
Build OptimizationCocoaPodsarchitecture
0 likes · 15 min read

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.
CocoaPodsDebuggingFlutter
0 likes · 10 min read

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.
Build OptimizationCocoaPodsDevOps
0 likes · 11 min read

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.
CocoaPodsFlutter BoostHybrid Development
0 likes · 6 min read

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.
CocoaPodsMixed CompilationModule System
0 likes · 12 min read

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.
Build OptimizationCocoaPodsContinuous Integration
0 likes · 24 min read

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.
Build OptimizationCocoaPodsbinary
0 likes · 19 min read

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.
CocoaPodsDependency ManagementSWIFT
0 likes · 6 min read

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.
Build SettingsCocoaPodsSDK
0 likes · 16 min read

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.
Clang PluginCocoaPodsLLVM
0 likes · 13 min read

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.
Binary DebuggingCocoaPodsComponentization
0 likes · 11 min read

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.
BundlerCocoaPodsDependency Management
0 likes · 12 min read

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.
CocoaPodsDynamic ConfigurationMGJRouter
0 likes · 18 min read

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.
CocoaPodsComponentizationContinuous Integration
0 likes · 22 min read

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.
CarthageCocoaPodsSWIFT
0 likes · 7 min read

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.
AppDelegateCocoaPodsJDRouter
0 likes · 14 min read

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.
ABI CompatibilityCocoaPodsComponentization
0 likes · 8 min read

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.
BinaryFrameworkCarthageCocoaPods
0 likes · 9 min read

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.
CocoaPodsDependency ManagementiOS
0 likes · 9 min read

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.
CocoaPodsURL routingiOS development
0 likes · 8 min read

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.
CocoaPodsEarlGreyXcode
0 likes · 13 min read


21CTOFeb 14, 2016 · Mobile Development
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.
CarthageCocoaPodsDependency Management
0 likes · 29 min read


Aotu LabJan 27, 2016 · Mobile Development
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.
CocoaPodsDependency Managementpodspec
0 likes · 12 min read


Aotu LabJan 27, 2016 · Mobile Development
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.
CocoaPodsGitHubPod Development
0 likes · 10 min read
