In the field of iOS development, needing a Mac is almost a default prerequisite. Project creation, code compilation, and device debugging all revolve around macOS and Xcode. However, in some practical scenarios, such as temporarily taking over a project or verifying functionality on non-Mac devices, this prerequisite can become a limitation.

Recently, while helping a friend with a small project, I tried a different approach: completing the writing and running of an iOS application without using the traditional Mac development environment.

The project wasn’t complex, but the workflow was complete, making it suitable for verifying the feasibility of this development method.

Creating an iOS Project in a Non-Traditional Environment

After opening the Kuai Xie IDE, you can directly access the project creation interface. The interface offers several project types:

  • Swift
  • Objective-C
  • Flutter

Select a Swift project, enter a name, and click create; the IDE will generate the project directory.

The project structure already includes basic code files and resource directories. Opening the entry file allows you to start writing code without additional initialization steps.

At this stage, no environment-related issues were encountered. The IDE has prepared the necessary tools for compilation, so after project creation, you can directly proceed to the development phase.
Creating a Project

Writing a Simple Feature to Validate the Project

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

  • A button
  • A text area

Upon clicking the button, local data is read and the result is displayed on the interface.

During code editing, the IDE provides auto-completion and syntax hints. When entering class names or methods, a list of options pops up. After saving the file, the IDE checks the code structure and marks error locations.

The editing experience is similar to common code editors, with relatively complete keyboard operations and plugin support.

Connecting an iPhone and Executing the Application Build

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

Connect the iPhone to the computer, and the IDE starts the build process.

The build process involves:

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

After the build completes, the app icon appears on the phone’s home screen. Clicking to open the app shows the interface displaying normally.

Clicking the button successfully updates the text area with the read data, indicating the code executed correctly.
Connecting the Phone

Modifying Code and Running Again

During development, code adjustments are constantly needed.

I added some processing logic to the button click, then saved the file and clicked the run button again. The IDE recompiles the application and installs the new version.

Opening the phone app shows the updated effect.

The entire process remains consistent:

Modify code → Click run → Compile application → Install on device → View results

No additional export or manual installation steps were required.

Implementation of Compilation Capabilities

In this workflow, Xcode on a Mac is not used.

The Kuai Xie IDE has a built-in set of compilation tools. These tools are configured during IDE installation. When clicking run or build, the IDE calls internal tools to complete code compilation and application building.

Developers in this environment can directly write iOS applications and complete compilation and execution.

For scenarios requiring code verification in non-Mac environments, this method provides a feasible path.

Development Testing Across Multiple Project Types

To further validate the IDE’s capabilities, I created a Flutter project.

After writing the Flutter page, connecting the device and clicking run allows the IDE to complete compilation and install the application.

Subsequently, an Objective-C project was tested and also ran normally.

In the same development environment, it can handle:

  • Swift projects
  • Objective-C projects
  • Flutter projects

This is convenient for cross-project development needs.

Building Installation Packages for Distribution

After application development is complete, an installation package needs to be generated.

In the Kuai Xie 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, detailed information can be viewed.

The generated installation files can be used for testing or distribution.
Building

For developers, this method can be used in specific scenarios, such as temporary development, feature verification, or when environments are limited.
Reference link: https://www.kxapp.com/blog/15