DEV Community: ObjC_Coder

iOS Dev Efficiency Tools: My Summarized Tools After 17 Code Changes in One Page Debug

ObjC_Coder — Wed, 08 Jul 2026 09:54:31 +0000

The issue on that page was actually not complicated: a list displayed correctly on an iPhone 13, but when switched to another device, the bottom button was pushed up a few pixels by the safe area. The UI itself had no errors, and the constraints worked fine, but there was a slight offset during scrolling.

This kind of problem is common in iOS development. What really consumes time is not fixing the logic, but repeatedly verifying. After checking the Git commit history, I found that from initial localization to final confirmation, I had changed the code about 17 times. Each modification required recompilation, running, connecting the device, and confirming the page behavior.

After that day, I started reorganizing the iOS development efficiency tools I was using.

Editors Actually Affect Continuity

When many people first start iOS development, they default to Xcode. It is complete, but as project types increase, a real issue emerges: the code you write in a day is not necessarily all Swift. It might also include:

Flutter pages
Shell scripts
JSON configurations
Backend API code

Therefore, many developers gradually shift to editors like VSCode. The reason is simple: work context does not require frequent switching. Plugins, shortcuts, Git operations, and terminal logic remain consistent. The editor itself does not reduce bugs, but it affects whether the development process is interrupted.

Real-Device Debugging Is the Most Frequent Development Action

What really takes time is the cycle of: modify code → compile → install to device → check results.

Page layouts, animations, permissions, push notifications, Bluetooth, camera – these features must be verified on real devices. If this process requires frequent switching of tools, the development rhythm becomes fragmented.

Therefore, many developers start to pay more attention to toolchain integration:

Can modifications be built quickly?
Can the device be directly connected?
Is additional export needed?
Is the installation process continuous?

These issues never appear in technical interviews, but they affect development experience every day.

Automation Tools Address Repetitive Work

In the later stages of a project, another category of tools becomes important, such as Fastlane, Jenkins, and GitHub Actions. What they do is not mysterious; they essentially automate building, packaging, uploading, and publishing. When these actions need to be repeated dozens of times, people start making mistakes. For example, when a test package needs to be regenerated daily, the value of automation scripts becomes very apparent.

Compilers Are Also Part of Efficiency Tools

Many developers don't discuss "compilers" separately because in traditional development workflows, they are hidden behind the IDE. But actually:

Project parsing speed
Build process
Architecture choice
SDK calls
Installation to device

All of these are part of the compilation pipeline. The larger the project, the more developers feel the time cost here.

I Recently Noticed a Pretty Interesting Tool

While reorganizing my toolchain recently, I came across an iOS development tool called Kuaixie (kxapp) . What attracted me was not that it "supports writing Swift."

Instead, it attempts to reintegrate several high-frequency actions in the development process:

Supports Swift, Objective-C, and Flutter projects
Editor based on VSCode architecture
Built-in compilation tool suite
Can run directly on real devices
Provides app package building capability

The key point here is that it does not separate "editing" and "compiling" into two independent environments. After modifying code, you can directly proceed to the build and device verification process. For people who need to frequently debug pages or maintain multiple projects, this design makes it easier to maintain development continuity.

The Value of a Tool Is Not Necessarily Reflected in the Number of Features

Often, what makes a tool truly useful is not how powerful it is, but whether it reduces repetitive actions. For example, opening one less window, switching one less environment, executing one less repeated command – these details individually seem minor, but they accumulate.

Especially when a page requires repeated debugging, developers become increasingly aware of the impact of the toolchain itself on development rhythm.

Generate AppStoreInfo.plist on Mac for App Store Submission

ObjC_Coder — Mon, 06 Jul 2026 08:00:54 +0000

When uploading an IPA to App Store Connect on macOS, a common issue is that the IPA is exported successfully with correct signing and no errors from Xcode Archive, but during the upload phase you get Missing AppStoreInfo.plist or Could not locate AppStoreInfo.plist.
Many developers instinctively try to manually create the plist file, copy it from an old project, or unzip the IPA and patch the file.

This not only fails to solve the problem but also introduces new metadata errors.

This article directly analyzes where AppStoreInfo.plist is generated and how to avoid manually maintaining it on macOS.

The file does not actually exist inside the IPA

Some developers unzip app.ipa and search for AppStoreInfo.plist in the Payload directory, only to find it does not exist. This is normal because AppStoreInfo.plist is not part of the app bundle itself.

It belongs to the upload metadata, not the App Bundle.

Why it is missing even on Mac

Many assume that using a Mac guarantees the plist file, but that is not the case.
The following scenarios often cause it:

Scenario	Result
Using command-line upload	Missing metadata
Custom upload script	Plist not generated
CI upload	Only IPA generated
Non-Xcode upload	No metadata phase

Why Xcode rarely reports this issue

During the Archive → Export process, Xcode automatically generates metadata and assembles the upload structure, so developers are unaware of it.

The real issue is during the upload phase

If the IPA is signed, can be installed, has the correct Bundle ID, but reports a plist error during upload, it means the upload tool lacks the ability to generate metadata.

Do not manually create the plist

Some online methods suggest:

<?xml version="1.0" encoding="UTF-8"?>

and then manually write the fields. The problem is that Apple metadata fields change, upload protocols update, and different Transporter versions have different structures. Incomplete fields will cause upload failure directly.

