DEV Community: Way Lau

The First HarmonyOS 6 AI Development Tutorial Is Now Available Online!

Way Lau — Mon, 20 Oct 2025 00:24:01 +0000

HarmonyOS officially announces: On October 22nd at 14:30, the special launch of Harmony Operating System 6 is coming!

In fact, as early as September 25th, 2025, DevEco Studio 6.0.0 Release (6.0.0.858) was officially released, marking that the complete set of HarmonyOS development tools (including SDK and the development tool DevEco Studio) centered around API 20 have reached the Release state and are now officially available. Developers can now engage in HarmonyOS 6 application development based on these Release-state development tools.

At this moment, coinciding with the official release of HarmonyOS 6, Lao Wei (a presumed instructor or developer) has created a video tutorial titled "HarmonyOS 6 AI Application Development," aiming to help you master the complete architectural capabilities for developing native HarmonyOS AI applications from scratch, through testing, to listing on the app store.

This course, with "AI Scanning Application" as the main project thread, is a practical course designed to cultivate HarmonyOS AI development engineers. Utilizing HarmonyOS's native AI capabilities, the course demonstrates how to build a complete HarmonyOS AI application from scratch, showcasing the entire lifecycle of AI application development, testing, and listing. It combines the enhancement of development thinking and technology in a comprehensive and progressive manner, deeply integrating technology and business. Additionally, the course keeps pace with technological trends, emphasizing the introduction of new technologies and frameworks in HarmonyOS 6, such as AI-assisted programming, ArkTS language, ArkUI, network programming, security management, natural language understanding services, voice-based AI services, visual AI services, and more, integrating them with application development to ensure the timeliness of the knowledge learned by students. This empowers HarmonyOS practitioners with stronger workplace adaptability and competitiveness, and assists computer science students in finding suitable jobs ahead of their peers.

Interested students can access the course directly via the link https://edu.51cto.com/course/39601.html or search for the keywords "HarmonyOS 6 AI Application Development" on 51CTO Classroom to find the course.

Fresh graduates aiming to stand out in competitions/graduation projects/job searches
Developers seeking to master both HarmonyOS and AI skills
Architects looking to enhance their workplace competitiveness and seek technological breakthroughs

Through this course, students can gain project experience with the "AI Scanning Application" from scratch, cultivating the technical and thinking abilities of a HarmonyOS engineer. By completing the course, students can acquire the complete architectural capabilities for developing native HarmonyOS AI applications from scratch to listing. Simultaneously, they can learn the application of new technologies such as AI-assisted programming, ArkTS language, ArkUI, network programming, security management, natural language understanding services, voice-based AI services, and visual AI services, enhancing their overall market competitiveness.

What you will learn:

Master common technologies used in HarmonyOS applications;
Acquire AI application development skills;
Explore the mysteries of pure-blood HarmonyOS native development;
Integrate technology with AI business;
Keep up with forward-looking technological trends;
Enhance core workplace competitiveness.

For more details, see Bilibili: https://www.bilibili.com/video/BV1wCWxzpEsq/

This article is also synchronized at: https://waylau.com/the-first-harmonyos-6-ai-tutorial-is-now-available-online/

Source code can be found in the open-source and free tutorials:

