The paper introduces the Temporal‑Aware Reasoning Optimization (TaRO) framework, which equips multimodal video large models with time‑aware reasoning via template‑based exploration, a temporal‑sensitivity reward, and progressive curriculum learning, achieving state‑of‑the‑art zero‑shot performance on several video temporal grounding benchmarks, including long‑video datasets.
The article explains why existing cross‑platform solutions cannot meet Taro’s demands for high performance, stability, full Taro ecosystem compatibility and low integration cost, and describes the design of a dual‑thread iOS rendering layer, a mixed native‑view + layer approach, and the C++‑based TaroUI framework that provides consistent, high‑speed UI components, a rich‑text engine, virtual list widgets and an extensible architecture for future platforms.
This article details Taro’s self‑developed iOS rendering layer and TaroUI framework, explaining how a double‑thread pipeline, native‑view‑plus‑layer architecture, rich‑text engine, and extensive rendering optimizations deliver high performance, stability, and cross‑platform consistency for mobile applications.
Taro 5.0 introduces a three‑layer WebOnNative architecture that unifies Mini‑Program, H5, Android, iOS and HarmonyOS development, delivering native‑level performance, pixel‑perfect UI consistency, AI‑assisted tooling, and dynamic publishing capabilities that have already been validated in large‑scale JD business scenarios.
This article details JD.com’s six‑month engineering effort to refactor its high‑traffic order module into a single Taro codebase that runs on Android, iOS and HarmonyOS, covering business background, preparation, multi‑mode adaptation, core challenges, quality assurance, efficiency gains and the resulting business impact.
A solo developer recounts the surprising hurdles of creating a WeChat mini‑program—from domain registration and residence‑permit verification to platform account splits, framework choices between Taro and Uni‑app, and the unexpected smoothness of the final review.
This article explains how to integrate Galacean Effects into a Taro 3.x mini‑program to create ritualistic card‑merge animations, covers installation, code examples, loading‑time analysis, and offline‑package optimization that dramatically reduces first‑frame delay and improves user experience.
An unexpected TypeError in Taro’s useRouter reveals that the router can be null after onHide, leading to crashes; this article dissects the root cause in Taro 3.6.29, examines the code flow, and presents a Babel plugin workaround that safely retrieves parameters.
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.
Learn how to configure Figma's Dev Mode MCP, connect it to AI coding assistants like Cursor, and generate accurate mobile front‑end code with Taro and React, leveraging component and icon libraries to streamline design‑to‑code workflows and improve development efficiency.
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.
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.
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.
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.
To overcome the 2 MB main‑package limit of WeChat mini‑programs, this guide details a step‑by‑step solution that uses @galacean/effects for stunning homepage animations, applies page and module splitting, Babel and webpack plugins, and Taro configuration to move large code into asynchronous sub‑packages.
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 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.
During the Double‑11 promotion, our team applied a series of Taro mini‑program performance optimizations—including Skyline rendering engine migration, lazy loading of feed resources, image size reduction, and parallel API requests—to significantly reduce cold‑start, hot‑start, and rendering times, improving overall user experience.
This article details a comprehensive performance optimization of a Taro‑based mini‑program for the Double‑11 promotion, covering measurement methods, problem analysis, Skyline rendering engine migration, lazy loading, image sizing, API parallelization, and the resulting speed improvements.
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 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 article explores how Taro integrates C++ via Harmony's C‑API to create a high‑performance, cross‑language event system that enhances rendering speed, improves lifecycle management, and overcomes ArkTS limitations for Harmony OS applications.
This article explains how Taro leverages C‑API to move runtime logic to C++ and builds a cross‑language event system that unifies ArkTS, JavaScript and C++ on Harmony OS, improving rendering performance, lifecycle management, and developer productivity.
This article explains how the Taro framework bridges React and HarmonyOS ArkUI by describing Taro's runtime architecture, the custom renderer implementation, and the step‑by‑step conversion of React components into ArkUI nodes, including code examples and key technical challenges.
This article details how the Taro framework bridges the gap between W3C CSS and HarmonyOS's ArkUI by converting units, handling layout differences with Yoga, processing static and runtime styles, and managing style updates to achieve high‑performance cross‑platform applications.
This article explains how Taro resolves the incompatibilities between standard CSS and HarmonyOS ArkUI CAPI styles by converting CSS at compile time, using a Rust‑based LightningCSS plugin, and employing the Yoga layout engine to achieve high‑performance, cross‑platform UI rendering.
This article explains how Taro adapts standard CSS to HarmonyOS's ArkUI by converting units, handling layout differences with the Yoga engine, and implementing an efficient runtime style system that maintains cross‑platform compatibility and high performance for React‑based applications.
This article explains how the Taro framework adapts React applications to run efficiently on HarmonyOS by converting React components into Taro virtual nodes, then into ArkUI nodes through a three‑step rendering pipeline, detailing runtime principles, hostConfig methods, and C++ implementation examples.
This article explains how the Taro framework bridges React applications to Huawei's HarmonyOS by converting React components into Taro's virtual nodes and then mapping them to ArkUI native components, detailing the runtime architecture, hostConfig methods, and three-step conversion process.
This article examines how the Taro framework adapts React code to run on Huawei's HarmonyOS by implementing a custom renderer that converts React components into Taro virtual nodes, then maps them to ArkUI structures through a three‑step process involving Taro Elements, RenderNodes, and native ArkUI nodes.
The article introduces AIGCDesign, an open‑source cross‑platform AI component solution that combines traditional frontend libraries with large‑language‑model capabilities, outlines its design goals, technical architecture, lifecycle hooks, configuration examples, multi‑framework support, and real‑world business integration cases.
This article examines the challenges of using remote components in DingTalk and WeChat mini‑programs, compares them with traditional npm packages, and presents a practical Taro‑based debugging workflow that leverages alias configuration and hot‑module replacement to streamline development.
JD leveraged the Taro cross‑platform framework to build a HarmonyOS native app, detailing the background partnership with Huawei, the technical solution choices, key features like Web‑style development, CSS optimizations, virtual lists, and mixed native modules, and presenting performance gains and future optimization plans.
This article explains how JD adopted the Taro cross‑platform framework to build HarmonyOS native applications, detailing the background, technical方案, key features, performance results, and future optimization plans for delivering high‑performance mobile experiences.
The article details JD's adoption of the Taro cross‑platform framework to build a HarmonyOS native app, describing the technical architecture, CSS and rendering optimizations, performance gains over native ArkTS, and future plans for further speed and flexibility improvements.
The article details JD’s 2024 initiative to build HarmonyOS native applications using the cross‑platform Taro framework, describing the chosen technical solution, key advantages such as Web‑style development, CSS optimizations, rendering performance, virtual list support, and future optimization plans.
The article explains JD's technical solution for developing HarmonyOS native applications with the Taro cross‑platform framework, detailing the chosen architecture, CSS adaptations, performance optimizations, and future enhancement plans that resulted in significant rendering speed gains.
This article explains the motivation, research, architecture, implementation details, lifecycle hooks, configuration options, multi‑framework support, and future directions of AIGCDesign, a cross‑platform AI component library built with Taro, React, Vue and native technologies, including code examples and streaming techniques.
The article introduces AIGCDesign, a cross‑platform frontend component library that leverages AI generation capabilities, explains its motivation, research of existing solutions, architectural layers, lifecycle hooks, configuration examples, multi‑framework support, business integration cases, and future stream‑processing enhancements.
This article walks through initializing a vue-mini mini‑program project, explains the build.js workflow, details how TypeScript, HTML and CSS files are processed with Babel, Rollup and PostCSS, compares its performance to Taro, and evaluates vue-mini’s current strengths and limitations.
This guide walks through selecting a suitable visualization library for DingTalk mini‑programs, explains why AntV F2 is optimal, and provides step‑by‑step instructions for integrating F2 4.x into a Taro + React project, covering canvas context handling, pixel‑ratio scaling, custom tooltips, and common pitfalls.
This article walks through the design and implementation of a compiler that automatically transforms Rax components into Taro components, covering the background, Babel‑based AST processing, import rewriting, component attribute mapping, project structure, automated end‑to‑end testing, and future enhancements.
The article examines why Taro‑based B‑end mini‑programs experience slow hot‑update builds as codebases grow, analyzes the bottlenecks in IDE and Taro compilation, and presents practical solutions—including project splitting, dynamic builds, configuration tweaks, and IDE version downgrades—to reduce build time from over 10 seconds to under 3 seconds.
This guide provides a step‑by‑step tutorial on configuring the development environment, installing Taro v4 beta, setting up the HarmonyOS project in DevEco Studio, and using Taro plugins and scripts to build, preview, and debug native HarmonyOS applications.
This article explains four practical techniques—page sub‑packaging, shared module sub‑packaging, Babel‑based import path rewriting, and image asset offloading—to reduce a Taro mini‑program’s main bundle below the 2 MB limit, detailing the underlying MiniSplitChunksPlugin implementation, configuration steps, and code snippets.
This article explains JD.com and Huawei's partnership to launch a HarmonyOS native JD app, details how the Taro front‑end framework adapts to HarmonyOS ArkTS and ArkUI, and provides a three‑part guide for developers to create their first HarmonyOS native application.
This tutorial provides a step‑by‑step guide for setting up the HarmonyOS development environment, creating a Harmony project, and using Taro v4.0.0‑beta.x to build, preview, and debug your first HarmonyOS native application, including configuration details and common pitfalls.
The article describes an AST‑driven command‑line tool that automatically upgrades a Taro 1.x mini‑program to 3.x by updating dependencies, converting imports, restructuring files, consolidating styles, replacing deprecated APIs, and adjusting build settings, offering faster, more reliable migration than the labor‑intensive manual approach.
Taro’s mini‑runner builds a webpack configuration from base, custom, and platform‑specific settings, then runs webpack to compile a single codebase into bundles for mini‑programs, H5, and other targets, while allowing extensive plugin, loader, and constant customization for multi‑platform development.
This article thoroughly analyzes how the Taro front‑end framework is adapted to Huawei's HarmonyOS ArkTS by employing a runtime‑centric adaptation approach that maps Taro's virtual DOM to ArkTS UI components, reducing compile‑time conversion errors and improving developer experience.
This article introduces Huawei's upcoming HarmonyOS Next, explains the ArkUI framework with its declarative ArkTS and Web‑like development models, compares the two paradigms, and details how the Taro framework can bridge Web development practices to ArkTS for cross‑platform app creation.
This article presents a comprehensive guide to improving Taro mini‑program performance, covering initial render acceleration with prerender, update efficiency via baseLevel and CustomWrapper, long‑list handling using VirtualList and VirtualWaterfall, setData reduction techniques, scroll‑penetration prevention, preload strategies, and the upcoming CompileMode feature.
Taro is a cross‑platform development framework that lets developers write a single codebase using React‑like syntax to compile mini‑programs, H5 pages, and mobile apps, handling API differences, UI component translation, and performance optimizations such as prerendering.
This article presents a comprehensive set of performance optimization techniques for Taro mini‑program development, covering initial render improvements, update efficiency, long‑list handling with VirtualList and VirtualWaterfall, setData data reduction, scroll‑penetration prevention, preloading strategies, and an upcoming CompileMode feature.
This article explains why front‑end data‑collection (exposure) points are crucial, outlines three main techniques—estimating visibility from paginated data, listening to scroll events with bounding‑box calculations, and using the IntersectionObserver API—detailing their implementation, advantages, drawbacks, and best‑practice usage across H5, mini‑programs, and Taro.
Unlike Taro 1/2, which compiles React code into native mini‑program files through a complex Babel‑based pipeline, Taro 3 runs the original React source at runtime by injecting a lightweight simulated DOM/BOM layer, simplifying development but adding a performance‑overhead that is mitigated with pre‑rendering and virtual lists.
This article examines the business background and challenges of multi‑platform front‑end development, evaluates mainstream cross‑platform technologies, selects Taro as the optimal solution, and details its integration with existing React Native and Web stacks, component and API adaptation, CSS handling, performance testing, cost analysis, and future outlook.
This article explains the multi‑compiler kernel ecosystem behind Taro, detailing how Webpack, Vite and Metro kernels are integrated, the plugin system that unifies build processes across Web, App, mini‑program and Harmony platforms, and the performance gains and challenges of this approach.
Over two years, NetEase Yanxuan built and open‑sourced OSSA, a Taro UI component library created to unify multi‑platform mini‑program development, detailing why Taro was chosen, the challenges of enterprise‑grade reliability and community building, and how automated CI/CD, documentation, MIT licensing, and contributor guides enable sustainable open‑source growth.
The article describes building a Taro component library whose components, documentation and live demos are generated from a single Markdown source, using Rollup‑built ES modules, a Vite‑based static site, a custom webpack markdown loader, and an isolated H5 demo project to ensure maintainable, reusable code and synchronized documentation.
The article presents Taro‑CRN, a low‑cost, Taro‑compatible framework built by Ctrip to enable seamless cross‑platform development of mini‑programs and native apps, detailing its architecture, plugins, integration steps, code examples, and suitable use cases for frontend teams.
This article details how the NutUI‑React component library was adapted to the Taro framework for WeChat mini‑programs, covering background, version upgrades, three development stages, key technical solutions, installation steps, and future community‑driven improvements.
This article analyzes the rapid growth of mobile mini‑programs, compares the cross‑platform frameworks uni‑app and taro based on core requirements, ecosystem, and performance, presents a concrete project structure and rendering details, and quantifies the efficiency gains achieved by adopting uni‑app for automotive quotation services.
This article introduces NutUI, JD's lightweight mobile component library now supporting JD mini-programs, compares H5 and mini-program development, and provides a step‑by‑step guide using Taro to quickly set up and run a NutUI‑based JD mini‑program project.
This article explains how to upgrade Taro 2.x projects to Taro 3.x by converting source code into an AST using Babel, programmatically editing imports, configs, routers, and styles, and then generating the updated code, complete with practical code examples and migration tips.
This tutorial walks through building a Taro mini‑program that connects to a BLE heart‑rate strap, discovers services and characteristics, reads device name and heart‑rate measurements, and handles data conversion, providing code examples and practical insights for mobile developers.
This article describes how a one‑code‑multi‑end interactive engine was built by selecting the Taro framework, adapting H5 design, creating a unified data‑management layer, defining a generic development model, handling UI adaptation, animation, and engineering concerns to improve development efficiency across web, mini‑program and app platforms.
The article explains why React is well‑suited for cross‑platform dynamic development, detailing its data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, Taro reconciler adaptations, and independent event system, and shows how React can serve as both a DSL and a full runtime for mobile and web.
The article explains how React’s data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, independent event system, and adaptations such as React Native and Taro enable efficient cross‑platform dynamic applications, and provides code examples and practical guidance for developers.
The article explains how React’s data‑driven model, JSX‑to‑virtual‑DOM workflow, fiber architecture, independent event system, and adaptations in frameworks like React Native and Taro enable efficient cross‑platform dynamic applications, while comparing it with traditional template‑based approaches.
This article presents a curated collection of twelve noteworthy open‑source WeChat mini‑program projects—including e‑commerce, UI component libraries, music, library, and development frameworks—detailing their main features, GitHub stars, and links to help developers explore and learn from real‑world examples.
This article examines performance bottlenecks in a Taro3-based hotel list page, presents measurement data, and details multiple optimization techniques—including preload API, setData reduction, node count trimming, animation refactoring, data flattening, virtual list enhancements, custom wrapper usage, native components, and React.memo—to significantly improve rendering speed and user experience.
This article presents Ctrip's Taro cross‑platform solution for mini‑programs, detailing the motivation behind multi‑platform development, the technical selection of Taro 3, the modular plugin architecture, repository management with git submodules, CI/CD pipelines, and the overall benefits for code reuse and development efficiency.
After three years of development, NetEase Yanxuan has open‑sourced OSSA, a TypeScript‑based, Taro‑powered UI component library that delivers over 30 cross‑platform components for WeChat, Alipay, ByteDance mini‑programs and H5, featuring monorepo management, on‑demand imports, automated testing, and a community‑driven roadmap.
The article defines T‑level interactions—high‑traffic, high‑revenue e‑commerce events—and outlines how using the Taro framework, a unified H5 and mini‑program development stack, combined with a custom component library, automated testing, and robust error‑handling strategies can dramatically improve development efficiency, consistency, and reliability across massive seasonal campaigns.
The article details JD.com's store team initiative to unify multi-end rendering using Taro and JDHybrid, replacing RN with a unified front‑end solution that cuts development effort by up to 70%, improves first‑screen performance, and enhances ISV openness across apps, web, and mini‑programs.
Version 3.5 of Taro introduces a major compilation system overhaul with Webpack 5 support, module‑federation based dependency pre‑bundling, esbuild compression, and @swc/register, delivering faster builds, React 18 compatibility, SSR via a Next.js plugin, MPA and Expo‑based React Native enhancements, plus detailed upgrade steps.
This article explains the background, design goals, and step‑by‑step implementation of NutUI's theme and component‑level style customization, including online configuration, Sass variable handling, and integration examples for Vite, Webpack, and Taro projects.
The Taro open‑source project defines a clear contributor promotion system, outlining roles from individual contributors to technical steering committee members, detailing responsibilities, application procedures, voting mechanisms, team organization, and bi‑weekly meetings to sustain a sustainable ecosystem.
This article explains how the Taro framework enables unified multi‑platform front‑end development by describing its open architecture, plugin system, cross‑framework adaptation, browser‑like runtime, support for various mini‑program ecosystems, and upcoming Harmony integration, while sharing practical code examples and implementation details.
This post curates a variety of technical article recommendations covering frontend innovations like MDN's redesign, Taro, Vite, state‑based architecture, and drag‑and‑drop, plus backend Node.js streams, mobile Flutter, and cross‑platform insights for developers seeking to stay updated.
This guide explains why developers should join open‑source projects, how to choose Taro as a target, and provides a detailed, code‑rich workflow—from locating suitable issues and forking the repository to setting up the development environment, implementing fixes, testing, and submitting a pull request.
This guide explains why Taro 3 was chosen for unified development, outlines its architecture evolution, and provides step‑by‑step instructions—including CLI setup, script configuration, plugin usage, routing, versioning, API requests, and mixed‑mode packaging—to create a single codebase that runs on both H5 and various mini‑program platforms.
Taro v3.4 introduces official Preact support, expanded Vue 3.2 capabilities, extensive H5 performance and routing improvements, new defineAppConfig/definePageConfig macros, a list of bug fixes and breaking changes, plus a step‑by‑step upgrade guide for developers.
This guide explains how to use the Taro framework to develop and adapt applications for Huawei's HarmonyOS, covering background, key differences with mini‑programs, the compatibility plugin, configuration steps, required tooling, and how to build and run a HarmonyOS project.
The article introduces major updates to the Taro React Native open‑source project, including a new react‑native template, GitHub Actions integration for automated builds, a Taro Playground app for debugging, and detailed CI/CD configurations to lower entry barriers for mobile app development.
This article details a real‑world project that used Taro, Vue 3, and NutUI 3 to build a cross‑platform e‑commerce solution supporting web, H5, and various mini‑programs, covering background analysis, technology comparison, implementation details, performance testing, theme customization, routing challenges, and optimization lessons learned.
This article introduces the Taro framework, explains why it simplifies multi‑platform mini‑program development, compares it with alternatives, details its design and compilation principles, provides code examples and project setup steps, and shares best practices for platform‑specific adaptations.
This article explains Taro 3's shift from a compile‑time heavy architecture to an interpretive runtime, detailing its JSX compilation drawbacks, the new runtime design that supports multiple frameworks, the implementation of a custom React reconciler, Web Components via Stencil, and how these changes improve cross‑platform development performance and flexibility.
This article examines the performance bottlenecks of a Taro3 mini‑program list page after migrating from Taro1, analyzes causes such as excessive node rendering and large setState payloads, evaluates backend pagination and the built‑in virtual list, and presents a custom virtual‑list implementation that reduces rendered nodes, uses screen‑height placeholders, and achieves roughly 45% faster rendering and 50% quicker interaction response.
This article introduces NutUI 3.0’s multi‑end capabilities, explains how it integrates with Taro to enable Vue 3 developers to write a single codebase for H5 and various mini‑program platforms, and provides step‑by‑step installation and usage examples.