When working on iOS projects, the development tool largely dictates the daily coding workflow. Factors like whether the editor is user-friendly, the project structure is clear, and device debugging is straightforward are details that repeat throughout the development process.

Recently, while developing a simple utility app, I tried switching to a different iOS development tool. Instead of continuing with the original development environment, I ran the entire project in the FastScorpion IDE. This project isn’t complex in functionality, but the development process covers key stages: project creation, code writing, real device debugging, and app building.

Below, I document the entire process, mainly discussing the tool’s practical performance from a development workflow perspective.

Creating a New iOS App Project

After installing and launching FastScorpion IDE, the interface displays a project creation entry. Clicking to create a project reveals several project type options:

  • Swift
  • Objective-C
  • Flutter

For this test, I used a Swift project. After entering the project name and selecting a save directory, the IDE automatically generates the project structure.

The project directory already includes basic code files and resource folders. Opening the entry code allows you to start writing app logic directly.

At this stage, there were no issues with environment configuration, such as missing SDKs or compilation components. The IDE prepared the necessary tools during installation, so after project creation, you can immediately start coding.

For developers needing to quickly start a test project, this workflow is relatively straightforward.
Creating a Project

Writing App Code in the Editor

FastScorpion IDE’s code editor is built on the VSCode architecture, so the interface structure feels familiar.

The left side shows the project file list, the middle is the code editing area, and the bottom contains debugging and output panels.

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

  • The page includes a button
  • A text label for displaying content

When the button is clicked, it calls a method that reads data locally and updates the text on the interface.

While writing code, the editor provides auto-completion. For example, when entering a class name, the IDE suggests methods and properties. After saving the code, the IDE automatically checks the syntax structure, highlighting any issues at the corresponding positions.

Since the editor is based on VSCode, many plugins can still be used, such as code formatting tools or AI-assisted plugins.

Connecting an iPhone and Running the App

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

Connect the iPhone to the computer via a data cable and start the build task.

The build process completes several steps:

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

After the build completes, an app icon appears on the phone’s home screen. Clicking the icon launches the app.

In the test project, clicking the button successfully displayed the read data in the text label, indicating the code logic runs correctly.

Subsequently, I modified the interface color in the code and clicked the run button again. The IDE recompiled the app and installed the new version, updating the interface on the phone.

This debugging method is quite direct, as code changes quickly show their effects in operation.
Connecting the Phone

IDE’s Built-in Compilation Tools

Throughout the development process, the IDE did not call any external development environment.

FastScorpion IDE includes a built-in suite of compilation tools. These tools are configured during IDE installation.

When clicking run or build, the IDE invokes these internal compilation tools to execute code compilation and app building.

This means developers don’t need to install Xcode separately when writing iOS apps. Code compilation, device running, and installation package generation can all be completed within the same tool.

For development phases requiring frequent app debugging, this development environment reduces many preparatory steps.

Managing Different Types of Projects Simultaneously

To test the IDE’s project support capabilities, I created two additional projects of different types.

One is an Objective-C project, and the other is a Flutter project.

The project creation method is similar to the Swift project. After creation, I wrote a simple page, connected the iPhone, and clicked run; the IDE executed compilation and installed the app.

Test results show that all three project types can run normally:

  • Swift project
  • Objective-C project
  • Flutter project

Managing projects with different technology stacks in the same iOS development tool makes the development environment more unified.

Building the App Installation Package

After app development is complete, an installation package needs to be generated for testing or release.

In FastScorpion IDE’s build menu, you can execute app building. The IDE compiles the code and generates installation files.

Build logs are displayed in the output window; if issues arise during compilation, detailed information can be viewed here.

The generated installation files can be used for testers to install or for submitting to app store review.
Building

In this test project, the development process was relatively seamless:

Create project → Write code → Connect device and run → Modify code → Recompile → Generate installation package

These steps were all completed within the same development tool.

For developers, a stable iOS development tool can make the development workflow smoother. Reducing environment configuration and tool switching allows more time to focus on the code itself.

Reference link: https://kxapp.com/