A simpler approach: auto-generate during upload

On macOS, a more stable method is to let the upload tool automatically generate AppStoreInfo.plist.

This eliminates the need to maintain the plist, study metadata formats, or manually assemble XML.

Using AppUploader CLI to upload

Tool location

mac version: inside AppUploader.app/runtime/, after entering the runtime, you can use appuploader_cli. Upload command:

Example:

appuploader_cli --upload-app -f Payload.ipa -u user@example.com -p xxxx-xxxx-xxxx-xxxx --type ios

Or:

appuploader_cli upload -f Payload.ipa -u user@example.com -p xxxx-xxxx-xxxx-xxxx --type ios

When uploading via CLI, it automatically parses the IPA, reads the Bundle ID, Version, Build Number,
creates metadata including AppStoreInfo.plist, and then invokes the upload interface to upload to App Store Connect.

Command-line is more suitable for long-term projects

If the project already uses:

Fastlane
Jenkins
GitHub Actions
GitLab CI

GUI upload becomes inconvenient.

CLI is more suitable for:

Scenario	Advantage
Automated builds	Scriptable
Multi-project upload	Easy batch processing
Remote servers	No GUI dependency

Example:

Flutter packaging IPA
Mac mini as CI node
Jenkins automatic upload

Script:

./appuploader_cli upload \
-f build/ios/app.ipa \
-u ci@example.com \
-p xxxx-xxxx-xxxx-xxxx \
--type ios

Metadata is automatically generated during upload, no manual plist intervention required.

AppStoreInfo.plist belongs to the metadata generation phase, not the app build phase.

If the upload tool already supports automatic metadata generation, there is no need to manually maintain the plist file.

iOS Compiler Independent of Xcode: Detailed Explanation of the kxbuild Tool in kxapp

ObjC_Coder — Thu, 02 Jul 2026 08:36:56 +0000

In iOS development, compilation is rarely discussed.

Most of the time, after writing code, you click Run, and the IDE handles the rest. But if you break down this process, many steps occur in between: parsing the project, selecting a target, handling architectures, calling SDKs, generating an executable, and packaging it into an IPA.

These steps are usually hidden inside Xcode, but once you step away from it, you realize that the entire workflow can exist independently.

Recently, while looking at an iOS development tool called Kuaixie (kxapp), I noticed it has a built-in independent compilation tool — kxbuild. Its positioning is straightforward: a compiler that can directly process iOS projects.

This article mainly discusses what such a tool actually does from the perspective of the compilation process itself.

What Changes When You Extract Compilation

Consider the simplest scenario: you have an Xcode project.

In the traditional workflow:

Open Xcode
Select a target
Click Build
Wait for the application to be generated

Behind these actions, there is actually a series of commands.

kxbuild's approach is to make these steps explicit, allowing developers to complete builds directly through commands.

For example, in the project directory, run:

kxbuild build --target MyApp --configuration Release --clean --install

This command does several things:

Selects the build target
Uses the Release configuration
Cleans the cache
Compiles the project
Installs to the device

In other words, the process hidden in the IDE is expanded into controllable steps.

How It Recognizes Project Structure

A key question is: how does the compiler understand the project?

kxbuild supports directly parsing iOS projects, including:

Xcode projects
Swift project structures

Before executing a build, you can view project information using the list command:

kxbuild list

This command lists the schemes and targets in the current directory.

If you add the --src parameter, you can also see the source files in the project:

kxbuild list --src

This process is equivalent to "reading the project structure" and is the first step of compilation.

Build Parameters: More Detailed Than You Think

Once the project structure is identified, the next step is to configure build parameters.

kxbuild provides some options that can be directly controlled, for example:

--target: Specifies the build target
--arch: Selects the architecture (arm64 / x86_64)
--configuration: Debug or Release
--clean: Cleans the cache before building
--install: Installs to the device after building

These parameters also exist in the IDE but usually don't require manual setting.

When used via the command line, you can control the build behavior more explicitly. For example, when debugging architecture-specific issues, directly specifying --arch is clearer.

Visibility of SDK and Build Environment

Another easily overlooked point is the SDK.

In Xcode, the SDK is implicitly present. But in an independent compiler, you can directly view the available SDKs:

kxbuild showsdks

This command lists all iOS and simulator SDKs on the system.

For scenarios where you need to troubleshoot build issues, such as SDK mismatch or version conflicts, this information is essential.

Complete Path from Code to IPA

Stringing these commands together forms a complete workflow:

Identify project structure (list)
Confirm SDK (showsdks)
Set build parameters (target / arch / configuration)
Execute build (build)
Output install package and optionally install to device

This path is a "click-to-complete" process in the IDE but a "command-driven" process in kxbuild.

The difference between the two methods is not about capability but about control granularity.

Role of kxbuild in kxapp

Using a command-line compiler alone has one problem: lack of context.

Where do you write code? Where do you view debugging? How do you manage devices?

kxapp's approach is to integrate kxbuild into the IDE, making compilation capability part of the development workflow rather than a standalone tool.

In this environment:

Code writing is done in the editor (based on VSCode architecture)
Compilation is executed through kxbuild
Running can directly connect to devices
Building can generate install packages

Thus, a closed loop is formed between the command-line tool and the IDE.