"Learn HarmonyOS Development with Lao Wei" (https://github.com/waylau/harmonyos-tutorial)
"Learn AI Large Model Development with Lao Wei" (https://github.com/waylau/ai-large-model-tutorial/)
"Learn Cangjie Programming Language Development with Lao Wei" (https://github.com/waylau/cangjie-programming-language-tutorial)

参考引用
本文同步至：https://waylau.com/the-first-harmonyos-6-ai-tutorial-is-now-available-online/
源码见《跟老卫学HarmonyOS开发》开源免费教程， https://github.com/waylau/harmonyos-tutorial
《跟老卫学AI大模型开发》开源免费教程， https://github.com/waylau/ai-large-model-tutorial/
《跟老卫学仓颉编程语言开发》开源免费教程， https://github.com/waylau/cangjie-programming-language-tutorial
《鸿蒙HarmonyOS手机应用开发实战》（清华大学出版社）
《鸿蒙HarmonyOS应用开发入门》（清华大学出版社）
“鸿蒙零基础快速实战-仿抖音App开发（ArkTS版）”（https://coding.imooc.com/class/843.html）
《鸿蒙HarmonyOS应用开发从入门到精通（第2版）》（北京大学出版社)
《鸿蒙之光HarmonyOS NEXT原生应用开发入门》（清华大学出版社)
“HarmonyOS NEXT+AI大模型打造智能助手APP(仓颉版)”（https://coding.imooc.com/class/927.html）
“鸿蒙HarmonyOS 6 AI应用开发”(https://edu.51cto.com/course/39601.html)

仓颉编程语言（Cangjie）正式发布1.0.0 LTS版本，附安装配置教程

Way Lau — Mon, 07 Jul 2025 02:48:32 +0000

仓颉编程语言的首个长期支持（Long-Term Support, LTS）版本已于2025年7月1日正式发布。仓颉最早是在2024年6月的华为开发者大会亮相，定位是下一代编程语言。笔者估计，本次LTS版本发布，是为了配合将于本月底仓颉编程语言开源事宜。

本文主要介绍仓颉编程语言的特性及安装。

仓颉编程语言简介

仓颉编程语言是华为自研的一种面向全场景应用开发的通用编程语言，可以兼顾开发效率和运行性能，并提供良好的编程体验，主要具有如下特点：

多后端支持：仓颉编程语言支持 CJNative 和 CJVM 两种后端。其中 CJNative 后端将代码编译为原生二进制代码，直接在操作系统层面上运行；CJVM 后端将代码编译为字节码，基于 VM（虚拟机）进行运行。本次发布仅提供 CJNative 后端 SDK，CJVM 后端 SDK 敬请期待。
语法简明高效：仓颉编程语言提供了一系列简明高效的语法，旨在减少冗余书写、提升开发效率，例如插值字符串、主构造函数、Flow 表达式、match 和重导出等语法，让开发者可以用较少编码表达相关逻辑。
多范式编程：仓颉编程语言支持函数式、命令式和面向对象等多范式编程，融合了高阶函数、代数数据类型、模式匹配、泛型等函数式语言的先进特性，还有封装、接口、继承、子类型多态等支持模块化开发的面向对象语言特性，以及值类型、全局函数等简洁高效的命令式语言特性。开发者可以根据开发偏好或应用场景，选用不同的编程范式。
类型安全：仓颉编程语言是静态强类型语言，通过编译时类型检查尽早识别程序错误，降低运行时风险，也便于代码维护。同时，仓颉编译器提供了强大的类型推断能力，可以减少类型标注工作，提高开发效率。
内存安全：仓颉编程语言支持自动内存管理，并在运行时进行数组下标越界检查、溢出检查等操作，确保运行时内存安全。
高效并发：仓颉编程语言提供了用户态轻量化线程（原生协程），以及简单易用的并发编程机制，保证并发场景的高效开发和运行。
兼容语言生态：仓颉编程语言支持和 C 等编程语言的互操作，并采用便捷的声明式编程范式，可实现对其他语言库的高效复用和生态兼容。
领域易扩展：仓颉编程语言提供了基于词法宏的元编程能力，支持在编译时变换代码。此外，还提供了尾随 lambda、属性、操作符重载、部分关键字可省略等特性，开发者可由此深度定制程序的语法和语义，这有利于内嵌式领域专用语言（Embedded Domain Specific Languages，EDSL）的构建。
助力 UI 开发：UI 开发是构建端侧应用的重要环节，基于仓颉编程语言的元编程和尾随 lambda 等特性，用户可以搭建声明式 UI 开发框架，提升 UI 开发效率和体验。
内置库功能丰富：仓颉编程语言提供了功能丰富的内置库，涉及数据结构、常用算法、数学计算、正则匹配、系统交互、文件操作、网络通信、数据库访问、日志打印、解压缩、编解码、加解密和序列化等功能。

版本

仓颉编程语言提供三个版本（LTS、STS 和 Nightly Build），每个通道均提供可以在Linux、Windows以及Mac上安装使用的软件包与帮助开发者在VScode平台上搭建开发环境的插件。每个版本通道更新/维护计划有所差异，具体计划根据各版本通道描述为准。

从官网了解到，截止目前仓颉编程语言也就发布过三个版本号，各个版本之间估计变更内容不是很多。

安装包

安装包在命名上更加规范了。安装包可以在https://cangjie-lang.cn/download，找到分为了仓颉SDK（仓颉工具链）和仓颉插件。

仓颉SDK（仓颉工具链）：cangjie-sdk-windows-x64-1.0.0.zip
仓颉语言 VS Code 插件：cangjie-vscode-1.0.0.tar.gz，该插件可以通过离线方式安装。插件也可以无需下载，直接可以在VS Code插件市场上找到直接安装。

Windows 平台上的安装、卸载

安装指导

1. 解压安装包

如果选择 zip 格式的安装包（例如 cangjie-sdk-windows-x64-x.y.z.zip），请将它解压到适当目录（比如本例D:\dev\cangjie\cangjie-sdk-windows-x64-1.0.0\cangjie），在安装包中，仓颉为开发者提供了三种不同格式的安装脚本，分别是 envsetup.bat，envsetup.ps1 和 envsetup.sh，可以根据使用习惯及环境配置，选择一种执行：

- 若使用 Windows 命令提示符（CMD）环境，请执行：

    ```bash
    path\to\cangjie\envsetup.bat
    ```

- 若使用 PowerShell 环境，请执行：

    ```bash
    . path\to\cangjie\envsetup.ps1
    ```

- 若使用 MSYS shell、bash 等环境，请执行：

    ```bash
    source path/to/cangjie/envsetup.sh
    ```

为了验证是否安装成功，请在以上命令环境中继续执行 `cjc -v` 命令，如果输出了仓颉编译器版本信息，表示已经成功安装了仓颉工具链。

值得注意的是，基于 zip 安装包和执行脚本的安装方式，类似于 Linux 平台，即 envsetup 脚本所配置的环境变量，只在当前命令行环境中有效，如果打开新的命令行窗口，需要重新执行 envsetup 脚本配置环境。此时，若想使仓颉工具链的环境变量配置在命令提示符或终端启动时自动生效，可以设置环境变量

2. 配置 CANGJIE_HOME 变量

“系统变量”（为系统所有用户进行配置）区域中，点击 “新建” 按钮，并在 “变量名” 字段中输入 CANGJIE_HOME。在 “变量值” 字段中输入仓颉安装包的解压路径，（比如本例D:\dev\cangjie\cangjie-sdk-windows-x64-1.0.0\cangjie）。配置完成后，请在 “编辑用户变量” 或 “编辑系统变量” 窗口界面确认路径正确，然后点击 “确定” 按钮。

在“系统变量”（为系统所有用户进行配置）区域中，找到并选择 Path 变量，点击 “编辑” 按钮，进入 “编辑环境变量” 窗口。点击 “编辑文本” 按钮，附加以下内容;%CANGJIE_HOME%\bin;%CANGJIE_HOME%\tools\bin;%CANGJIE_HOME%\tools\lib;%CANGJIE_HOME%\runtime\lib\windows_x86_64_llvm。设置完成后可能需要重启命令行窗口或重启系统以让设置生效。

配置完成后 Windows 命令提示符（CMD）或 PowerShell 启动即可直接使用仓颉编译工具链。

C:\Users\wayla>cjc -v
Cangjie Compiler: 1.0.0 (cjnative)
Target: x86_64-w64-mingw32

卸载与更新

如果选择 zip 格式的安装包进行的安装，删除仓颉工具链的安装包目录，同时移除上述环境变量设置（若有），即可完成卸载。

若需要更新仓颉工具链，需要先卸载当前版本，然后按上述指导重新安装最新版本的仓颉工具链。

配置仓颉语言 VS Code 插件

安装过程，参考往期博客。

主要配置如下：

能呼出如下界面，则证明安装成功：

视频演示

详见B站：https://www.bilibili.com/video/BV1mz36zMEdz/

参考引用

华为自研仓颉编程语言将开源，未来与ArkTS同等地位
仓颉编程语言开发环境搭建（安装VSCode仓颉插件）
《跟老卫学仓颉编程语言开发》开源免费教程， https://github.com/waylau/cangjie-programming-language-tutorial
“HarmonyOS NEXT+AI大模型打造智能助手APP(仓颉版)”https://coding.imooc.com/class/927.html

HarmonyOS NEXT + AI Q&A 06: What is the Relationship Between the Cangjie Toolchain and DevEco Studio Cangjie Plugin?

Way Lau — Mon, 30 Jun 2025 02:05:07 +0000

HarmonyOS NEXT + AI Q&A 06: What is the Relationship Between the Cangjie Toolchain and DevEco Studio Cangjie Plugin in the Cangjie Programming Language? Why Install So Many Plugins?

In the "HarmonyOS NEXT + AI Large Model to Build an Intelligent Assistant APP (Cangjie Version)" course, a student raised the following question:

After installing the Cangjie toolchain, why do I still need to install the DevEco Studio Cangjie Plugin? Will DevEco Studio call the SDK of the Cangjie toolchain? It seems there are no related settings for this.

Here is a unified response to this student's question to facilitate reference for other students. Previous Q&As can be found on my homepage.

In Chapter 3, "Intelligent AI Assistant Project - Development Environment Setup," of the course, we have arranged the following content:

3.1 Chapter Introduction
3.2 Register a Huawei account and complete real-name authentication
3.3 Set up the Cangjie programming language development environment
3.4 Basic usage of CJPM
3.5 [Practical] Develop a Cangjie "Hello World" application
3.6 Analyze the structure of the Cangjie "Hello World" application
3.7 Download and install the development tool DevEco Studio
3.8 Configure DevEco Studio
3.9 Download and install the DevEco Studio Cangjie Plugin
3.10 [Practical] Create a HarmonyOS application "Hello World"
3.11 Sign the HarmonyOS application
3.12 Run the HarmonyOS application on a local real device
3.13 Run the HarmonyOS application using a local emulator
3.14 Master the common functions of the DevEco Studio editor
3.15 Detailed explanation of the HarmonyOS application structure
3.16 Master the core component Ability of HarmonyOS
3.17 Understand application-level and component-level configurations
3.18 Understand the packaging principle of HarmonyOS
3.19 How to improve UI development efficiency and experience?
3.20 Chapter Summary
3.21 Exercises: Create a HarmonyOS application

It can be seen that there are actually two sets of environment setups introduced here: one is a pure Cangjie environment, and the other is a Cangjie-HarmonyOS environment. These two sets of environments are independent and have no association.

The main installation steps for the pure Cangjie environment are:

3.3 Set up the Cangjie programming language development environment
- Mainly involves installing the Cangjie toolchain and the VSCode Cangjie plugin. The Cangjie toolchain can be simply understood as the SDK for Cangjie, similar to the JDK for Java, used for compiling and running pure Cangjie programs.
- The VSCode Cangjie plugin supports developing pure Cangjie programs in VSCode.

The main installation steps for the Cangjie-HarmonyOS environment are:

3.7 Download and install the development tool DevEco Studio
3.8 Configure DevEco Studio
3.9 Download and install the DevEco Studio Cangjie Plugin
- Mainly involves installing DevEco Studio and the DevEco Studio Cangjie Plugin. These tools are primarily used to support developing Cangjie-based HarmonyOS applications in DevEco Studio, similar to Android Studio.

These are two separate environments: one is a pure Cangjie environment, and the other is a Cangjie-HarmonyOS environment. They are independent and have no association.

If you only want to learn the syntax of the Cangjie programming language, you only need the pure Cangjie environment. Chapter 4, "Intelligent AI Assistant - Quickly Get You Started with Cangjie Programming Language," of the course provides a complete learning path from scratch, allowing you to systematically master the Cangjie programming language. Through this chapter, you can learn to develop an animal sound simulator, understand Cangjie collection classes, exception handling, package management, master large-scale program code organization and management, become familiar with I/O operations, file reading and writing operations, and network programming. You can even create TCP servers, UDP servers, and build HTTP services using the Cangjie programming language.

If you want to develop HarmonyOS applications using the Cangjie programming language, you need to install the Cangjie-HarmonyOS environment. As we all know, DevEco Studio is an essential IDE for developing HarmonyOS applications. Since the Cangjie programming language has not been officially released yet, it is necessary to support developing HarmonyOS applications based on the Cangjie programming language in DevEco Studio through a plugin (DevEco Studio Cangjie Plugin). Chapters 5-11 of the course also include corresponding practical training.

Currently, having multiple environments and multiple plugins has indeed caused many difficulties for HarmonyOS application developers, but this is only temporary. As I mentioned in the article "Huawei's Self-Developed Cangjie Programming Language Will Be Open-Sourced and Have the Same Status as ArkTS in the Future," as the Cangjie programming language continues to improve, it will inevitably have the same status as ArkTS. Then, DevEco Studio will naturally support HarmonyOS applications based on the Cangjie programming language without the need to install so many plugins.

The future of the Cangjie programming language is promising. Are you ready?

After understanding the differences between these HarmonyOS programming languages, I believe you now have your own judgment on choosing a HarmonyOS programming language. When selecting a language, you can consider the following aspects based on your own situation:

Personal Preference:
- Developers have certain preferences for programming languages. You can choose ArkTS or Java based on your personal喜好.
- If you are familiar with Java or Android, you can choose Java. If you are familiar with JS or TS, you can choose ArkTS. If you are familiar with Rust, Cangjie is also a good choice.
Career Needs:
- If you want to implement powerful and complete HarmonyOS application functions and maximize compatibility with existing Android devices on the market, Java is currently a good choice. However, note that HarmonyOS will no longer support Java after API 8. For related content on developing HarmonyOS applications with Java, please refer to my books "HarmonyOS Mobile Application Development Practice" and "HarmonyOS Application Development from Beginner to Master" as well as the video tutorial "HarmonyOS System Practical Short Video App Development from Scratch to Mastery (ArkTS Version)."
- ArkTS is currently the main language promoted in the HarmonyOS ecosystem. It is recommended to build new commercial projects based on ArkTS. For related content on developing HarmonyOS applications with ArkTS, please refer to my books "HarmonyOS Application Development Introduction," "HarmonyOS Application Development from Beginner to Master (2nd Edition)," and "Harmony Light: HarmonyOS NEXT Native Application Development Introduction" as well as the video tutorial "HarmonyOS Zero-Based Rapid Practical - Imitation Douyin App Development (ArkTS Version)."
- If you simply want to learn a new language and keep up with its evolution, Cangjie is also a good choice. From a future development perspective, Cangjie may replace ArkTS as the main development language. However, note that Cangjie is currently only a developer preview version, with an unstable API and incomplete functionality. It is not recommended for use in commercial scenarios. For related content on the Cangjie programming language, please refer to my book "Cangjie Programming from Beginner to Practice" and the video tutorial "HarmonyOS NEXT + AI Large Model to Build an Intelligent Assistant APP (Cangjie Version)."

For more open-source tutorials, please see:

Huawei's Self-Developed Cangjie Programming Language to Go Open Source, Sharing Equal Status with ArkTS in the Future

Way Lau — Tue, 24 Jun 2025 01:33:57 +0000

At the Huawei Developer Conference 2025 (HDC 2025) on June 20, 2025, Huawei officially announced the launch of the HarmonyOS 6 Developer Beta version, further enhancing the innovation in user experience and development efficiency. Gong Ti, President of Huawei's Consumer BG Software Department, delivered a speech titled "A More Efficient Harmony Development Experience" and announced that the Cangjie programming language would go open source on July 30. Cangjie first made its debut at the Huawei Developer Conference in June 2024, positioned as a next-generation programming language.

Features of the Cangjie Programming Language

As a new programming language, Cangjie has absorbed the strengths of various mainstream programming languages and developed its own unique characteristics.

Efficient Programming: For application development, programming languages should be easy to learn and use, lowering the entry barrier for developers and reducing the cognitive load during the development process. They should support various common development paradigms and programming models, enabling developers to express business logic concisely and efficiently. Cangjie is a multi-paradigm programming language that supports functional, imperative, and object-oriented paradigms, including features such as value types, classes and interfaces, generics, algebraic data types, pattern matching, and higher-order functions. Additionally, Cangjie supports type inference, reducing the burden of type annotations for developers. Through a series of concise and efficient syntaxes, it minimizes redundant code and enhances development efficiency. The language's built-in syntactic sugar and macro capabilities enable developers to quickly develop domain-specific languages (DSLs) based on Cangjie and build domain abstractions.
Safety and Reliability: As a modern programming language, Cangjie strives for security at the coding level. Through its static type system and automatic memory management, it ensures type safety and memory safety such as null safety. Meanwhile, Cangjie provides various runtime checks, including array bounds checking, type conversion checking, numerical overflow checking, and string encoding validity checking, to promptly detect errors during program execution. Furthermore, it offers additional support for cross-language interoperability security and code asset protection through code scanning tools, obfuscation tools, and sanitizers.
Effortless Concurrency: Concurrency and asynchronous programming are essential capabilities in application development, effectively improving processor utilization and ensuring program responsiveness in interactive applications. The Cangjie language implements lightweight user-mode threads and a concurrency object library, making efficient concurrency effortless. Cangjie adopts a user-mode thread model, where each Cangjie thread is an extremely lightweight execution entity with an independent execution context but shared memory. For developers, the use of user-mode threads remains consistent with that of traditional system threads, without adding extra burden. From a runtime perspective, thread management is handled by the runtime system, independent of the operating system's thread management. Therefore, operations such as thread creation, scheduling, and destruction are more efficient, with lower resource consumption compared to system threads. To avoid data races, Cangjie provides a concurrency object library where the methods of concurrency objects are thread-safe. Thus, calling these methods in a multi-threaded environment is no different from serial programming, and application logic developers do not need to worry about concurrency management. For some core libraries, Cangjie also provides lock-free or fine-grained locking algorithm implementations to further reduce thread blocking and improve concurrency.
Exceptional Performance: The Cangjie compiler and runtime optimize compilation across the entire stack, including compiler front-end optimizations based on CHIR (Cangjie HighLevel IR) (such as semantic-aware loop optimization and semantic-aware backend collaborative optimization), backend-based optimizations (such as SLP vectorization, Intrinsic optimization, InlineCache, inter-procedural pointer optimization, and Barrier optimization), and runtime-based optimizations (such as lightweight locks, distributed marking, and concurrent tracing optimization). These optimizations enable Cangjie to fully leverage processor capabilities and provide exceptional performance support for applications. Additionally, the Cangjie language adopts a native lightweight design for the runtime. Through modular and layered design of the runtime, it defines the Cangjie common object model and runtime common infrastructure components. Based on the common object model, it implements basic runtime capabilities such as memory management, stack unwinding, exception handling, and cross-language calls, significantly reducing redundant object designs across multiple capabilities and streamlining the runtime size. Meanwhile, through on-demand package loading technology, it reduces redundant package memory overhead during Cangjie application startup, resulting in lower resource consumption and better support for resource-sensitive devices.

In addition, Cangjie supports a series of toolchains for application development, including language services (highlighting, code completion), debugging (cross-language debugging, thread-level visual debugging), static checking, performance analysis, package management, documentation generation, mock tools, testing frameworks, coverage tools, fuzzing tools, and intelligent programming assistance tools, further enhancing the software development experience and efficiency.

Interpretation of the Harmony Programming Language White Paper

On June 20, 2025, Huawei released Version 1.0 of the "Harmony Programming Language White Paper." The core content of the white paper is as follows:

Harmony Programming Language Overall Framework

Multi-Language Ecosystem: Harmony supports three programming languages—ArkTS, Cangjie, and C/C++—which complement each other and jointly support the construction of the Harmony application ecosystem.
- ArkTS: A dynamically typed programming language based on TypeScript, characterized by its ease of learning and use, and a rich ecosystem, suitable for efficient development scenarios.
- Cangjie: A statically typed programming language with high performance, strong security, and cross-platform capabilities, suitable for scenarios with high performance and security requirements.
- C/C++: Suitable for specific scenarios such as high-performance computing and hardware acceleration, and can be encapsulated as ArkTS and Cangjie extension modules through cross-language interoperability.
Language Interoperability: ArkTS and C/C++ achieve interoperability through Node-API; Cangjie and C language achieve mutual function calls and cross-language data conversion; Cangjie and ArkTS achieve data conversion and function calls through an interoperability library.

Harmony Programming Language Application Scenarios

Efficient Development: ArkTS is compatible with TS's efficient syntax, provides a rich set of basic libraries and concurrency capabilities, supports declarative UI development, and can inherit the TS/JS language ecosystem.
High Performance: ArkTS's compilation runtime supports hybrid execution modes, optimizes module loading mechanisms, and provides an efficient concurrent programming model. Cangjie, based on static typing and static compilation optimization technologies, offers exceptional performance support.
Security: ArkTS introduces features such as a type system at the language level and provides additional security mechanisms in the compilation toolchain and runtime. Cangjie ensures program security through static typing, automatic memory management, etc.
Cross-Platform: Cangjie supports static compilation to machine code for different OS platforms, enabling cross-OS platform code sharing and supporting multiple operating system platforms.
Technical Asset Protection: ArkTS provides source code obfuscation tools like ArkGuard. Cangjie offers various obfuscation techniques such as shape obfuscation, data obfuscation, and control flow obfuscation.

Harmony Programming Language Evolution Strategies

ArkTS Evolution Strategy: Further define and refine the language specification, provide compiler implementations based on the language specification, and introduce type information to optimize runtime performance.
Cangjie Evolution Strategy: Continuously improve the efficient development experience, provide high-performance and strong security capabilities, and continuously refine and explore in the areas of cross-platform and intelligence.
Intelligent Evolution Strategy: Cangjie will build Agent DSL capabilities through metaprogramming and DSL capabilities, and in the future, will deepen integration with AI technologies to promote applications in multiple fields.

Language Evolution Strategies for the Next Year

ArkTS: Will continue to iterate and evolve, further enriching new features such as concurrent programming, improving the type system, modernizing syntax, enhancing development efficiency, and enriching SDK functionality.
Cangjie: Will aim to improve the developer experience, continuously build language capabilities from aspects such as language feature construction, compatibility with existing ecosystems, and improving the usability of the toolchain, including API development, development tool support, and documentation improvement.

Summary

Both ArkTS and Cangjie will serve as the main programming languages for Harmony, enjoying equal status and complementary advantages, jointly supporting the construction of the Harmony application ecosystem. ArkTS has a first-mover advantage with a rich API library, while Cangjie, though later to the market, boasts inherent high performance and security.

For more content related to Cangjie, please refer to the open-source and free tutorial "Learning Cangjie Programming Language Development with Way Lau" and "Building an Intelligent Assistant APP with HarmonyOS NEXT + AI Large Model (Cangjie Edition)."

References

"Learning AI Large Model Development with Way Lau" Open Source and Free Tutorial: https://github.com/waylau/ai-large-model-tutorial/
"Learning Cangjie Programming Language Development with Way Lau" Open Source and Free Tutorial: https://github.com/waylau/cangjie-programming-language-tutorial
"Learning HarmonyOS Development with Way Lau" Open Source and Free Tutorial: https://github.com/waylau/harmonyos-tutorial
"Practical Development of HarmonyOS Mobile Applications" (Tsinghua University Press)
"Introduction to HarmonyOS Application Development" (Tsinghua University Press)
"Rapid Hands-On HarmonyOS Development from Scratch - Imitating Douyin App Development (ArkTS Edition)" (https://coding.imooc.com/class/843.html)
"Mastering HarmonyOS Application Development from Beginner to Advanced (2nd Edition)" (Peking University Press)
"Introduction to HarmonyOS NEXT Native Application Development" (Tsinghua University Press)
"Building an Intelligent Assistant APP with HarmonyOS NEXT + AI Large Model (Cangjie Edition)" (https://coding.imooc.com/class/927.html)
"Harmony Programming Language White Paper" Version 1.0: https://developer.huawei.com/consumer/cn/doc/guidebook/programming-language-0000002323920052

The application of SwiperAnimationMode introduced in HarmonyOS API 15

Way Lau — Mon, 23 Jun 2025 00:34:26 +0000

This article highlights the new event changeIndex(index: number, animationMode?: SwiperAnimationMode| boolean) added in API 15, which allows setting the animation mode when flipping to a specified page within a swiper component. The default value is SwiperAnimationMode.NO_ANIMATION. There are three types of animation modes available:

NO_ANIMATION: Flips to the specified page without any animation.
DEFAULT_ANIMATION: Flips to the specified page with an animation effect.
FAST_ANIMATION: Quickly flips to a nearby page without animation, then animates to the final target page.

The example provided demonstrates triggering these effects through three buttons. Each button click invokes the changeIndex method with different parameters to switch pages using one of the above animation modes. Specifically:

Clicking 'NO_ANIMATION 0' will change the index to 0 without any animation.
Clicking 'DEFAULT_ANIMATION 10' will animate the transition to index 10.
Clicking 'FAST_ANIMATION 20' first rapidly moves near the target page and then animates to index 20.

These examples show how to apply different animation effects when navigating between pages in a swiper component. The source code for this example can be found in the "Learning HarmonyOS Development with Old Wei" project on GitHub: https://github.com/waylau/harmonyos-tutorial.

The new Indicator navigation point component in HarmonyOS API 15.

Way Lau — Tue, 17 Jun 2025 00:27:18 +0000

This section demonstrates the features and usage of the new Indicator navigation point component in HarmonyOS API 15.

Environment Used

DevEco Studio 5.0.5 Release

Overview of the Indicator Navigation Point Component

The Indicator navigation point component offers two styles of navigation points: dot navigation points and digit navigation points.

This component has been supported since API Version 15. It provides the existing capabilities of the Indicator in the original Swiper component as a standalone component for developers to use. Developers can display navigation points independently without relying on the Swiper component, or they can bind it with the Swiper component using the IndicatorComponentController.

When multiple navigation point components are bound to the same Swiper component, only the last navigation point component will successfully bind to the Swiper.

When a navigation point component is bound to multiple Swiper components, only the last Swiper component will successfully bind to the navigation point component.

Creating an Example to Display Navigation Points Independently Without the Swiper Component

Create a project named "ArkTSIndicator" to demonstrate displaying navigation points independently without relying on the Swiper component.

Modify Index.ets as follows:

@Entry
@Component
struct Index {
  @State indicatorIndex: number = 0;

  // Controller for the Indicator component, which can be bound to the Indicator component to control page flipping.
  private indicatorController: IndicatorComponentController = new IndicatorComponentController();

  build() {
    Column() {
      Text(this.indicatorIndex + '')
        .fontSize($r('app.float.page_text_font_size'))
        .fontWeight(FontWeight.Bold)

      IndicatorComponent(this.indicatorController)
        .initialIndex(0) // Sets the index of the current navigation point when it is first displayed.
        .style( // Optional navigation point indicator style.
          new DotIndicator()
            .itemWidth(25)
            .itemHeight(25)
            .selectedItemWidth(25)
            .selectedItemHeight(25)
            .color(Color.Gray)
            .selectedColor(Color.Blue))
        .loop(true) // Sets whether to enable looping.
        .count(6) // Sets the total number of navigation points.
        .vertical(false) // Sets whether it is a vertical slide.
        // This event is triggered when the index of the currently selected navigation point changes. The index of the currently selected navigation point can be obtained through the callback function.
        .onChange((index: number) => {
          console.log("current index: " + index );

          // Assign the index to the variable indicatorIndex.
          this.indicatorIndex = index;
        })
    }
    .height('100%')
    .width('100%')
  }
}

Runtime Effect

For a video demonstration, please visit Bilibili: https://www.bilibili.com/video/BV1AE76z5Ei8/

Code Explanation

In the above example, the IndicatorComponentController is the controller for the Indicator component, which can be bound to the Indicator component to control page flipping.

The interface IndicatorComponent(controller?: IndicatorComponentController) is the constructor for the standalone navigation point component and can be used to configure the controller of the component. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API Version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The property initialIndex(index: number) of the IndicatorComponent is used to set the index of the current navigation point when it is first displayed. If the set value is less than 0 or greater than or equal to the number of navigation points, it will be treated as the default value 0. This property does not take effect when the standalone navigation point component is bound to the Swiper. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The property style(indicatorStyle: DotIndicator | DigitIndicator) of the IndicatorComponent is used to set the optional navigation point indicator style. The optional navigation point indicator style can be either DotIndicator or DigitIndicator, where DotIndicator is the dot indicator style and DigitIndicator is the digit indicator style. The default type is DotIndicator. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The property loop(isLoop: boolean) of the IndicatorComponent is used to set whether to enable looping. This property does not take effect when the standalone navigation point component is bound to the Swiper. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The property count(totalCount: number) of the IndicatorComponent is used to set the total number of navigation points. When the standalone navigation point component is bound to the Swiper, the number of pages in the Swiper takes precedence. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The property vertical(isVertical: boolean) of the IndicatorComponent is used to set whether it is a vertical slide. This property does not take effect when the standalone navigation point component is bound to the Swiper. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The event onChange(event: Callback<number>) of the IndicatorComponent is triggered when the index of the currently selected navigation point changes. The index of the currently selected navigation point can be obtained through the callback function. The description is as follows:

Card Capability: Starting from API version 15, this interface supports use in ArkTS cards.
Atomic Service API: Starting from API version 15, this interface supports use in atomic services.
System Capability: SystemCapability.ArkUI.ArkUI.Full

The currently selected navigation point index will copy the index value of the currently selected navigation point to the variable indicatorIndex, which is then displayed in the Text component above.

Source Code

The source code for this example is archived in "Learning HarmonyOS Development with Way Lau": https://github.com/waylau/harmonyos-tutorial