Apple’s WWDC26 video shows how developers can run Agentic AI locally on a Mac using the MLX framework, integrate it directly into Xcode, and achieve high‑performance, privacy‑preserving AI‑assisted app creation without relying on cloud APIs.
XcodeBuildMCP, an open‑source Sentry project, lets AI agents such as Cursor and ClaudeCode fully automate iOS/macOS development by handling Xcode build management, device selection, log capture and error handling, eliminating the manual verify‑compile‑test loop.
Anthropic’s Claude AI assistant is now integrated into Apple’s Xcode 26, letting developers link their Claude accounts, interact via natural language, and leverage tools like documentation generation, code explanation, SwiftUI previews, and inline edits to streamline building, testing, and releasing Apple platform apps.
This article walks through a complete iOS package size reduction process, covering IPA structure, detailed component analysis, Xcode compile settings, code and resource optimizations, monitoring scripts, and best‑practice guidelines to keep the app lean and stable.
Apple unveiled a suite of developer tools at WWDC—including a privacy‑focused Foundation Models framework, Xcode 26 with built‑in LLM support, enhanced App Intents, Swift 6.2 upgrades, Linux container capabilities, and App Store accessibility labels—signaling major shifts for iOS developers.
Apple’s WWDC revealed delayed Siri updates, a new Xcode 26 with built‑in ChatGPT, and a Foundation Models framework, but investors were disappointed, causing a $750 billion market‑cap drop and sparking criticism that Apple’s AI strategy lags behind competitors.
This guide explains the recent Apple privacy‑manifest requirements, how to create and fill the privacy manifest file in Xcode 15, the key fields involved, and the steps and commands needed to sign third‑party SDKs for iOS app submission after May 1 2024.
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 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 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 step‑by‑step guide shows how to create a Safari web extension that generates a QR code for the current page, covering project setup in Xcode, manifest configuration, UI design, JavaScript communication, and optional offline QR generation.
This article explains how Xcode organizes projects through xcworkspace and xcodeproj bundles, details the structure of the project.pbxproj file, describes the role of PBX objects such as PBXFileReference and PBXGroup, and shows how to manipulate Xcode projects programmatically using the Xcodeproj Ruby gem.
This article explains the architecture of Xcode workspaces and projects, detailing the relationships among workspaces, projects, targets, schemes, and the pbxproj file, and shows how these components can be leveraged for advanced build automation and configuration in iOS development.
This article details HuoLala's comprehensive iOS app slimming process—covering background metrics, Apple size limits, App Thinning, compiler and resource optimizations, Mach‑O analysis, framework handling, coding guidelines, and CI safeguards—to help developers reduce installation size, improve launch speed, and boost user conversion rates.
The team built a real‑time debugging workflow for a large Swift iOS app by using Xcode’s Attach to Process feature, restoring the exact source commit, disabling Swift optimizations, configuring LLDB source‑maps for the app and CocoaPods, and ensuring debug symbols so breakpoints work without recompiling.
This article provides a comprehensive guide to analyzing and reducing iOS IPA package size by unpacking the .ipa, examining its internal components, applying Xcode compile and code optimizations, compressing resources, removing unused assets, and establishing monitoring mechanisms to maintain a lean binary.
This guide explains what App Clips are, their capabilities and limitations, how users discover them, and provides a step‑by‑step tutorial for creating, configuring, coding, testing, and publishing an App Clip within an iOS project, including code snippets and deployment tips.
This guide explains how to update an iOS private library to the latest 15.0 runtime headers by preparing the development environment, cloning and compiling RuntimeBrowser, accessing its built‑in file server, and exporting the file list with wget for constructing a private API library.
This article explains the concept, principles, and practical steps of iOS symbolication, covering crash log processing, address translation, ASLR handling, function‑start and nlist tables, DWARF debugging information, and essential Xcode command‑line tools for accurate source‑level debugging.
This article explains the structure of Xcode workspace and project bundles, the role of the project.pbxproj file and its Property List format, how Xcodeproj maps these objects in Ruby, and demonstrates practical code for adding files and dependencies to an Xcode project.
This guide explains how to improve iOS app performance by monitoring eight key metrics—battery, launch time, hang rate, memory, disk writes, scrolling, termination, and MXSignposts—using Xcode Organizer, MetricKit, Instruments, XCTest, and the App Store Connect API.
This article systematically explains how to analyze, reduce, and monitor iOS IPA package size by examining Xcode build settings, resource files, and code, providing detailed step‑by‑step configurations, tables of component sizes, practical scripts, and best‑practice recommendations for sustainable bundle‑size management.
This article explains how to create a custom ADHoc build configuration in Xcode for a mixed Flutter and iOS project, covering steps such as duplicating Debug/Release configurations, adjusting bundle identifiers, app names, push SDK parameters, certificates, user‑defined settings, and integrating the changes into Flutter’s build scripts and CI pipelines.
LLDB is a high‑performance debugger integrated with Xcode that supports C, Objective‑C, and C++ development; this article introduces its command‑line syntax, explains key commands such as help, expression, thread, breakpoint, watchpoint, and image, and provides usage examples to improve debugging efficiency.
This guide explains how to resolve the Xcode 10 simulator launch failure on macOS Mojave by backing up, removing, and restoring the Xcode Plug‑Ins folder, along with additional steps such as editing scheme settings and resetting the simulator, providing detailed screenshots and code snippets.
This guide explains how to set up and use static analysis tools SwiftLint, Infer, and OCLint for iOS projects, covering installation methods, Xcode integration, custom configuration, report generation, and a comparative overview to help choose the right solution.
After weeks of testing by overseas developers, this guide reveals how common development tools like Xcode, VS Code, Docker, Homebrew and others perform on Apple Silicon Macs, highlighting native support, workarounds via Rosetta 2, and the remaining compatibility gaps programmers should expect.
This guide explains the complete iOS push notification workflow—from creating APNs certificates and enabling Xcode capabilities, to requesting user permission, implementing both local and remote notifications with the UserNotifications framework, debugging tools, and handling received messages across app states.
This guide walks through configuring iOS certificates, installing Fastlane, handling common installation issues, and using Fastlane or a build script to package and install an iOS app on a real device, complete with command‑line examples and troubleshooting tips.
This tutorial walks through setting up an iOS demo project in Xcode, creating a yellow rectangle view, adding a clickable button and a centered image using Swift code, and then compares the Swift syntax with equivalent Objective‑C snippets, while also covering useful comment tags.
This article explains Apple's requirement to switch to LaunchScreen.storyboard before June 30 2020, compares LaunchImage and LaunchScreen.storyboard, details the preparation steps, presents three implementation approaches, and discusses device‑specific layout problems and cache‑related black‑screen issues with code examples.
This guide explains what the Objective‑C runtime is, where to obtain its source code, the required build environment, step‑by‑step compilation instructions, and detailed solutions for the numerous build errors encountered when compiling objc4 on macOS.
This guide explains how to adopt Xcode’s UITesting framework for iPad applications—COOHOM, KuJiaLe Cloud Design, and Enterprise Cloud Design—detailing setup, test case creation, execution, code coverage collection, and seamless integration with GitLab CI to automate testing and reporting.
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 explains how to enable Xcode Canvas previews for legacy Objective‑C views by leveraging SwiftUI's PreviewProvider, detailing the required project settings, bridging‑header configuration, code examples, and troubleshooting steps for integrating preview support into large iOS codebases.
This article details a comprehensive set of practical techniques—ranging from Xcode project configuration tweaks and CocoaPods packaging to CCache, distcc, hardware tricks, PCH usage, and deep Clang/LLVM analysis—that together reduced a massive iOS build from over 27 minutes to under 10 minutes.
This article examines the challenges of iOS centralized building, introduces two build methods—single‑certificate single‑profile and single‑certificate dual‑profile—detailing required commands, certificate management, provisioning profiles, and automation steps to achieve fully automated, reproducible iOS app packaging.
This guide walks you through configuring Xcode and writing code so that Swift can call Objective‑C and vice‑versa, covering bridging headers, generated Swift headers, and integrating a Swift framework into an Objective‑C host app.
This article introduces the most commonly used LLDB commands for iOS development, covering command syntax, help utilities, expression evaluation, printing, thread management, breakpoints, and watchpoints, and provides practical code examples to improve debugging efficiency in Xcode.
This article explains how iOS developers can use Xcode's breakpoint features—including basic toggles, conditional breakpoints, ignore counts, actions like LLDB commands and log messages, exception breakpoints, and symbolic breakpoints—to pause execution, inspect state, and streamline debugging workflows.
This article explains how Xcode’s static analysis feature can automatically identify common iOS development problems—including localization warnings, logical errors, memory leaks, dead stores, and syntax mistakes—by analyzing code without execution, and shows how to resolve each type of issue.
This article explains how iOS developers can create, configure, and use Xcode breakpoints—including basic, conditional, ignore, action, options, exception, and symbolic breakpoints—to pause execution, inspect state, and streamline debugging with detailed examples and screenshots.
This article explains how Xcode’s static analysis feature can automatically identify text localization problems, logic errors, memory management concerns, dead‑store data issues, and syntax mistakes in iOS projects, and provides step‑by‑step instructions and code examples for fixing each type of warning.
This guide introduces the open‑source LLDB debugger and the Facebook‑maintained Chisel plugin for iOS, covering installation via Homebrew, configuration of .lldbinit, and a comprehensive set of custom commands that simplify UI inspection, view hierarchy analysis, and autolayout debugging within Xcode.
This guide details how to set up an iOS automation environment using Appium, Java, and related tools on macOS, covering system requirements, installation of Xcode, JDK, Node, Appium, WebDriverAgent, and necessary plugins, along with troubleshooting tips for successful device testing.
This guide explains how to resolve the Xcode 10 simulator launch hang on macOS Mojave by backing up, removing, and restoring Xcode's PlugIns folder, along with additional steps such as checking the scheme and resetting the simulator.
This guide walks you through setting up iOS real‑device debugging for WeChat mini‑programs, covering IPAPatch preparation, Xcode signing, Safari Web Inspector usage, JSContext inspection, page‑frame HTML debugging, and UI layout analysis with Reveal, all without promotional fluff.
The article summarizes WWDC 2018 highlights, covering Apple's focus on stability, performance, and security across iOS, macOS, Xcode, Swift, ARKit, and Machine Learning, while also noting new developer tools, privacy requirements, and recruitment opportunities at Liulishuo.
This tutorial explains why iOS code obfuscation is needed, how to prepare the required scripts and PCH file, configure Xcode’s build phases, and apply the obfuscation tool to hide method and variable names, while noting its limitations to .m/.h classes.
Learn how to unlock JavaScriptCore's hidden debugger on iOS by locating the framework version, building the source with private headers, creating a custom Debugger subclass, and integrating it into an Xcode project, complete with code examples and configuration tips.
An iOS team discovered that Xcode’s memory usage jumped from 2 GB to nearly 7 GB after a codebase upgrade, traced the surge to hundreds of nonnull warnings embedded in header files that inflated .dia cache files, and resolved the issue by removing the warnings, highlighting the hidden cost of ignored compiler warnings.
This guide explains why an iOS app may be rejected for IPv6 incompatibility, how to set up a local IPv6 test environment with two iPhones and a Mac, troubleshoot network bugs, update the Reachability library, and strip unsupported architectures from frameworks to resolve App Store upload errors.
This guide explains how to debug iOS devices without a USB cable by using Xcode 9's Wi‑Fi support and, for remote scenarios, by forwarding the usbmuxd service with socat to enable wireless device connections from any machine.
This tutorial introduces Apple’s ARKit platform introduced at WWDC 2017, explains the required hardware and iOS version, walks through creating an Augmented Reality App project in Xcode 9, importing 3D models, configuring plane detection, and rendering a virtual cup on a detected horizontal surface using ARSCNView.
This article comprehensively outlines Swift 4’s new syntax, language enhancements, standard‑library updates, performance improvements, and Xcode 9 build‑system changes, providing code examples and explanations to help iOS developers adopt the latest features in modern app development.
Three Liulishuo iOS engineers attended WWDC 2017 and report on Apple’s new iPad productivity features, App Store redesign, Swift updates, Xcode enhancements, and the introduction of CoreML, ARKit, and HomePod, offering developers valuable insights into the evolving iOS ecosystem.
This article explains how iOS App Slicing works, how to use Xcode's Asset Catalog to manage image resources, and how to automate the creation of device‑specific assets and the Assets.car file through a Build‑Phase Run Script, addressing challenges in large‑scale apps.
This article walks through the design and implementation of a voice‑controlled music iOS application using Siri SDK, Sketch and Principle for UI prototyping, and Xcode with Objective‑C and SpeechKit for speech recognition, culminating in a functional prototype that searches iTunes and plays song previews.
This guide details the required Mac hardware, essential software tools, Xcode and Instruments usage, and step‑by‑step procedures for performing iOS automation testing, including UIAutomation scripting and common terminal commands for developers.
Clang Static Analyzer, integrated in Xcode, provides static code analysis for C, C++ and Objective‑C, and this guide explains its core checkers, common warning types such as null‑pointer dereference and division‑by‑zero, and demonstrates how to run it via scan‑build on an iOS project to generate HTML reports.
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.
Learn essential Xcode debugging techniques for iOS development, covering project creation, interface overview, running apps, various breakpoint types, common LLDB commands, multithreading strategies, UI inspection tools, crash analysis, and recommended resources, all illustrated with step‑by‑step screenshots.
Chris Lattner, the original creator of LLVM and Clang, now leads Apple’s Developer Tools division and has driven the development of Swift since 2010, integrating his compiler expertise, fostering interactive tools like Xcode Playgrounds, and shaping modern programming education.