What Scenarios Are Suitable for This Compilation Method

From a usage perspective, this type of tool is more suitable for:

Developers who want to directly control the build process
Scenarios that do not rely on a full IDE
Workflows that require fast building and app installation
Cases with clear requirements for build parameters

Complete Solution and Toolchain for iOS Cross-Platform Development: Coding and App Store Submission

ObjC_Coder — Tue, 30 Jun 2026 01:04:23 +0000

When discussing cross-platform development, it's easy to get stuck on framework choices, such as Flutter, React Native, or uni-app. But when the project actually starts, problems usually arise later, such as:

How to handle iOS signing
How to package without a Mac
How to upload IPA

Cross-Platform Frameworks Are Just an Entry Point

First, establish a foundation: cross-platform frameworks solve UI and business logic reuse, not iOS publishing

Common choices:

Framework	Runtime Method
Flutter	Dart compilation
React Native	JS Bridge
uni-app	WebView / Native

Whichever you choose, eventually an iOS project (or a project that can build for iOS) will be generated

Example (Flutter)

flutter build ios

Example (uni-app)

Use HBuilderX cloud packaging to generate an iOS package

Building Cross-Platform ≠ No Need for Xcode

Even when using cross-platform frameworks, building for iOS still requires:

Certificates
Provisioning profiles

For Flutter:

flutter build ipa

Under the hood, Xcode is still invoked.

If the signing configuration is incorrect, it will fail directly.

Signing Preparation: A Key Watershed for Cross-Platform Projects

This is where many projects get stuck.

On macOS, you can use Xcode's automatic management, but in cross-platform environments (Windows / Linux), you need to prepare manually.

You can use AppUploader to generate signing files.

Operation Steps

1. Create a Certificate

Open AppUploader
Enter Certificate Management
Click Add
Select distribution
Set name and password
Download .p12

2. Create a Provisioning Profile

Enter Provisioning Profile Management
Create a new App Store type
Select Bundle ID
Bind certificate
Download .mobileprovision

3. Import into Build Environment

macOS → Import into Keychain
CI → Script import

Multiple Ways to Build IPA

Cross-platform projects can choose different build methods:

Method 1: Local Mac Build

Suitable for:

Having a Mac device
Debugging phase

Method 2: Cloud Build

For example:

HBuilderX cloud packaging
CI (Mac Runner)

Method 3: Automated Build (Fastlane)

build_app(
  export_method: "app-store"
)

The build result is always:

.ipa file

Uploading IPA Can Break Free from macOS Dependency

The upload step can be completely independent.

On Windows or Linux, you can upload directly.

Uploading with AppUploader

Steps:

Open the Submit Upload page
Enter Apple ID
Set app-specific password
Select IPA file
Choose upload channel (1 or 2)
Click Upload

If you encounter:

Upload stuck
Progress not moving

You can switch channels and upload again.

Review and Publishing: No Difference for Cross-Platform Projects

After upload:

Go to App Store Connect:

My Apps → Select App → TestFlight → Build → Submit for Review

Prepare:

App screenshots
Privacy policy
Test account

A Common Overlooked Issue in Cross-Platform Development

When modifying the Bundle ID:

The provisioning profile does not update automatically

Symptom:

Build succeeds
No build after upload

Solution:

Recreate the provisioning profile
Ensure Bundle ID consistency

Cross-platform development solves the problem of writing code once, but the publishing process still follows iOS rules. You can separate signing, building, and uploading. Cross-platform projects are no more complex than native ones when it comes to iOS submission.

Writing Swift in VSCode and Running on iPhone? A Practical Experience with KuaiXie IDE Development

ObjC_Coder — Wed, 10 Jun 2026 09:50:48 +0000

In daily development, VSCode has become the default editor for many people. Writing front-end, scripts, or even back-end services can almost all be done in the same environment. However, when it comes to iOS development, things become different—Swift can be written, but project building, running, and debugging still rely on a complete toolchain.

Recently, while working on a small feature validation, I attempted to complete the entire process of writing Swift in VSCode, not only writing code but also running it on an iPhone. During this process, I used an iOS development IDE called KuaiXie, which offers an editing experience similar to VSCode while having built-in compilation and debugging capabilities.

Creating a Swift Project in a VSCode-like Environment

After opening KuaiXie IDE, the interface structure is quite similar to common code editors. The left side shows the project directory, and the middle is the editing area.

When creating a project, you can choose different types:

Swift
Objective-C
Flutter

After selecting Swift and entering the project name, the IDE automatically generates the project structure. The directory already includes entry files and basic configurations.

One difference here is that there is no need to manually configure project files. Once the project is created, you can directly open the code files and start writing Swift.

If you are used to writing code in VSCode, the learning curve for this step is relatively low.

Writing Swift in a VSCode-like Editor

During the code editing phase, the experience is essentially writing Swift in an enhanced VSCode environment.

I created a simple page:

A button
A text label

Clicking the button updates the text content.

While typing code, the editor provides auto-completion suggestions. For example, when entering UIKit-related classes, it automatically lists available methods. After saving the code, the IDE performs syntax checking.

If you need to use an AI code assistant, you can directly install VSCode plugins, which is consistent with the daily development environment.

For developers accustomed to keyboard shortcuts and plugin systems, this editing experience feels quite natural.

Running Code on an iPhone

