This article details practical HarmonyOS compilation optimizations — unified lockfiles, boosted extraction, disabled JS intermediate output, and skipped lib compression — that reduced full builds from 24 to 14 minutes and incremental builds from 4 to 2.5 minutes on a 3-million-line ArkTS codebase.
Through an AI ID photo tool case study, this article demonstrates HarmonyOS concurrency patterns: TaskPool for short preprocessing, Worker for long AI inference, TaskGroup for parallel batch generation, SequenceRunner for dependent tasks, SharedArrayBuffer for zero-copy sharing, Sendable for thread-safe singletons, and producer-consumer queues for real-time previews, with before/after performance metrics.
This tutorial demonstrates how to implement face detection in HarmonyOS apps using Core Vision Kit, covering face position, landmarks, orientation, confidence scores, with complete ArkTS code examples, constraints, error handling, and privacy considerations for offline on-device processing.
The article demonstrates how CodeGenie uses MCP to connect external knowledge bases and Rules to enforce ArkTS standards, enabling AI to detect deprecated APIs, retrieve official docs, and generate compliant HarmonyOS code through a four-step workflow.
This article analyzes HarmonyOS security architecture, detailing its Level II national certification, the six-layer StarShield defense model covering hardware TEE, microkernel isolation, dynamic permissions, distributed security, and a government migration case study with measurable security improvements.
This guide walks you through the complete HarmonyOS mobile development workflow—from understanding the platform’s layered architecture and core ArkTS/ArkUI concepts, to setting up DevEco Studio, creating a Hello World app, managing UI, state, routing, data, and finally packaging and publishing the app.
This article details implementing a high-performance line art extraction feature in HarmonyOS using ArkTS, covering grayscale conversion, differential edge detection, efficient pixel buffer access, sketch and comic style rendering, and time-sliced chunk processing to prevent UI freezes on large images.
This article applies two‑sided market theory and game‑theoretic modeling to examine HarmonyOS’s ecosystem growth, Huawei’s strategic levers, and three possible long‑term equilibrium scenarios, supported by recent market data and ecosystem metrics.
This case study details how HarmonyOS 6 distributed features — soft bus, atomic services, distributed data management, and task scheduling — were used to create a unified elderly care platform connecting seniors, families, caregivers, and doctors across devices and locations, with code examples and lessons on elderly-friendly design.
Hisense Aijia's smart home app migrated to HarmonyOS using ArkTS, integrating Scan Kit for robust QR scanning, Cast Engine for low-latency screen casting, responsive layouts for foldable devices, and Account Kit for simplified OAuth login, cutting launch time to 2 seconds with HarmonyOS team support.
This tutorial walks through the complete lifecycle of a HarmonyOS atomic service — from UI implementation with Navigation, Grid, LazyForEach, and @Builder, to AI-powered text-to-speech, and finally manual code signing, packaging, and release via AppGallery Connect.
A HarmonyOS developer shares the full technical practice of building a children's flag-learning app, covering technology selection (Core Speech Kit, ArkTS, Stage model), core feature implementation (offline voice synthesis/recognition, canvas drawing, puzzle game), global state management with AppStorage, performance optimizations for 200+ flags, and future plans for multi-device collaboration and AI integration.
This article details three core aspects of building cinema-grade long video apps with HarmonyOS AVPlayer: smooth gesture-based brightness and orientation controls, stable playback via audio focus management and seamless foreground/background resume, and full functionality including picture-in-picture and background audio playback.
A HarmonyOS developer shares the technical journey of building 'Shengqu Guoqitong', a children's flag learning app, detailing why HarmonyOS was chosen over Android, Flutter, and React Native, and how Core Speech Kit's offline TTS/ASR and ArkTS declarative UI enabled efficient development of voice-driven, interactive educational features.
A HarmonyOS developer shares complete technical implementation details and competition strategies from building 'Koko Picture Editor' for the 2025 HarmonyOS Developer Incentive Program, covering ArkUI architecture, ImageKit compression, Canvas cropping, color matrix filters, componentSnapshot watermarks, and performance optimization patterns.
A junior developer shares the full lifecycle of creating "Gege Check-in," a HarmonyOS habit-tracking app that won Huawei's 2025 developer incentive, detailing architecture, AI-assisted coding, DevEco Studio workflows, calendar component integration, privacy-first local storage, and the monthly active user targets required to claim the reward.
This guide teaches WeChat developers how to ensure Mini Programs and web apps run correctly across Android, HarmonyOS, iOS, Windows, and Mac by implementing platform detection via systemInfo and User-Agent parsing, with complete code examples for each scenario.
AndroidCross-Platform CompatibilityFrontend Development
A Flutter developer details the complete HarmonyOS adaptation of the Baby Lagou children's app, covering library migration, multi-screen UI adaptation, strict permission handling, performance optimization, and future plans for desktop widgets and atomic components.
This article details integrating Flutter with HarmonyOS native image APIs (ImageSource, PixelMap, ImagePacker) using a bridge-adapter architecture, covering cross-platform design principles, caching strategies, photo_view-based viewer and gallery implementations, performance optimizations leveraging HarmonyOS distributed capabilities and ArkCompiler, and best practices for modular design, error handling, and compression achieving 40% faster loading and 30% memory reduction.
The 2025 Bugly HarmonyOS Quality Report analyzes system version adoption, device distribution, crash and freeze rates across industries, identifies top stability issues such as memory leaks and main‑thread blocking, and offers concrete optimization recommendations for developers seeking better app performance.
Surgeon Ding Ce, frustrated by cumbersome medical calculations, leveraged Tencent Cloud’s AI code assistant CodeBuddy to create a customizable WeChat mini‑program for prostate volume, body surface area, and fetal weight formulas, expanded it to a HarmonyOS app, and shared insights on AI‑driven development, data handling, and cross‑platform deployment.
Hooop leverages HarmonyOS's on‑device AI and custom vision algorithms to provide real‑time, offline basketball training by detecting shots, analyzing trajectories, automatically clipping scoring clips, and tracking performance metrics without an internet connection.
This article explains how to enable and configure code obfuscation in HarmonyOS applications using DevEco Studio, covering compiler options, rule files, HAR building modes, debugging obfuscated stack traces, and third-party hardening requirements for app security.
Learn how to monitor and analyze crashes in HarmonyOS Next by handling native C/C++ signals and ArkTS/JavaScript errors, using hiAppEvent watchers, simulating crash scenarios, and leveraging build artifacts such as source maps, debug .so files, and nameCache for precise stack trace reconstruction and improved app stability.
This case study details how the Chang Xiang Si poetry app overcame HarmonyOS SDK compatibility issues by developing custom Flutter plugins, leveraged HarmonyOS's 'one development, multi-device' capability to achieve 90% code reuse across phones, foldables, and tablets, integrated Huawei Account one-click login, and explores future AI voice reading and eye-tracking interactions.
MYKMP is Alipay’s native cross‑platform solution built on Kotlin Multiplatform and Compose, enabling a single codebase to run on Android, iOS and HarmonyOS, with detailed architecture, engineering practices, GC optimizations, and integration guidelines presented for billion‑scale applications.
This guide details how to secure HarmonyOS app network connections by configuring trusted CA certificates for server validation, disabling user-installed CAs to prevent MITM attacks, and implementing SSL pinning for high-security applications like banking.
This tutorial demonstrates how to implement external subtitles (SRT/VTT) in HarmonyOS using AVPlayer's subtitleUpdate event, covering subtitle file loading via addSubtitleFromFd, callback registration, synchronization, and limitations like pre-playback-only subtitle setting.
CodeGenie, HarmonyOS's AI coding assistant, now generates compilable ArkTS UI code from screenshots in ~2 minutes using a parse-then-generate architecture with VLM element detection and LLM agents, achieving 85%+ parsing accuracy, near 100% preview rate, and 40% adoption across food, travel, shopping, news, and education apps.
This guide covers HarmonyOS AVScreenCapture for screen recording, detailing features like hardware-accelerated H.264/H.265 encoding, dual audio tracks, full-screen and region capture, plus complete ArkTS and C++ NDK code examples with configuration parameters and development workflows.
This article introduces HarmonyOS NEXT's pure, fast, and minimal design, its development base with DevEco Studio and ArkTS, the compilation artifacts (HAR, HSP, HAP), the system‑level open capability map, and the ARMS RUM SDK's architecture, session management, and three unobtrusive data‑collection schemes for performance monitoring.
Huawei's new Mate XTs triple-fold device introduces three form factors, free multi-window mode, and stylus support; the official best-practices guide details responsive layout adaptation, window-mode handling, and Pen Kit integration for developers.
CodeGenie leverages a Huawei-curated HarmonyOS corpus to provide context-aware code completion with three trigger modes, fine-grained acceptance controls, cross-module dependency resolution, and adaptive style learning, enabling developers to generate accurate ArkTS code while maintaining full control over suggestions.
This article explains how Bugly leverages the open‑source Xlog kernel to overcome HarmonyOS native logging limitations, offering a comprehensive, cross‑platform log engine, diagnostic fetch module, and practical scenarios that boost issue diagnosis, dynamic log control, privacy, and developer productivity.
This article explains how to implement dialog routing in HarmonyOS using the Navigation component's Dialog mode, contrasting Standard and Dialog NavDestination modes, and provides a complete shopping cart example with ArkTS code demonstrating persistent, non-blocking dialogs with transition effects.
The August 30, 2025 “Youth Coding·HarmonyOS Summer” event in Xiamen featured Jia Ding’s deep dive into Sohu News’ HarmonyOS meta‑service, revealing three key technical breakthroughs—dynamic list loading, MVVM‑based detail pages, and skeleton‑screen stability—while outlining future ecosystem integrations such as Push Kit and RAG.
This tutorial details how to implement cross-package page navigation in HarmonyOS multi-module apps using the Navigation router, covering router_map.json configuration, builder functions, compilation order, dependency setup, and code examples for HAP, HSP, and HAR modules.
This guide details how to enable and configure the ArkGuard source code obfuscation tool in HarmonyOS projects, covering build-profile.json setup, default rules, obfuscation and retention options, release compilation requirements, and the ObfuscationHelper utility for automated whitelist generation.
This guide details how to implement audio and video capture using Camera Kit, AudioCapturer, and OHAudio, as well as playback with AVPlayer in HarmonyOS apps, covering permission setup, device selection, profile configuration, session creation, resource management, and supported formats.
Huawei's CodeGenie Smart Tuning in DevEco Studio 6.0.0 Beta uses 20+ atomic profiling tools and a curated knowledge base to let developers diagnose cold-start delays, frame drops, and memory leaks via natural-language queries, cutting manual log analysis by half.
This guide covers HarmonyOS AVRecorder's supported formats (AAC/MP3, H.264/H.265, MP4/M4A), provides step-by-step ArkTS and C++ NDK code examples for recording workflow, and outlines key development practices including state machine rules, resource cleanup, and permission handling.
Zhihu partnered with Huawei to develop and open‑source an Appium driver for HarmonyOS, enabling unified, efficient automated testing across iOS, Android, and HarmonyOS and energizing the open‑source HarmonyOS ecosystem for developers and enterprises.
The article summarizes Tencent's announcement and a podcast where the WeChat HarmonyOS team discusses why the app had to be rebuilt from scratch, the technical hurdles of Huawei's fast‑changing OS, and how the teams collaborate to overcome legacy code and platform differences.
This article walks through implementing sophisticated like-button animations using HarmonyOS ArkUI, compares the approach with Android's animation framework, explains key ArkUI APIs like animateTo, and provides detailed Kotlin and TypeScript code for property, Bézier path, and lifecycle management of dynamic UI effects.
This article explains how HarmonyOS developers can reuse native C/C++ file upload code across iOS, Android, and HarmonyOS by employing Node‑API thread‑safe functions to asynchronously report upload progress, errors, and completion from native threads back to the ArkTS UI thread.
This tutorial walks you through the complete process of adding push notification support to a HarmonyOS app, covering environment setup, certificate generation, profile configuration, client ID setup, permission requests, token retrieval, handling cold and hot starts, and the required server payload format.
The article details the open‑source release of Taro on HarmonyOS, explaining its architectural evolution, performance optimizations, multi‑platform development workflow, and real‑world results from JD’s HarmonyOS app, while outlining future roadmap and ecosystem expansion.
This article details the evolution, architecture, performance optimizations, and open‑source progress of Taro on HarmonyOS, illustrating how a unified front‑end framework enables efficient multi‑platform development and delivers native‑level performance for complex applications.
This article details the open‑source Taro on HarmonyOS framework, covering its evolution, technical architecture, performance optimizations, and cross‑platform development benefits that enable developers to write once and deploy across HarmonyOS, web, and mini‑program ecosystems.
Tencent's game esports live streaming SDK adapted to HarmonyOS using the Kuikly cross-platform framework, achieving 100% business code reuse across Android, iOS, and HarmonyOS while supporting multiple game apps, saving over 50% development effort through modular architecture, Schema-based feature routing, and atomic infrastructure design.
With the launch of HarmonyOS Next, the game live‑streaming SDK team leveraged the Kuikly cross‑platform framework to adapt their Android, iOS and web code to HarmonyOS, achieving 100% cross‑platform reuse across three platforms, cutting over 50% of development effort while boosting performance, stability and modularity.
This article walks through implementing sophisticated like-button animations for a news client on HarmonyOS using ArkUI, compares the approach with Android's animation framework, explains key ArkUI APIs like animateTo, and provides detailed Kotlin and TypeScript code for property and Bezier curve animations.
This article explains how to use Node‑API’s thread‑safe functions to asynchronously relay native file upload progress, completion, and error callbacks from native C/C++ threads to ArkTS JavaScript on HarmonyOS, covering API definitions, event‑loop integration, and practical implementation details with code examples.
At the 2025 Huawei Developer Conference, JD’s mini‑program team demonstrated how integrating the Cangjie language into HarmonyOS mini‑programs can halve JS API execution time, reduce main‑thread load, and improve cold‑start performance by up to 20% across high‑frequency scenarios.
This article shares the JD developer’s experience at the 2025 Huawei Developer Conference, detailing how the Cangjie language and a dual‑thread architecture were used to analyze and optimize high‑frequency JS API calls in JD mini‑programs on HarmonyOS, achieving up to 50% faster execution and a 20% reduction in cold‑start time.
This article details a high‑performance, cross‑platform HarmonyOS mini‑program development practice that analyzes architecture, identifies JS API bottlenecks, demonstrates a step‑by‑step API call breakdown, and shows how the Cangjie language reduces getSystemInfo latency by over 50% while improving overall startup speed.
This article details JD's collaboration with Huawei at the 2025 Developer Conference, showcasing how the Cangjie language was used to analyze and optimize high‑frequency JS API calls in HarmonyOS mini‑programs, resulting in significant reductions in main‑thread load, faster cold‑start times, and a roadmap for broader cross‑platform performance improvements.
This article shares the author's experience at the 2025 Huawei Developer Conference, detailing how the JD.com mini-program team leveraged the Cangjie language to analyze and optimize API calls, reduce main-thread load, and achieve up to 50% faster getSystemInfo execution on HarmonyOS.
At the 2025 Huawei Developer Conference, JD’s team demonstrated how integrating the Cangjie language into HarmonyOS mini‑programs can halve API execution time, reduce main‑thread load, and improve cold‑start performance by over 20%, offering a high‑performance, cross‑platform development solution.
The article explains how HarmonyOS’s microkernel differs from Linux’s monolithic design, why it can still run Linux binaries through POSIX, ABI shim, and HDF layers, and what architectural choices enable high‑performance IPC, distributed operation, and deterministic scheduling.
ovCompose is a newly released cross‑platform framework that fully supports HarmonyOS, Android, and iOS, leveraging Kotlin Multiplatform and the native‑focused KuiklyBase to deliver native‑level performance, unified UI rendering, advanced memory and GC optimizations, and a rich component ecosystem, with open‑source repositories for community collaboration.
This article introduces ovCompose and KuiklyBase, Tencent Video's cross‑platform development framework built on Compose Multiplatform, explains the background, key advantages, implementation details, performance optimizations for Android, iOS and HarmonyOS, provides repository information and outlines future plans.
This article introduces Taro's open‑source Harmony C‑API solution, detailing its architecture, rich component and CSS support, performance optimizations, and step‑by‑step installation guide that enable developers to build native‑grade Harmony OS applications using familiar web technologies.
Tencent's Kuikly cross-platform framework open-sources HarmonyOS support and Compose DSL beta, achieving native-level performance via Kotlin Multiplatform and CAPI rendering, with detailed engineering trade-offs on ArkUI mapping, text layout reuse, and Kotlin Native optimization.
Kuikly, Tencent’s Kotlin Multiplatform‑based cross‑platform framework, has been extended to support HarmonyOS with native performance, offering Compose DSL, high‑performance rendering, Kotlin Native adaptation, debugging tools, and detailed optimization strategies that achieve near‑native speed and dynamic UI capabilities across Android, iOS, Web, and mini‑programs.
The article introduces Taro's open-source C-API version for HarmonyOS, detailing its architecture, rich component and CSS support, high-performance rendering, hybrid native integration, and step‑by‑step installation guide, positioning it as a leading frontend solution for cross‑platform development.
Taro, an open‑source cross‑platform solution from JD, now supports pure HarmonyOS through its C‑API version, enabling developers to build H5, mini‑programs, RN and native Harmony apps using familiar web technologies, offering high‑performance rendering, extensive component support, and seamless migration of existing Taro projects.
The article introduces Taro on Harmony's C‑API version, detailing its evolution, open‑source release, three‑layer architecture, rich component and CSS support, high‑performance rendering, installation steps, and future roadmap, positioning it as a leading framework for developing native‑like HarmonyOS applications.
Although HarmonyOS uses a microkernel rather than a monolithic Linux kernel, it achieves Linux compatibility and container emulation through a combination of POSIX support, an ABI shim layer, high‑performance IPC/RPC mechanisms, and the Hardware Driver Framework, which together translate Linux calls into microkernel services.
Taro For Harmony’s open‑source C‑API release upgrades the framework to fully support pure HarmonyOS, delivering richer style adaptation, higher rendering performance, comprehensive component coverage, and a web‑style development experience that rivals native ArkTS apps.
Tencent open-sources Kuikly, a Kotlin Multiplatform framework used in 15+ apps with billion daily PVs, achieving native performance via two-tree rendering and declarative DSL while supporting dynamic updates across Android, iOS, HarmonyOS, Web, and mini-programs.
This article details JD's Taro framework adaptation for HarmonyOS, tracing its evolution from ArkTS-based to C-API-driven single- and multi-threaded architectures, highlighting performance gains, feature support, and future enhancements for native-like HarmonyOS app development.
Taro, an open‑source cross‑platform framework initiated by JD, now offers a HarmonyOS solution that evolved from an ArkTS bridge to a high‑performance C‑API based multi‑threaded architecture, delivering native‑level rendering, rich component support, and dynamic updates for mobile developers.
The Taro‑on‑Harmony solution lets developers write a single React‑based codebase that compiles to native HarmonyOS apps with C‑API‑driven rendering, offering both single‑thread and multi‑thread architectures, full component and CSS support, high‑performance UI, and upcoming tooling, as demonstrated by JD.com’s S‑level certified shopping app.
Facing the dual challenges of migrating millions of lines of enterprise code to HarmonyOS and maintaining stability amid rapidly evolving APIs, the WeChat team introduced the DataList framework, employing three entropy‑reduction mechanisms—structured, dynamic, and cognitive—to achieve data‑driven UI, cross‑platform reuse, and decoupled business logic.
The article explains HarmonyOS’s Text component—showing basic usage, method‑chained styling, and mixed Span/ImageSpan content—then details an emoji workflow using a JSON mapping and regex to split text into model arrays, and demonstrates RichEditor with a custom keyboard for inserting and managing emoji spans.
This guide walks you through DevEco Studio 5.0.1's refactoring capabilities—renaming, safe deletion, and extracting methods, constants, interfaces, and variables—to streamline HarmonyOS app code, improve structure, and boost development efficiency.
This guide demonstrates how to use the ohos.request module in HarmonyOS NEXT API 12 to upload a local file through a custom proxy by creating a proxy agent, reading the file, configuring request options, and handling responses and errors.
This article details JD's self‑built HarmonyOS image library (DImage), covering its background, research on existing solutions, C++‑based cross‑platform architecture, core modules, performance‑focused pipeline, monitoring and recovery mechanisms, and future optimization directions, all aimed at high‑performance image handling for the JD app on HarmonyOS.
This article explores how Taro leverages C++ and the Harmony C‑API to build a high‑performance, cross‑language event system that unifies event handling across C++, ArkTS, and JavaScript, detailing architecture, event center implementation, node event processing, and future enhancements.
This article explains the HarmonyOS NEXT Background Tasks Kit, detailing its four task types—Transient, Continuous, Deferred, and Agent‑powered Reminder—along with their characteristics, typical use cases, and complete ArkTS code examples for each scenario.
This article introduces JD’s self‑developed HarmonyOS image library, explaining the background, research on existing solutions, the decision to build a C++‑based cross‑platform library, its modular architecture, performance optimizations, quality assurance mechanisms, and future development plans.
This article explains how the ExtendedText component adds custom text‑overflow effects, including start, middle, end and auto modes, supports highlighted keywords with keep‑visible spans, and improves performance by replacing binary search with range estimation across Flutter, Android, iOS, Web and HarmonyOS platforms.
This guide explains the background of HarmonyOS NEXT, introduces Alibaba Cloud ARMS Real User Monitoring SDK for native HarmonyOS apps, details its page, resource, exception, and custom data collection features, and provides step‑by‑step integration instructions with code examples.
This edition of the ZhuanZhuan Frontend Weekly presents a curated selection of recent technical articles covering React 19 release, HarmonyOS adaptation in a travel app, the Vision animation platform at Kuaishou, migration from Electron to Tauri, and WebAssembly‑enhanced WebCodecs for high‑performance video frame extraction.
This article explains how Taro converts standard W3C CSS into HarmonyOS ArkUI styles, addressing unit and layout differences, using a Rust‑based LightningCSS plugin and the Yoga layout engine, and detailing the full style initialization, matching, application, and update workflow for cross‑platform React development.
This article explains how Taro leverages C++ and the HarmonyOS C‑API to build a high‑performance, multi‑language event system that bridges ArkTS, JavaScript and native components, detailing architecture considerations, implementation details, and future directions for improving cross‑language event handling.
This article details Ctrip's migration of its large‑scale React Native (RN) codebase to HarmonyOS using the custom CRN framework, covering technology selection, version upgrades, native component re‑implementation, component C‑ization, performance optimizations such as pre‑loading, TurboModule worker threads, instruction pruning, and future roadmap.
This article introduces Cangjie, a lightweight, high‑performance programming language for HarmonyOS, detailing its core advantages, rapid environment configuration, distinctive language features such as flow expressions, lightweight threads, extensions, synchronization primitives, and demonstrates seamless interoperation with ArkTS, concluding with future development outlook.
Cangjie is a general-purpose programming language designed for efficient application development, offering lightweight runtime, user threads, and seamless ArkTS interoperability.
This article details JD's custom HarmonyOS image library built with C++ and Taro, covering its background, technical design, core modules, performance monitoring, optimization techniques, quality assurance mechanisms, and future development plans to achieve high‑performance cross‑platform image loading for mobile applications.
This article details JD's development of a modular, C++‑based image library for HarmonyOS, explaining the shortcomings of native components, the design of a cross‑platform architecture, core modules, performance pipelines, monitoring, and future optimization plans.
This guide explains two primary techniques—using the Navigation component and the router object—to pass parameters between pages in HarmonyOS NEXT, providing step‑by‑step code examples, practical scenarios, and tips for choosing the appropriate method.