In the iOS development environment, Xcode has always been the core tool. Project management, compilation, and device debugging are largely dependent on it. However, in specific scenarios, such as temporarily verifying an idea or quickly running a project on a new device, the step of setting up the environment in the development workflow can become quite complex.

Recently, while working on a small utility app, I tried a different approach: instead of using Xcode, I completed the entire development process in an IDE called KuaiXie. The goal was simple: to see if project creation, coding, compilation, running, and installation package generation could be smoothly accomplished in an independent environment.

Creating an iOS Project in Another Way

After opening KuaiXie IDE, you can directly access the project creation interface. It offers three project types:

  • Swift
  • Objective-C
  • Flutter

For this test, I selected Swift. After entering the project name and confirming the path, the IDE generates the project structure.

The generated project directory already includes entry files and basic configurations. Opening the code files allows you to start writing logic directly, with no additional initialization steps.

At this stage, there were no issues with missing SDKs or compilation components. The IDE installation includes the necessary development environment, so after project creation, you can proceed directly to the coding phase.
Creating a Project

Writing Application Logic in the IDE

KuaiXie’s editor is based on the VSCode architecture, with a relatively intuitive interface layout. The left side shows the project file list, the middle is the code area, and the bottom is the output panel.

To validate the development workflow, I wrote a simple page:

  • A text label to display status
  • A button to trigger updates

When the button is clicked, it calls a method that reads some local data and updates the interface.

While typing code, the editor provides auto-completion hints. For example, when entering class or method names, a suggestion list pops up. After saving the file, the IDE performs syntax checking; if errors exist, they are marked at the corresponding locations.

Since the editor is based on VSCode, you can directly use its plugin ecosystem, such as code formatting tools or AI-assisted plugins.

Connecting a Device and Running the Application

After writing the code, it needs to be run on a real device.

After connecting an iPhone to the computer, the IDE starts the build process.

This process sequentially completes:

  • Compiling the source code
  • Building the application
  • Installing it on the phone

After the build is complete, the app icon appears on the phone’s home screen. Opening the app shows the interface displaying normally.

Clicking the button successfully updates the text label, indicating that the code logic has been executed correctly.
Connecting a Device

Modifying Code and Re-running

During development, after modifying code, recompilation is needed to verify the effects.

I added a simple processing step to the button-click logic, then saved the code and clicked the run button again. The IDE re-executes the compilation process and installs the new app version.

The app on the phone is updated, and opening it shows the modified effects.

This process is relatively straightforward:

Write code → Click run → IDE compiles → Phone runs the new version

There are no steps for exporting installation packages or manual installation.

Implementation of Compilation Capabilities

Throughout this process, the IDE does not call Xcode.

KuaiXie IDE has a built-in compilation tool suite. After installation, these tools are already configured. When clicking run or build, the IDE calls its internal compilation tools to complete the application build.

This means developers can complete iOS app development without installing Xcode.

For scenarios requiring quick code testing or feature validation, this approach can reduce environment setup time.

Handling Different Projects in the Same Environment

For further testing, I created two more projects of different types:

  • An Objective-C project
  • A Flutter project

The project creation method is the same as for the Swift project. After writing a simple page, connecting the device and clicking run, the IDE can complete compilation and install the app for both.

Handling multiple project types in the same IDE can be more convenient when maintaining projects with different technology stacks.

Building Application Installation Packages

After development is complete, installation packages need to be generated.

In KuaiXie IDE, you can generate application installation files through the build function. The IDE executes compilation and outputs the installation package.

Build logs are displayed in the output panel; if compilation issues arise, you can view detailed information here.

The generated installation files can be used for test distribution or app store submission.
Building

In this test project, the development workflow remained relatively simple:

Create project → Write code → Compile and run → Modify code → Recompile → Build installation package

The entire process did not use Xcode.

For developers, this approach can serve as an Xcode alternative, useful for rapid development or feature validation.

Reference link: https://kxapp.com/blog/12