After writing the code, the key question becomes: Can it be directly run on a phone?

After connecting the iPhone to the computer, execute the build process.

This process completes:

Compiling Swift code
Building the application
Installing it on the device

Within seconds, the app icon appears on the phone's desktop. Clicking the icon launches the application.

In the test project, clicking the button successfully updates the text content, indicating that the code has been executed correctly.

Modifying Code and Quickly Validating

During development, code needs constant adjustments.

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

Opening the phone app shows the modified effects.

The rhythm of this process is quite clear:

Write code → Run → Modify → Run again

The entire process does not require switching tools or additional export steps.

How Compilation and Running Are Completed

In this workflow, no external development environment is used.

KuaiXie IDE has a built-in compilation tool suite. When clicking run, the IDE calls internal tools to complete Swift code compilation and application building.

This is why iOS development can be done in a VSCode-like environment.

When writing Swift, developers do not need to install Xcode separately or manually configure the compilation environment.

Handling Different Projects in the Same Environment

To verify the IDE's capabilities, I created a Flutter project.

After writing the Flutter page, connecting the device and clicking run, the IDE can complete the build and install the application.

Subsequently, I tested an Objective-C project, which also compiled and ran normally.

In the same environment, you can handle:

Swift projects
Objective-C projects
Flutter projects

For developers who need to switch between different technology stacks, this approach is quite convenient.

Building Installation Packages

After the application 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 issues arise, you can view detailed information here.

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

The focus of this test was to verify whether it is feasible to complete Swift development in a VSCode-like environment.

In KuaiXie IDE, the entire workflow is seamless:

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

The code-writing experience is similar to VSCode, while also having iOS application compilation and running capabilities.

For developers accustomed to VSCode, this development approach offers a different choice.

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

IPA Upload Rejected Without Clear Reason? Troubleshoot via Provisioning Profile, Certificate, and Bundle ID

ObjC_Coder — Tue, 09 Jun 2026 10:04:16 +0000

Some iOS projects encounter tricky situations after uploading an IPA:

App Store Connect does not show the build
Or shows "Processing Failed" without specific reasons
Email notifications are vague, such as "Invalid Binary"

This type of problem is difficult to pinpoint directly because the error messages do not point to code or specific configurations. In such cases, rather than blindly modifying the project, it's better to adjust the upload approach. Below explains how to handle these issues.

First, Confirm Where the Problem Occurs

Upload failure is not a single scenario; it involves at least:

Building the IPA locally or via CI
Uploading to Apple's servers
Apple's backend processing the build

Different stages exhibit different symptoms:

Stage	Symptoms
Build Stage	Xcode / Fastlane reports errors
Upload Stage	Tool reports errors or interrupts
Process Stage	App Store Connect shows no build or processing failure

If the IPA uploads successfully but there is no build record in the backend, the issue usually lies in signing or package content.

Check if the IPA is Actually a Release Build

A common issue: the uploaded file is actually a Development build.

Verification method:

