This article explains the Flutter widget lifecycle, covering the differences between StatelessWidget and StatefulWidget, detailing each lifecycle method, providing a runnable demo with code and logs, and discussing app‑level lifecycle handling and common pitfalls for mobile developers.
This article explores the rapid rise of mobile cross‑platform solutions, explains why the Xueersi 1‑to‑1 team chose Flutter, and details their engineering practices—including project architecture, engine‑sharing strategies, unified routing, communication channels, and crash monitoring—while also looking ahead to future possibilities.
The article analyzes why Flutter crashes on iOS when accessing the GPU in the background, explains the official SyncSwitch fix for ImageDecoder, and details Xianyu’s additional patches for MultipleFrameCodec, EncodeImage, and Rasterizer::DrawToSurface that together, via PR #28383, fully resolve the GPU‑background crash.
This article explains how Xianyu tackled the challenges of rapidly delivering lightweight, dynamic pages by designing a stream‑based page container architecture that combines a platform‑side building system, MVVM client side, three‑layer protocols, event‑driven communication, and high‑performance list rendering in Flutter.
This comprehensive guide walks you through Flutter's drawing fundamentals, covering Canvas, Paint, Path, Color, and advanced techniques such as custom text outlines, image shaders, and animated wave effects, with clear code examples and practical tips for creating dynamic graphics in mobile apps.
The article compares the view‑and‑layer tree architectures of iOS, Android, Web, and Flutter, explaining iOS’s UIView/CALayer hierarchy, coordinate system, and model‑presentation‑render trees, while detailing Flutter’s widget, element, render‑object, and layer trees, and highlighting their shared parse‑layout‑render pipeline and differing animation approaches.
These articles compare how Web, Android, iOS, and Flutter represent UI structures—detailing the DOM and Virtual DOM creation, diffing, and rendering on the Web, and the XML‑based layout inflation, view hierarchy, styling, and drawing pipeline on Android—to help front‑end developers grasp each platform’s tree‑based architecture.
This article examines the cause of jank in a vertically scrolling Flutter list page on low‑end Android devices, explains the rendering pipeline and build‑layout‑paint stages, and presents a frame‑splitting optimization using the keframe package that reduces frame time and improves smoothness, with performance data.
This article investigates why text in Flutter buttons often fails to vertically center, analyzes Android font metrics and NotoSansCJK details, explores native Android solutions like includeFontPadding and Paint.getTextBounds, and proposes a Flutter implementation using minikin layout to achieve precise vertical centering.
This tutorial explains how to incorporate third‑party AAR files into a Flutter plugin, configure the Android host project, address the bundleReleaseAar build error, and successfully build a Flutter application APK.
Flutter is chosen for cross‑platform development because its single‑code Dart framework uses a self‑rendering engine and layered architecture—embedder, engine, and framework—to bypass JS bridges, delivering high‑performance, consistent UI via a GPU‑driven pipeline with layout, painting, and compositing optimizations.
This article details how Enterprise WeChat tackled the challenges of five‑platform UI development by adopting Flutter, describing its multi‑module architecture, hybrid stack engine management, communication via pigeon and dart‑ffi, performance optimizations, tooling, and dynamic‑loading strategies that enabled large‑scale cross‑platform deployment.
This article explains the thread‑merging problem that arises when using PlatformView in multi‑engine Flutter scenarios, analyzes its root causes in both independent and lightweight engines, and presents a comprehensive solution—including code changes, task‑queue merging logic, and practical implementation details — that has been merged into the official Flutter engine repository.
Xianyu’s Flutter team defines a custom lint configuration in analysis_options.yaml, selecting stable rules from effective_dart, pedantic, flutter_lints and lints to enforce concise syntax, safe null handling, explicit typing, consistent style, and proactive quality checks, supported by CI enforcement and team‑wide consensus.
Flutter determines which widget handles a pointer by converting raw data into PointerEvents, hit‑testing the widget tree, and routing events through a GestureArena where recognizers compete, as illustrated by an image viewer that resolves conflicts between pinch‑zoom and horizontal drag using custom recognizers and boundary‑aware scrolling.
This article explains the Flutter soft‑keyboard invocation flow on Android and iOS, analyzes page‑repaint and animation problems such as stutter on specific devices, and presents practical fixes including performance flags, MediaQuery handling, and native input adjustments.
This article explains the design and implementation of a pure‑Dart Lottie animation library for Flutter, covering its architecture, data parsing, rendering pipeline, code examples for both Android and Flutter, performance comparisons, and future plans for interactive features.
This article explains the thread‑merging problem that arises when using PlatformView in Flutter’s multi‑engine setups, analyzes the root causes in both independent and lightweight engines, and presents a comprehensive solution that modifies the engine’s task‑runner merging logic to support one‑to‑many merges.
This comprehensive guide walks you through installing the Flutter SDK, configuring environment variables, creating projects and modules, understanding declarative versus imperative programming, exploring Flutter's three-layer architecture, rendering pipeline, platform channel integration, and provides a full counter‑app example with recent version highlights.
This article introduces Kraken, a high‑performance, Flutter‑based web rendering engine, detailing its technical background, architecture, bridge implementations, key performance optimizations, extended widget support, and debugging tools, while comparing its rendering flow with traditional WebView and Flutter pipelines.
Kraken is an open‑source, high‑performance web rendering engine built on Flutter that implements W3C standards, leverages a three‑generation bridge for C++‑Dart communication, supports SSR, sliver layout, extensible plugins, and provides Chrome DevTools debugging, aiming to unify front‑end and Flutter ecosystems for faster, consistent cross‑platform development.
This article details concrete techniques for reducing Flutter app memory consumption, focusing on image cache sizing, resource cropping, local caching, asset compression, cache thresholds, and page‑stack management, while providing step‑by‑step experiments, code snippets, and visual illustrations to guide developers.
This guide explains how mobile developers can create a consistent, project‑level development environment by using Homebrew for package management, rbenv for Ruby version control, RubyGems and Bundler for dependency handling, and flutter‑wrapper to standardize Flutter SDK usage across the team.
The article describes how the MOO app team used Flutter's Dart VM Observatory and Allocation Profile tools to detect and fix an image memory leak caused by a custom painter not deregistering an ImageStreamListener, demonstrating step-by-step snapshot comparison, reference‑chain analysis, and the resulting memory stabilization after code fix.
The article details MOO Music’s experience with Flutter memory management, explaining the Dart heap, stack, and external memory structures, common leak sources such as missing listener deregistration, unbounded widget lists, retained timers, static references, and third‑party or engine bugs, and offers practical detection and optimization techniques.
This article guides developers through compiling, debugging, and analyzing the Flutter 2 Router source code, covering engine setup, architecture layers, key initialization classes, and practical steps to run a custom Flutter engine on Android and iOS.
This article provides a comprehensive overview of Flutter for Web, detailing its architecture, development workflow, code structure, performance considerations, and the advantages and drawbacks of using a single codebase to target mobile and web platforms.
This article explores the underlying font metrics and layout algorithms that cause text vertical misalignment in Flutter, analyzes Android native solutions like includeFontPadding and getTextBounds, and demonstrates how to implement a precise forceVerticalCenter feature by leveraging Minikin and Skia rendering pipelines.
This article recounts Xianyu's pioneering adoption of Flutter since 2017, detailing the technical, organizational, and cultural challenges they faced, the lessons learned from hybrid architecture and open‑source efforts, and why rumors of abandoning Flutter are unfounded as they continue to invest in the technology.
This article explains Flutter 2's new multi‑engine Add‑to‑App approach, walks through creating an Android project with a Flutter module, shows how to manage engines with FlutterEngineGroup, and compares multi‑engine and single‑engine hybrid solutions in terms of memory and performance.
At Hello Travel, the team detailed how Flutter’s three‑layer architecture and two custom containers—Sparrow Microservice Container and Lumos Cross‑Platform Business Container—enable rapid exposure of native core functions, seamless integration of business logic, and consistent, high‑performance mobile development across more than nine business lines.
Kraken 0.8.0 introduces Flutter 2.2.2 compatibility with Dart Null Safety, boosts first‑paint performance by 10% through Bridge optimizations, enhances Flexbox layout speed, adds new HTML tags and CSS units, fixes numerous bugs, and outlines upcoming features like QuickJS and SSR support.
This article explains why integrating a Flutter AAR into an Android project that already contains a Flutter app causes version, class, native library, and resource conflicts, and presents a comprehensive solution using custom class loading, library renaming, and resource isolation to enable seamless coexistence.
Xianyu pioneered Flutter adoption in 2017, overcoming internal resistance and architectural gaps by creating the AliFlutter community and a hybrid Flutter Boost stack, successfully migrating its main app, learning from early open‑source missteps to improve documentation and APIs, and now commits to three more years of Flutter development while preparing for future cross‑platform ecosystems.
This article details a Flutter‑based solution for automatically tracing Chinese characters, covering data preprocessing, SVG‑to‑coordinate conversion, scaling, Y‑axis inversion, translation, centering correction, and smooth stroke animation with frame‑rate optimization.
This article explains how MobX implements data binding and update mechanisms in Flutter, compares it with other state‑management frameworks, walks through the internal Observer‑Atom‑Reaction workflow with code examples, and presents common pitfalls and best‑practice recommendations for mobile developers.
This article explains how Flutter loads and caches images, analyzes the underlying source code of key classes such as PaintingBinding, ImageCache, ImageProvider, and RenderImage, and provides practical techniques for reducing memory usage and preventing OOM in large Flutter applications.
This talk explains how Vue.js can be leveraged to create high‑performance Flutter applications by bridging front‑end ecosystems with W3C‑based rendering, addressing the challenges of Dart‑centric development and showcasing the Kraken engine's role in achieving consistent multi‑device experiences.
This article explains how the growing need for cross‑platform development, especially with IoT devices, makes Flutter popular yet costly, and introduces a W3C‑standard‑based solution that uses Vue.js and the Kraken engine to connect front‑end ecosystems with consistent multi‑device rendering.
FlutterBoost 3.0 preview, released after two months of development and testing, introduces refactored lifecycle management, enhanced cross‑platform consistency, custom startup and return parameters, page transparency, custom event handling, pre‑interceptors, and expanded documentation with examples, while maintaining the existing architecture and focusing on community adoption.
The Xianyu instant‑messaging system, burdened by years of technical debt, was rebuilt with a Flutter‑centric, four‑layer architecture that shares FlutterEngine instances, introduces an entity cache and custom ORM, simplifies synchronization, and delivers up to 40 MB memory savings, lower power use, reduced CPU load and roughly half the development and testing effort.
This article details how a video editing page built entirely with Flutter and Redux can overcome state, logic, UI, and performance complexities through architectural decisions, time‑range handling, stack‑based rendering, thumbnail caching, and frame‑rate optimizations to achieve native‑level performance on mainstream devices.
Lumos Hybrid Stack leverages Dart and Flutter to unify iOS and Android business logic, cutting duplicated development effort, accelerating debugging, and saving person‑days while providing a consistent, extensible architecture, performance monitoring, and a communication protocol that paves the way for future centralized state‑management across platforms.
This article details Kuaishou's Flutter audio-video implementation, optimization practices, and engineering support, covering video playback via external textures, data communication strategies, FFI integration, and performance tuning.
This article details how Kuaishou’s Fast Creation team leveraged pure Flutter to implement complex audio‑video features such as playback, editing, and live streaming, describing the challenges of UI, state, performance, and data communication, and presenting optimization techniques like external textures, FFI, thumbnail caching, and frame‑rate improvements.
The article explains that Flutter Driver and Integration Test struggle to locate elements in hybrid native‑Flutter apps, then describes Xianyu’s approach of extending native UI automation with OCR, image‑matching, and a layered page‑object architecture, achieving over 98% success across 500+ runs.
This article introduces Kaiyan Kuaichuang's Flutter‑based cross‑platform architecture, covering component layering, state‑management strategies (BLoC, Provider, Redux, Built_redux), data communication via gRPC/ProtoBuf, and a custom URL‑based routing solution, while sharing practical code snippets and lessons learned.
This article explores how Kuaishou Creative leverages Flutter for cross‑platform development, detailing its componentized architecture, page‑level and inter‑page state management approaches, data and page communication mechanisms, and the custom routing solution that unifies navigation across the app.
This document presents VM-Mapping, a solution for cross-scene data synchronization in mobile apps, addressing fragmented business scenarios and inconsistent UI states through annotation-based object mapping and data-driven UI updates.
This tutorial explains step‑by‑step how to create a custom iOS Flutter plugin for audio playback, covering the MethodChannel architecture, Dart side implementation, Swift native code, and communication of playback controls and status between Flutter and iOS.
The article examines the missing gesture capabilities in current web standards, compares implementations across Kraken, hammer.js, Flutter, iOS, and Android, and argues for a unified, high‑performance, and easy‑to‑use gesture specification to improve web development.
This article details the performance challenges of large‑scale Flutter apps and presents a series of practical optimizations—including module‑level hybrid rendering, native‑side data prefetch with FFI, multi‑level caching, and resource compression—that together reduced home‑page startup time by more than one second.
In 2020 I reflected on my role as a front‑end engineer working with a mixed‑tech team on Alibaba's Xianyu content creator business, detailing how I built the team, set goals, made data‑driven decisions, and delivered front‑end innovations such as a rule engine, Flutter expansion, backend tooling, and container strategy.
Since 2017 Xianyu’s small engineering team has pioneered Flutter adoption—creating the Flutter Boost engine, hybrid stack calls, and packaging solutions—to achieve near‑native performance across iOS and Android, overcome early ecosystem gaps, and now positions Dart‑first development as a scalable, cost‑effective choice for large‑scale front‑end products and future enterprise apps.
The article compares Flutter’s native interaction methods, explaining how Platform Channels use message codecs and thread switching for method calls, while FFI lets Dart directly invoke C functions, offering superior performance but more boilerplate, and discusses trade‑offs, implementation details, and a benchmark showing the speed gap.
This roundup presents a selection of recent technical articles covering the Node.js 16 release, front‑end performance optimizations, CSS @property advances, WebRTC transport protocols, game‑engine dark‑mode implementation, Babel deep‑dive, and a new Flutter‑based web rendering engine, each linked for further reading.
To streamline app quality assurance, a comprehensive mobile bug‑reporting SDK was built that automates screenshot, screen‑recording, network and log collection, auto‑fills device and app data, and integrates with the Max backend, reducing feedback latency and simplifying the reporting workflow for developers and testers.
This article explains how ZhiZhuan's mixed Flutter‑native app architecture is incorporated into the Beetle DevOps platform, detailing Beetle's branch types, the release process for Flutter modules, and component management strategies that improve multi‑module coordination and deployment quality.
Flutter 2 transforms the framework into a true multi‑platform solution by adding stable desktop (Windows, macOS, Linux) and web support, introducing dual‑screen widgets, sound null‑safety, stable FFI, and tooling upgrades, while highlighting migration challenges and future enhancements.
This article explains how to create a custom ADHoc build configuration in Xcode for a mixed Flutter and iOS project, covering steps such as duplicating Debug/Release configurations, adjusting bundle identifiers, app names, push SDK parameters, certificates, user‑defined settings, and integrating the changes into Flutter’s build scripts and CI pipelines.
This article explains what Flutter packages and plugins are, how to create them via IDE or command line, the required file structure, how to publish them to pub.dev, private registries or Git, and how to add them as dependencies in a Flutter project while also covering common troubleshooting steps.
FlutterBoost 3.0 streamlines hybrid app development by providing a non‑intrusive engine integration that works with any Flutter SDK, halving code size, unifying Android and iOS APIs, allowing optional page containers, delivering precise lifecycle events, and fixing legacy issues, all with a simple dependency setup.
The article introduces Thresh, a self‑developed dynamic Flutter framework that enables one‑time development for Android, iOS and Web, explains its design goals, architecture, three‑stage evolution of mobile cross‑platform technologies, communication mechanisms, component update strategies, engineering practices, real‑world deployment at Manbang, and future enhancements.
This article analyzes the theoretical and measured performance differences of inertial scrolling among Web (Chromium), native Android, and Flutter, explains the underlying rendering mechanisms that cause Flutter’s lag, and outlines engine‑level optimizations that bring Flutter’s scroll smoothness close to native levels.
The article explains how to implement dynamic domain name switching in mobile apps across iOS, Android, Flutter, and H5 by using a configuration center and native network interception techniques such as NSURLProtocol, OkHttp instrumentation, texture bridging, and frontend configuration to resolve regional DNS issues and enable extended features like request statistics and custom responses.
This article explains how to configure product flavors in a Flutter Android project, create multiple entry files for each flavor, detail the underlying Gradle and Flutter build commands, and analyze a case‑sensitive SDK bug with practical solutions for successful APK generation.
Beike adopted Flutter to address rapid growth and staffing shortages, achieving over 80% hybrid development, native‑like performance, one‑second hot‑reload cycles, extensive community package usage, and a systematic Flutter infrastructure across dozens of mobile applications.
This article explains how to create a Flutter-based color‑picker utility that captures the current screen, extracts pixel colors at any touch point, and displays a magnified view with the selected color, providing a practical solution for UI verification and design‑developer communication.
TRouter is a hybrid stack routing framework for Flutter that reuses a single engine through native Activity/ViewController containers, offloading page transitions and URL parsing to the native layer, clearing iOS view bitmaps and applying bytecode‑hooked Android fixes to dramatically reduce memory usage while keeping native modifications visible, low‑risk, and compatible with multiple Flutter SDK versions.
This article details Meituan Waimai's front‑end team experience of using Flutter Web to create a unified code base for Android, iOS, PC and H5, covering business and technical background, challenges, overall and detailed design, performance optimizations, build‑and‑deploy pipelines, and measurable results.
To enable mixed‑span waterfall layouts in Flutter, we built a custom FlowView that mimics RecyclerView’s StaggeredGridLayoutManager, handling normal and full‑width cards by dynamically selecting the shortest or tallest column, recycling off‑screen items, and achieving performance comparable to native GridView, now deployed in Xianyu’s home and search pages.
FlutterWorker is a Dart‑based cross‑platform logic framework that runs client‑side processing for Xianyu’s mobile app, unifying data handling across iOS, Android and Flutter, reducing server‑side BFF reliance, cutting memory and CPU overhead, improving latency by about five percent, and dramatically increasing development efficiency.
Xianyu, Alibaba’s C2C platform, transformed its massive legacy system into a cloud‑native, serverless architecture—integrating Flutter, a unified development framework, and a suite of tools like Nexus API and GCLI—to dramatically cut development cycles, lower operational costs, and support a GMV of over 2 trillion yuan.
This week’s developer roundup covers Google’s Flutter 2 launch, JD Cloud’s next‑gen server, Apache Flink 1.12.2 bug‑fix release, sidewalk robots classified as pedestrians, Microsoft Mesh mixed‑reality platform, Facebook’s self‑supervised SEER model, plus recent AI research from EMNLP and COLING conferences.
This article examines the difficulties of embedding Flutter in Android apps—such as multiple FlutterEngine instances, lifecycle mismatches, and page‑stack inconsistencies—and presents MixStack, a solution that shares a single engine, corrects rendering lifecycles, and provides a unified page‑container model, validated in production.
The study compares four image‑blur approaches for a Flutter music app—real‑time BackdropFilter, CPU‑intensive StackBlur, server‑side GaussianBlur, and compact BlurHash—showing that BackdropFilter causes frame‑rate stutter, StackBlur adds decode overhead, server GaussianBlur offloads work with caching benefits, while BlurHash minimizes storage at the cost of visual fidelity, guiding developers to select the method that fits their performance and quality needs.
The article examines why adding Flutter to an iOS app inflates the binary, breaks down the framework’s largest parts—engine, AOT snapshot, assets, and ICU data—and details a three‑pronged strategy of compression, externalization and stripping, using custom build scripts to move or delete files and dynamically load data, achieving roughly a 12 MB size reduction.
This article curates a collection of actively maintained high‑fidelity clone projects for popular apps—including WeChat, Zhihu, TikTok, Bilibili, Meituan, and more—showcasing the tech stacks (Flutter, Vue, React, Node.js, etc.), core features, screenshots, and direct GitHub links to help developers learn and build similar applications.
Flutter converts native MotionEvent data into a serialized ByteBuffer, passes it through JNI to the engine, creates a Dart PointerDataPacket, hit‑tests the render tree, dispatches the event to each hit object, and resolves competing GestureRecognizers in the arena so the winning recognizer triggers the appropriate callback such as onTap or onDrag.
This article explains Flutter widget communication techniques—direct value passing, function callbacks, key modification, and GlobalKey—and explores state management solutions including InheritedWidget, Stream, EventBus, Bloc, Scoped_model, Provider, and Redux for cross-widget/page communication, and discusses their underlying principles and usage scenarios.
Xianyu’s streaming page container architecture redesigns the Flutter home page with an MVVM‑based, event‑driven framework, DinamicX DSL templates, and the PowerScrollView list container, eliminating duplicated layout logic, accelerating A/B testing and releases, and enabling dynamic, lightweight pages with partial UI refreshes.
This article describes how the JAYE 2.0 project at Beike leverages abstract syntax tree (AST) generation, a custom runtime interpreter, and Dart VM execution to achieve high‑performance, hot‑fixable dynamic updates for Flutter applications, addressing packaging, hot‑reload, and scalability challenges.
Meituan’s MTFlutter team rebuilt Flutter’s embedder layer for HarmonyOS by simulating VSync, creating a SurfaceProvider‑based rendering surface, forwarding touch, key and speech events, and re‑implementing asset loading, message loops and lifecycle callbacks, allowing Flutter apps to run on phones, tablets, TVs and wearables.
This article explains how the exhibition cloud platform leverages Google Flutter for cross‑platform mobile development, detailing its architecture, engine components, integration methods, Platform Channel communication, and the efficiency gains observed in a real‑world trade‑fair app.
PowerScrollView is a high‑performance Flutter flow‑layout framework that composes section‑based slivers for lists, grids and waterfalls, adds automatic exposure, scroll‑to‑index, fine‑grained refresh and element‑reuse optimizations, and uses frame‑by‑frame rendering to deliver smooth scrolling across Xianyu’s core pages.
This article evaluates Flutter image performance by comparing view reuse, disk‑cache reuse, and memory‑cache reuse strategies, detailing implementation hurdles, and ultimately finds that a Texture‑based approach offers fast communication yet consumes more memory than the native Image widget’s on‑demand decoding.
By examining Flutter’s Dart‑based runtime, cross‑platform GUI framework, and productivity features such as hot‑reload, the article maps these technical strengths to core front‑end challenges—remote communication, state and UI management, and lifecycle handling—offering developers a structured perspective for strategic adoption and future innovation.
This talk explores a cost‑effective cross‑platform strategy that shares only business logic—using Dart, TypeScript‑to‑Dart transpilation, and a Hooks‑like abstraction—to achieve high performance on mobile and web while reducing coordination overhead.
This article explores the history and current state of cross‑platform development, covering PC, mobile, IoT, Web, Hybrid, Weex, React Native, and Flutter, and discusses how developers can balance performance, user experience, and development efficiency across diverse devices.
This article outlines Zhenkun's mobile engineering journey from 2020 to 2021, detailing the shift to componentized architecture, the adoption of Flutter hybrid development, CI automation, and real‑time monitoring to boost development efficiency and product quality.
This article introduces the Daojia App general development framework, detailing its evolution, componentization challenges and solutions, layered architecture, cross‑platform strategy with Flutter, and its practical application in the Jiazheng Cloud project to improve development efficiency and maintainability.
The article walks through the complete workflow for building a Flutter plugin—using native_image_view as an example—including platform channel communication, Dart and native (iOS/Android) implementation, testing via an example app, and publishing to public or private Pub repositories.
This article introduces Ke‑FUT, a home‑grown Flutter UI automation solution that leverages VMService and InspectorService to obtain element IDs, generates stable IDs via a custom IdGenerator, and drives view interactions through a Python‑based FUTClient, providing a low‑cost, cross‑platform testing approach for mobile apps.
The article reviews Taobao's Mini‑Program Creative Interaction project, detailing its evolution, technical architecture, engine migration, rendering design, task system, practical use cases, and future directions, illustrating how game technologies are integrated into e‑commerce mini‑programs.
This article explores the evolution of cross‑platform technologies—from early PC and mobile web solutions to modern frameworks like Weex, React Native, and Flutter—highlighting their benefits, challenges, and the ongoing quest for performance, consistency, and development efficiency across diverse devices.
The Xianyu team optimized their Flutter‑based app by creating a lag‑diagnosis tool, minimizing unnecessary widget rebuilds, deferring load‑more updates, using low‑resolution placeholders, prefetching data with skeleton screens, reusing FlutterBoost containers and early data passing, which together cut jank by half, shaved ~300 ms off page loads and raised average FPS by about three points on low‑end devices.
This article explains Flutter's animation system, covering core concepts like Animation, AnimationController, CurvedAnimation, Tween, and listeners, then demonstrates basic and combined animations, introduces system widgets such as AnimatedContainer and AnimatedCrossFade, and shows how to create custom page transitions with PageRouteBuilder and Hero.
The article dissects Flutter’s tree‑shaking process within the engine—tracing the compilation pipeline from GenSnapshot through AOT phases, showing how unused methods and resources are identified, retained or discarded, and finally obfuscated, thereby enabling dead‑code elimination, smaller binaries, and seamless Flutter‑FaaS integration.
This article details JDFlutter's evolution as a one‑code, container‑based cross‑platform framework that tackles Flutter's ecosystem gaps, improves development efficiency, enables dynamic updates, web conversion, iOS size reduction, mixed native integration, and provides a full‑stack support pipeline for large‑scale mobile apps.
The article details how Xianyu improved long‑list scrolling smoothness on both native Android and Flutter by building a cross‑platform frame‑jank detection tool, applying async view‑caching and unbinding in Android, and using repaint boundaries, clipping tweaks, time‑slicing and custom scroll physics in Flutter, achieving up to 57 FPS and halving big‑jank counts on low‑end devices.