Technical Summary: Porting Declarative UI to HarmonyOS via ArkTrans

Problem Statement

The emergence of HarmonyOS has created a critical demand for migrating software from established platforms like Android and iOS. However, the landscape of User Interface (UI) development has shifted from imperative paradigms (e.g., XML, UIKit) to declarative frameworks: Kotlin Jetpack Compose (KJC) for Android, SwiftUI for iOS, and ArkUI for HarmonyOS. Existing automatic program translation approaches are ill-suited for this task because they primarily target backend logic or legacy imperative UIs.

Directly applying Large Language Models (LLMs) to translate KJC/SwiftUI to ArkUI faces two salient challenges:

1. Programming Language (PL) Unfamiliarity: ArkUI is a relatively new framework (officially launched in 2023) with a scarce corpus on code hosting platforms compared to mature PLs. Consequently, state-of-the-art (SOTA) LLMs lack sufficient training data to master ArkUI's specific syntax and programming paradigm.
2. Severe Syntactic Chaos: Due to this unfamiliarity, LLMs tend to copy source PL syntax or mix source and target syntaxes during translation. Empirical studies indicate that 40% of direct prompting failures stem from syntactic errors, and even with guidance, over 50% of syntactic errors remain unresolved.

Methodology: ArkTrans

To address these challenges, the authors propose ArkTrans, a heuristic-guided LLM approach for automatic UI migration. ArkTrans operates through a four-stage pipeline:

1. Metadata Extraction (ME)

The system parses source UI files (KJC or SwiftUI) into an Abstract Syntax Tree (AST) to hierarchically extract metadata. It filters out non-UI logic (e.g., lifecycle hooks, property wrappers) and constructs a structural UI tree. Each node in this tree is a tuple containing the component type, properties (key-value pairs), modifiers (chained calls), and children. This process isolates the pure UI declaration from boilerplate code.

2. Skeleton Construction (SC)

Using the extracted UI tree, ArkTrans synthesizes a deterministic ArkUI skeleton. This step performs cross-PL component mapping using a predefined dictionary to translate known components, properties, and modifiers into their ArkUI counterparts. Unknown elements are preserved as comments. The result is a partial ArkUI code structure that defines the UI topology and layout constraints, ensuring the maximum preservation of metadata that cannot be heuristically migrated.

3. LLM-driven Translation (LT)

An LLM is invoked to populate the generated skeleton with executable code. The prompting strategy includes:

• System Role & Context: Providing the ArkUI skeleton and extracted color constants.
• One-Shot Learning: Supplying a demonstration example that translates a similar skeleton into ArkUI code. This example covers common syntactic pitfalls (property assignment, modifier chaining, layout expansion, state management) to guide the LLM's in-context learning.

4. Post-Fixing (PF)

Recognizing that LLMs still produce syntactic errors, ArkTrans applies a rule-based post-fixing engine. This stage executes deterministic transformations based on empirically revealed error patterns:

• Constant Inlining (CI): Resolves unresolved references to external design tokens (e.g., color classes) by inlining literal values and removing unused class definitions.
• Lexical Rectification (LR): Replaces source PL-specific lexical tokens (e.g., toInt() in Kotlin) with their ArkUI equivalents (e.g., Number() in ArkTS).
• Layout Property Rectification (LPR): Expands directional shorthand properties (e.g., padding(horizontal)) into explicit ArkUI properties (e.g., left, right).
• Structural Integrity Validation (SIV): Validates component placement rules (e.g., ensuring Blank components are only inside linear layouts like Row or Column) and repairs unbalanced delimiters.

Key Contributions

1. Benchmark Construction: The authors constructed the first file-level parallel UI migration benchmark consisting of 100 samples across eight application scenarios (e.g., E-commerce, Social Media). These samples include equivalent KJC and SwiftUI code files manually verified for functional and visual consistency.
2. Empirical Study: A comprehensive analysis of KJC/SwiftUI-to-ArkUI translation failures, identifying that SOTA LLMs fail completely without guidance and that syntactic errors persist even with skeleton-based guidance.
3. ArkTrans Framework: The proposal of a skeleton-guided and post-fixing-enhanced translation framework specifically designed for declarative UI migration.
4. Progressive Evaluation System: The establishment of a multi-dimensional evaluation system measuring both Code Executability (Compilation Success Rate) and Visual Fidelity (Global metrics like CLIP/Color Histogram and Local metrics like Position, Size, Color, and Text Integrity).

Experimental Results

The authors evaluated ArkTrans using SOTA LLMs (GPT-5.2, DeepSeek-V3.2, Kimi-K2-Turbo, GLM-5) against baselines of Direct Prompting and One-Shot Prompting.

• Compilation Success Rate (CSR): Direct and One-Shot prompting failed to generate a single compilable file (0.00% CSR). In contrast, ArkTrans achieved a CSR of 53.33%–90.67%. Specifically, KJC-to-ArkUI translation reached 90.67%, while SwiftUI-to-ArkUI reached 53.33%.
• Visual Fidelity: ArkTrans significantly outperformed baselines in visual consistency. For KJC-to-ArkUI, it achieved a CLIP Similarity of 78.89% and a Color Histogram Similarity of 56.01%. Local metrics (Position, Size, Color, Text) also showed high fidelity, with Text Integrity reaching 82.50%.
• Ablation Studies:
  • The ArkUI Skeleton was the primary driver for breaking the 0% CSR barrier.
  • One-Shot examples significantly improved performance, particularly in visual fidelity.
  • Post-Fixing provided the most substantial boost in executability, resolving the remaining syntactic errors that prevented compilation.
  • Color metadata in prompts was found indispensable for maintaining visual integrity.
• Generalizability: ArkTrans demonstrated effectiveness across diverse LLM architectures, consistently improving performance regardless of the underlying model, though performance varied slightly based on the model's inherent reasoning capabilities.

Significance and Claims

The paper claims that ArkTrans is the first approach to successfully address UI migration as a direct code translation problem between modern declarative frameworks. The authors emphasize that:

• Structured Guidance is Critical: Simple prompting is insufficient for declarative UI migration due to the "syntax gap" and paradigm shifts. The combination of skeleton construction and rule-based post-fixing is necessary to bridge this gap.
• Ecosystem Enrichment: ArkTrans serves as a powerful tool for rapidly enriching the HarmonyOS software ecosystem by automating the porting of existing high-quality UIs from Android and iOS.
• Modest Scope: The authors acknowledge that while the benchmark covers representative scenarios, it may not cover all industrial-scale edge cases. They also note that SwiftUI-to-ArkUI migration remains more challenging than KJC-to-ArkUI due to stricter type-checking and scoping rules in ArkTS.

The work concludes that ArkTrans effectively mitigates the zero-success barrier observed in unguided LLM translation, offering a viable pathway for declarative UI migration.