unzip -p app.ipa Payload/*.app/embedded.mobileprovision | grep -a "ProvisionedDevices"

If the output contains device UDIDs, it indicates:

A Development provisioning profile is used
This build cannot be used for the App Store

A correct App Store build:

Does not contain a device list
Provisioning profile type is App Store

Verify if the Provisioning Profile and Certificate Match

If the provisioning profile and certificate do not match, the upload stage may not report errors, but Apple's processing will fail.

You can use tools to view provisioning profile content.

In AppUploader (Happy Upload):

Open the provisioning profile management
Import or view the current provisioning profile
Check the following information:
- Whether the type is App Store
- Whether the bound certificate is Distribution
- Whether the Bundle ID is consistent

If inconsistencies are found here, you need to regenerate the provisioning profile and repackage.

Check if the Bundle ID Matches the App Store

If the Bundle ID is inconsistent, after upload, you may encounter:

Build successfully uploaded
But cannot find it in App Store Connect

Check path:

Open the IPA
View CFBundleIdentifier in Info.plist
Compare with the Bundle ID in App Store Connect

Both must be exactly the same.

Confirm if the Build Number is Incremented

Apple rejects duplicate version numbers during build processing.

Check:

CFBundleShortVersionString (version number)
CFBundleVersion (build number)

If the build number has not changed:

Upload may succeed
But no new build will be generated

It is recommended to increment the Build number for each build.

Repackage and Change the Upload Method

Sometimes the issue is not with the IPA itself, but with the upload method.

For example:

Upload interruptions in certain network environments
Transporter upload anomalies
Fastlane deliver timeouts

You can try switching upload tools.

For example, using AppUploader to upload:

Open the submission upload page
Set the Apple-specific password
Select the IPA file
Switch upload channel (1 or 2)
Execute the upload

Different channels use different upload paths, helping to rule out network or interface issues.

Compare Differences Between Two Builds

If the problem persists, you can perform a "difference comparison."

Operation method:

Keep an IPA that was successfully uploaded before
Extract and compare with the current IPA:

diff -r old_app new_app

Focus on:

embedded.mobileprovision
Info.plist
Frameworks directory

If differences in signing or resources are found, you can quickly locate the issue. You can also use AppUploader to view IPA files.

IPA upload rejections without reasons are not without cause; the problem occurs in unseen areas.

Reference link: https://www.appuploader.net/blog/228

New iOS Development Tool Experience: Complete App Development and Real Device Debugging in FastScorpion IDE

ObjC_Coder — Sat, 06 Jun 2026 09:52:15 +0000

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.

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.

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.

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/

Upload iOS Apps via Command Line on Linux: Fastlane + AppUploader (Happy Uploading)

ObjC_Coder — Fri, 20 Mar 2026 10:32:35 +0000

Many teams run their CI or release environments on Linux servers, such as GitLab Runner, Jenkins, or self-built build nodes. After the app has generated a .ipa file, the next question is: Can the IPA be directly uploaded to the App Store from Linux?

The answer is yes, with the key being to separate the processes—building the IPA and uploading the IPA are not the same thing.

Below explains how to complete the iOS upload process via command line on Linux.

1. Prepare Files Required for Release

Before uploading from Linux, three files need to be prepared:

File	Purpose
`.ipa`	iOS app installation package
`.p12`	iOS distribution certificate
`.mobileprovision`	App Store provisioning profile

These files can come from different sources:

Mac build environment
CI build system
Cloud packaging services

If the team does not have a Mac, certificates and provisioning profiles can also be generated in Windows or Linux environments using AppUploader (Happy Uploading).

General process for generating certificates:

Log in to the Apple Developer account
Go to certificate management
Create a distribution type certificate
Download the .p12 file

Process for creating provisioning profiles:

Go to provisioning profile management
Create a new App Store type
Bind the Bundle ID and certificate
Download the .mobileprovision file

These files will be used during the packaging or CI build phase.

2. Build IPA in CI or on Mac

Linux environments typically only handle releases, not building iOS apps.

IPA can be generated in the following ways:

Using Xcode

Execute on Mac:

Product → Archive

Then export the App Store type IPA.

Using Fastlane

If the project uses Fastlane, it can be built via script:

lane :release do
  build_app(
    scheme: "AppScheme",
    export_method: "app-store"
  )
end

Execute:

fastlane release

Generate the .ipa file.

After building, upload the IPA to the Linux server.

3. Install Upload Tool on Linux

Upload tools from Xcode cannot run on Linux, but command-line upload tools can be used.

One way is to use AppUploader CLI.

After downloading AppUploader, the command-line tool can be found in the compressed package.

Confirm the command is executable:

chmod +x appuploader_cli

4. Upload IPA Using Command Line

Execute on the Linux server:

appuploader_cli -f app.ipa -u appleid@example.com -p xxxx-xxxx-xxxx-xxxx -c 2

Parameter explanation:

Parameter	Meaning
`-f`	IPA file path
`-u`	Apple Developer account
`-p`	App-specific password
`-c`	Upload channel

Channel explanation:

1 Old upload channel
2 New upload channel

After successful upload, the command line will return the upload status.

5. View Build in App Store Connect

After uploading, go to App Store Connect:

My Apps → App → TestFlight

Wait for Apple to process the build.

After processing is complete:

New build version can be seen
TestFlight distribution is possible
Submission for review is possible

6. Automate Upload in CI

One advantage of Linux command-line upload is direct integration into CI.

For example, Jenkins Pipeline:

stage('Upload IPA') {
    sh '''
    ./appuploader_cli \
    -u $APPLE_ID \
    -p $APP_PASSWORD \
    -c 2 \
    -f build/app.ipa
    '''
}

CI automatically uploads after building is complete.

7. Common Issue Troubleshooting

Build Not Appearing in App Store Connect

Check:

Whether Bundle ID is consistent
Whether build number is incremented
Whether Distribution provisioning profile is used

Upload Failure

Confirm:

App-specific password is correct
Network is not blocked
IPA file is not corrupted

8. Summary of Linux Release Process

If the process is organized into a tool combination, the structure is as follows:

Phase	Tool
Certificate Generation	AppUploader
Provisioning Profile Generation	AppUploader
IPA Building	Xcode / Fastlane
Command-line Upload	AppUploader CLI
Review Submission	App Store Connect

iOS app upload process is not necessarily tied to macOS.
If the IPA file is already generated, the upload phase can be completely done via command line in Linux environments.

Reference link: https://www.appuploader.net/tutorial/zh/83/83.html

Complete Guide to Apple App Store Submission Process: From Developer Registration to Happy

ObjC_Coder — Thu, 04 Dec 2025 04:47:30 +0000

Compared to the relatively open Android market, the Apple App Store's submission process is strict and systematic.
For developers, understanding the Apple App Store submission process not only increases the approval rate but also avoids multiple rejections due to signing, privacy policy, or screenshot issues.

With the rise of cross-platform development, more developers want to complete iOS submission in Windows or Linux environments. The new Happy Submission (Appuploader) command-line tool (CLI) is designed for this purpose.

1. Basic Process of Submitting an App to the Apple App Store

The Apple App submission process consists of 6 core stages:

Stage	Content
Stage 1	Register an Apple Developer account
Stage 2	Create App ID, apply for signing certificates and provisioning profiles
Stage 3	Package and generate an IPA file
Stage 4	Configure app information in App Store Connect
Stage 5	Upload the IPA file (can use Appuploader)
Stage 6	Submit for review and release

Below, we will break down each step in detail.

2. Register an Apple Developer Account

Register on the Official Website

Visit the Apple Developer official website, log in with your Apple ID, and click "Enroll" to join the developer program.

Pay the Annual Fee

Registering as an individual or company account requires paying an annual fee of $99 (approximately 699 RMB).

Account Type	Suitable For	Features
Individual Account	Independent developers	Simple registration, fewer permissions
Company Account	Enterprise teams	Supports multi-user collaboration and role assignment

After registration, you can log in to App Store Connect.

3. Create Signing Certificates and Provisioning Profiles

The Apple system requires all submitted apps to use valid signing certificates.

Type	Function
Development Certificate	For real device debugging
Distribution Certificate	For App Store submission
Provisioning Profile	Binds certificates and App ID

Use Happy Submission (Appuploader) to Create Certificates with One Click

No Mac or Keychain required.

Advantages:

Supports Windows / Linux / macOS;
One-click generation of certificates and provisioning profiles;
Can be shared among multiple users;
Completely eliminates Mac environment dependency.

4. Package and Generate an IPA File

IPA is the final release package for iOS apps.

Framework	Packaging Method
Native iOS (Xcode)	Use Xcode → Product → Archive → Export IPA
uni-app / HBuilderX	Cloud packaging to generate IPA, no Mac required
Flutter / React Native	Command-line build + signing export
Cordova / Ionic	CLI build followed by IPA upload

If you don't have a Mac, you can use HBuilder cloud packaging + Happy Submission CLI to complete the entire process.

5. Configure App Information in App Store Connect

Click "My Apps" → "+" to create a new app; fill in the following information:

Information Item	Description
App Name	Up to 30 characters, cannot be duplicate
Bundle ID	Must match the certificate
SKU	Internal tracking number
App Category	Select an appropriate category (e.g., Education, Utilities)
Language and Region	Determine the app's language version

Also upload required content such as screenshots, app icon (1024×1024 PNG), and privacy policy link.

6. Upload IPA to the App Store

Traditional Method (Mac Users Only):

Upload via Xcode
Drag-and-drop upload via Transporter App
Command-line using altool / Fastlane (requires Xcode environment)

This makes submission difficult for non-Mac users.

Cross-Platform Solution: Happy Submission (Appuploader)

The new command-line tool supports Windows, Linux, macOS across all systems, allowing IPA upload to the App Store without a Mac.

Example command:

appuploader_cli -u ios@team.com -p xxx-xxx-xxx-xxx -c 2 -f ./release/MyApp.ipa

Parameter	Description
`-u`	Apple Developer account
`-p`	App-specific password (not login password)
`-c`	Upload channel (1=old channel, 2=new channel)
`-f`	IPA file path

Key Features:

Supports multiple systems;
Stable upload with automatic retry;
Does not carry Mac device information;
Can integrate into CI/CD automation pipelines;
Provides detailed upload logs.

7. Submit for Review and Release

After upload, return to App Store Connect:

Fill in app description, keywords, and supported device information;
Select build version → submit for review;
Wait for Apple review (typically 1–3 business days);
After approval, the app is automatically released globally on the App Store.

If rejected, App Store provides detailed reasons, and you can modify and resubmit.

8. Common Review Rejection Reasons and Suggestions

Reason	Description	Solution
Incomplete Privacy Declaration	Missing permission descriptions	Add fields like NSCameraUsageDescription in Info.plist
App Crashes	Program crashes	Fix issues through real device testing
Use of Non-Public APIs	Calling unauthorized interfaces	Replace with official APIs
Non-Compliant Screenshots	Size or display issues	Use 5.5" + 6.5" size screenshots
Duplicate App	Multiple versions of similar apps	Merge features and resubmit

9. Automated Submission Practice (Fastlane + Happy Submission CLI)

Development teams can simplify the submission process using automation tools.

# Build IPA
fastlane gym --scheme "MyApp" --output_directory "./build"

# Upload IPA
appuploader_cli -u dev@icloud.com -p xxx-xxx-xxx-xxx -c 2 -f ./build/MyApp.ipa

Can be integrated into Jenkins, GitLab CI, GitHub Actions for fully automated build and upload.

The Apple App Store submission process may seem complex, but the core logic is clear: account → certificates → packaging → upload → review → release.
Reference tutorial: https://www.applicationloader.net/tutorial/zh/1/1.html

Engineering Troubleshooting and Tool Combination for App HTTPS Packet Capture

ObjC_Coder — Fri, 28 Nov 2025 09:50:12 +0000

In mobile application debugging and online troubleshooting, app HTTPS packet capture is a fundamental skill for identifying network, authentication, and encryption issues. When encountering problems such as "unable to capture packets," "HTTPS handshake failure," or "request inconsistency with the server," engineers should troubleshoot in the order of network layer → TLS layer → application layer, and flexibly combine proxy tools, low-level packet capture, and data export methods. Below, we provide actionable processes, common commands, tool responsibilities, and an alternative packet capture solution Sniffmaster, explaining how to use tools to complete a full analysis chain with practical feature points.

I. First Define the Goal: What to Capture and Where
Before packet capture, clarify: Are you looking at the TCP three-way handshake (connectivity), TLS handshake (certificate/ALPN/Alert), or the application layer HTTP/2/1.1 request body and headers (signature, Cookie, CORS)? Prioritize capturing at the location closest to the issue occurrence (client proxy or edge/origin server capture), and record the reproduction time, device IP, and request-id to align with logs.

II. Tool Responsibilities and Combined Usage (Packet Capture Tool Matrix)

Proxy tools (Charles / Fiddler / Proxyman / mitmproxy): Used for decrypting HTTPS, breaking and modifying requests, and quickly verifying headers/body. Suitable for development environments or test devices where CA can be installed.
Low-level packet capture (tcpdump / tshark / Wireshark): Capture -s 0 pcap files at the gateway or backend for analyzing the three-way handshake, retransmissions, and TLS ClientHello/ServerHello. This provides authoritative evidence to determine if requests reach the backend.
Scriptable tools (pyshark / scapy / mitmproxy scripts): Suitable for batch statistics on TLS Alerts, automated replay, and continuous monitoring.
Alternative packet capture solution, Sniffmaster: When proxies are unavailable, apps use certificate pinning, or specific network policies block capture, it can filter traffic by App/domain and export pcap and single-packet binary files, supporting HTTPS decryption and mTLS/pinning analysis assistance, facilitating frame-by-frame comparison with backend pcap files.

III. Reproducible Troubleshooting Process (TCP → TLS → HTTP)

TCP layer: Confirm connectivity and port listening. Common commands:

nc -vz api.example.com 443
sudo tcpdump -i any host <client_ip> and port 443 -s 0 -w /tmp/cap.pcap

Check for excessive SYN, RST, or retransmissions.
\2. TLS layer: Check ClientHello (SNI, cipher), ServerHello, certificate chain, and TLS Alert:

openssl s_client -connect api.example.com:443 -servername api.example.com -showcerts

Filter for tls.handshake.type==1 and tls.alert_message in Wireshark. If incomplete chains, OCSP issues, or ALPN mismatches are found, prioritize fixing the certificate chain and stapling.
\3. Application layer: Use proxies to view HTTP/2 frames or HTTP/1.1 requests when decryption is possible, verifying signatures, timestamps, request body order, and header differences.

IV. Common Challenges and Solutions (App HTTPS Packet Capture Scenarios)

Certificate pinning / Custom TLS: Browsers can capture, but apps cannot; temporarily disable pinning in test builds or use alternative solutions that export pcap to export app traffic and compare with backend pcap files.
HTTP/3 (QUIC): QUIC is UDP-based and bypasses TCP proxies. When encountered, force fallback to TCP+HTTP/2 on the client or server for reproduction and capture.
Partial network/ISP issues: Collect affected users' ASN and region, capture edge pcap files, and compare certificate Issuers with app-exported pcap to determine if intermediate substitution or transparent proxies exist.

V. Alternative Packet Capture Process When Proxies Are Not Feasible
When proxies cannot decrypt or be configured, capture packets at the backend and simultaneously export app traffic as pcap, then analyze side-by-side in Wireshark: align timelines, compare ClientHello SNI, ServerHello and certificate chains, and check tls.alert.
Sniffmaster provides the ability to filter by App/domain, export Wireshark-compatible pcap and single-packet binary files, and supports interceptors and JavaScript scripts to modify requests/responses, significantly improving analysis efficiency in complex scenarios (use within compliance boundaries).

VI. Interception and Automated Modification (Advanced Debugging)
During development debugging, interceptors can temporarily modify request parameters or response bodies to verify fixes. Packet capture tools supporting JavaScript scripts can run custom logic at breakpoints, enabling automated test scenarios such as batch replacement of signature fields or simulating failure responses, facilitating quick identification of root causes.

Packet capture files often contain sensitive data (Tokens, personal information). In production environments, packet capture must have approval, limited time windows, and exported files should be encrypted, anonymized, and regularly destroyed. When delivering analysis conclusions, include: reproduction time window (second-level), relevant pcap files, Wireshark key frame screenshots, conclusions, and actionable repair suggestions (e.g., patch fullchain, adjust proxy/firewall, update client pin configurations).

Which IPA Encryption Tool is Good?—Multi-Tool Comparison and Implementation Recommendations for Engineering-Oriented Delivery

ObjC_Coder — Thu, 20 Nov 2025 10:34:16 +0000

For teams looking to "truly harden" their iOS applications, the challenge is not about finding the "most magical" tool, but rather selecting a tool combination suited to their delivery model and operational capabilities, and turning hardening into a reusable engineering capability. This article avoids flashy marketing and instead, from an engineering practice perspective, compares several common types of IPA encryption/obfuscation tools in terms of capabilities, pros and cons, and applicable scenarios, providing implementation recommendations and typical pipelines for direct reference by development/security/operations teams.

1. Clarifying the Problem First: Why There's No Single Answer to "Which Tool is Best"

Tool selection depends on several dimensions:

Access to Source Code: If source code is available, prioritize compile-time obfuscation (deeper protection); if not, only product-level obfuscation on the IPA can be performed.
Team's Operational Capability: Whether the team can maintain CI, KMS, approval processes, and rollback mechanisms.
Compatibility Requirements: Whether hot updates, third-party SDKs, or hybrid frameworks (Flutter/React Native/H5) are used.
Audit and Compliance: Whether mapping tables and keys require strict auditing and multi-copy backups.

Therefore, the definition of "good" should be: maximizing reverse engineering costs while preserving rollback and symbolization capabilities, under the premise of ensuring stability and maintainability.

2. Tool Categories and Pros/Cons (Engineering Perspective)

Source Code-Level Obfuscation Tools (e.g., Swift layer/compiler plugins) Pros: Can rename, encrypt strings, perturb control flow; high protection depth; controllable performance impact. Cons: Requires source code modification and compilation verification; ineffective against third-party/outsourced packages. Applicable Scenarios: Teams with self-developed, controllable source code.
Product-Level IPA Obfuscation Tools (operating on compiled IPAs) Pros: Can harden without source code, suitable for outsourced deliveries and historical versions. Can modify class names, resource names, perturb MD5, and output mapping tables. Cons: Requires strict management of whitelists and mapping tables; prone to crashes due to mis-obfuscation; requires additional handling for hot updates. Applicable Scenarios: Situations where source code is unavailable or secondary hardening of deliverables is needed. Representative Approach: Export symbols → edit mapping strategy → specify symbol file for obfuscation → re-sign and test (demonstrated below with Ipa Guard CLI).
Runtime/Dynamic Protection and Detection (anti-debugging, anti-injection, integrity checks) Pros: Adds real-time detection capabilities, can detect injection or tampering at runtime. Cons: Cannot replace static obfuscation; may hinder testing or debugging; requires switches. Applicable Scenarios: Supplementary measures against tools like Frida/LLDB.
Automation and Governance Platforms (CI, signing, KMS, crash symbolization) Pros: Turns hardening into a delivery capability, manages mapping tables and approvals, and supports rollback and symbolization. Cons: Requires operational investment and institutional setup. Applicable Scenarios: Medium to large teams or products with high compliance requirements (e.g., finance, government).

3. The Role of Ipa Guard (Product Hardening) in the Engineering Pipeline and a Practical Introduction

If your delivery form is "only receiving the IPA," product hardening tools are essential. Taking Ipa Guard's command-line mode as an example (engineering-friendly), the typical process is as follows:

Export Obfuscatable Symbols

ipaguard_cli parse game.ipa -o sym.json

After export, sym.json contains fields like confuse, refactorName, fileReferences for each symbol, facilitating decisions on which symbols can be modified and which need to be retained.

Edit the Symbol File (Critical)

Set confuse:false for non-obfuscatable bridging/Storyboard/hot-fix interfaces;
Modify refactorName (keep length unchanged, avoid duplicates);
Note references to H5/JS files in fileReferences, replace strings or exclude as necessary.

Obfuscate the IPA with the Specified Symbol File

ipaguard_cli protect game.ipa -c sym.json --email you@addr.com --image --js -o confused.ipa

Parameters like --image (modify image MD5) and --js (obfuscate JS) are useful in hybrid app scenarios.

Re-sign and Test on Real Devices

kxsign sign confused.ipa -c cert.p12 -p pwd -m dev.mobileprovision -z out.ipa -i

Always perform regression testing on all critical paths (launch, login, payment, hot updates) on real devices using development certificates before release.

Archive and Govern Mapping Tables Encrypt and upload the final sym.json and generated mapping tables to KMS, bind to build numbers, and require approval and audit trails for any access.

Engineering Tip: Encapsulate the above steps into CI (Jenkins/GitLab CI + Fastlane) to turn "hardening" into a capability triggered by a single commit, while retaining rollback paths.

4. How to Choose the "Most Suitable" Tool—Decision Checklist

When evaluating specific tools, scoring against the following checklist provides more practical value:

Supports hardening without source code (Mandatory/Bonus)
Can export and specify symbol files (Facilitates whitelisting and fine-grained control)
Outputs mapping tables and supports encrypted archiving (Necessary for audit and symbolization)
Provides options for perturbing resources like images/JS (Hybrid app friendly)
Supports command-line and easy CI integration (Essential for engineering)
Has good documentation on rollback and testing recommendations (Reduces release risks)
Can the team bear the governance costs (KMS, approvals, drills) (Organizational capability)

After evaluating each item, select tools based on your most valued criteria and prepare supporting processes (whitelist maintenance, canary releases, emergency rollback).

5. Practical Recommendations (Key Points to Avoid Pitfalls)

Strictly version whitelists and include them in the source code repository; any changes must be assigned responsibility and include regression test cases.
Treat mapping tables as keys, using KMS/HSM for encrypted storage and approval-based decryption processes.
Perform full-path regression testing on real devices after obfuscation (launch, push notifications, payments, hot updates, third-party SDKs).
Canary releases and gating: Start with 1–5% canary, monitor crash rates and key business metrics, and automatically roll back if thresholds are exceeded.
Regular dynamic validation: Security teams should periodically conduct smoke tests and reverse engineering sampling using Frida, Hopper, etc., as a basis for iteration.

6. Conclusion

"Which IPA encryption tool is good?" cannot be answered by a marketing slogan. A more effective approach is to select tool categories based on delivery model and team capabilities (whether source code can be modified, whether CI and KMS governance can be implemented, whether hot fixes exist, etc.), and integrate tool capabilities (such as Ipa Guard's symbol export/specification, resource perturbation, CLI integration) into a rigorous release pipeline.
The ultimate goal is not to achieve 100% irreversibility, but to raise the cost of cracking, tampering, and repackaging to commercially unviable levels, while ensuring the business remains maintainable, rollback-capable, and auditable.