A while ago, when taking over an old project, I had four tools open on my desktop at the same time.

One for writing code, one for handling Git, one for packaging, and another dedicated to uploading test builds.

The project itself wasn’t particularly large, but the development process had clearly been fragmented into many segments. Later, when I sorted things out, I realized that iOS development today is no longer an era where you just install an IDE and you’re done.

Different tools are now responsible for different stages: some handle code editing, some handle project building, and some are specifically designed for automated releases. What developers actually use is a complete workflow.

This article will not simply list software; instead, it organizes common iOS development tools according to the actual development process and discusses what problems each solves.

Code Editing: The Longest Part of Development

The tools you spend the most time with each day are usually the code editors.

Xcode

Xcode remains the core tool in iOS development.

Project creation, target configuration, Interface Builder, certificate management, and real device debugging are all bundled together. For pure native projects, it is still the most complete development environment. However, as projects grow larger, many developers start to separate “writing code” from “project management.”

VSCode

VSCode has become increasingly prominent in mobile development in recent years, largely because many teams maintain multiple platforms simultaneously:

• iOS
• Android
• Flutter
• Web
• Node services

If all code can be worked on within a single editor, the development process becomes more continuous. Swift plugins, Git plugins, terminal support, and AI-assisted tools have also made VSCode appear more frequently in iOS projects.

AppCode

JetBrains’ AppCode is still used by some developers. Its code analysis capabilities are strong, especially in large Objective-C projects, where refactoring and navigation are more noticeable. However, it still relies on the Xcode toolchain.

Project and Dependency Management

Beyond code, the project structure itself also requires tools for maintenance.

CocoaPods

Many older projects still rely on CocoaPods to manage third-party libraries. After running pod install, a workspace is generated and then opened with Xcode. Although many projects have migrated to SPM, CocoaPods hasn’t completely disappeared.

Swift Package Manager (SPM)

SPM has become the default choice for an increasing number of Swift projects. It is directly integrated into Apple’s official toolchain, so no additional dependency management tools need to be installed. Many new projects have begun to reduce their reliance on CocoaPods.

Compilation and Building: The Most Overlooked Part

Many developers click Run every day, but what actually happens is more complex than imagined:

• Parse the project
• Call SDKs
• Select architectures
• Compile code
• Link libraries
• Generate the App

These steps together form the build process.

Fastlane

Fastlane is common in team projects. It automates the execution of:

• Building
• Packaging
• Uploading to TestFlight
• Releasing versions

For example:

fastlane beta

This automatically completes the upload of a test build. When projects require frequent releases, such tools significantly reduce repetitive operations.

Jenkins / GitHub Actions

CI/CD tools are more commonly seen in team collaboration scenarios. After code is submitted, they can automatically:

• Compile the project
• Execute tests
• Generate installation packages
• Release versions

These processes become increasingly important in the later stages of a project.

Real Device Debugging and Device Management

Many issues only appear on real devices, such as:

• Push notifications
• Bluetooth permissions
• Camera functionality
• Performance issues

Therefore, real device debugging remains one of the most frequent actions during development.

Apple Configurator

Primarily used for device management, for example:

• Installing configuration profiles
• Managing test devices
• Batch deploying applications

It is common in enterprise testing environments.

Charles

Charles is not an IDE, but almost every iOS developer has it installed.

It is mainly used for:

• Packet capture
• Viewing API requests
• Analyzing network issues

When APIs behave abnormally or data structures are inconsistent, such tools become very important.

Upload and Release

After development is complete, another workflow begins.

App Store Connect

Ultimately, submitting the final version still requires Apple’s official platform.

This includes:

• TestFlight testing
• Review submission
• Version management

AppUploader

Some teams separate the upload step into a dedicated tool. Tools like AppUploader are more focused on IPA upload management rather than development itself.

Emerging Integrated Tools

As the number of tools increases, a change is emerging: the development process has become increasingly fragmented. For example:

• VSCode for writing code
• Xcode for managing projects
• Fastlane for packaging
• AppUploader for uploading

Each tool is good on its own, but the cost of switching becomes increasingly apparent.

Recently, some new integrated tools have started to appear.

One of the more interesting ones is Kuaixie (kxapp).

It does not simply solve one single step; instead, it attempts to bring several high-frequency actions back into a single environment.

Currently, Kuaixie supports:

• Swift projects
• Objective-C projects
• Flutter projects

Its editor is based on the VSCode architecture, and it comes with its own built-in compilation tool suite. After modifying a project, you can directly perform builds and run on real devices. Application building and installation package generation are also completed within the same development environment. For developers who need to frequently switch between projects or quickly verify features, this kind of tool is closer to a “complete workflow.”

Now, when considering the question “What are the iOS development tools?”, it becomes clear that it is no longer just a list of software names. Editors, dependency management tools, compilation tools, automation tools, packet capture tools, and release tools all participate in the development process.

Different teams will combine different workflows. Some prefer to use separate tools, while others are beginning to try integrated solutions.