fzyzcjy/flutter_smooth

This system is a Flutter plugin library designed to maintain 60 FPS performance by intercepting and optimizing the rendering pipeline for lists, page transitions, and custom builders. It provides native platform bridges for precise timing synchronization and includes a comprehensive suite of development tools, such as automated testing utilities and performance analysis scripts, to facilitate debugging and validation. The project also features a documentation website that aggregates community feedback and technical design discussions.

The \packages/smooth/example/macos\ directory now contains a complete macOS project scaffold, including the Xcode project, workspace, and scheme files, along with native Swift entry points (\AppDelegate.swift\, \MainFlutterWindow.swift\) and configuration files. This setup enables the smooth package to be built and tested as a native macOS application, with the generated plugin registrant explicitly registering \path\_provider\_macos\ to support file system operations on the platform.

packages/smooth/example/macos · high confidence

The example application now includes the native project files required to build and run on Linux and Windows. This adds the CMake build configurations, GTK-based application entry points for Linux, and Win32 window management with DPI scaling for Windows, enabling developers to test the package on desktop platforms directly.

packages/smooth/example/android, packages/smooth/example/linux, packages/smooth/example/windows · high confidence

The scripts directory now includes a new Python package structure with a utils module. This module provides a run\_command helper function that executes shell commands and prints them to the console, along with a path utility to determine the repository base directory. A .gitignore file has also been added to exclude Python bytecode and IDE files from version control.

scripts · high confidence

The example app now includes a new page that reproduces Flutter's official list\_text\_layout benchmark scenario. This page allows users to toggle between a standard ListView implementation and one wrapped in SmoothBuilder to compare performance, specifically noting that visual cues for smoothness should be verified via timeline tracing rather than direct observation.

_packages/smooth/example/lib/example\_list\_text\layout · high confidence

A new Pigeon configuration file has been added to define the \SmoothHostApi\, which exposes a single method \pointerEventDateTimeDiffTimeStamp\ to the host platforms. This change generates the necessary Dart, Java, and Objective-C bindings to allow the Flutter side to query the time difference between pointer events and system time on Android and iOS.

packages/smooth/pigeons · high confidence

The example application now includes several new utility components in the \utils\ directory to support testing and demonstration. \AutoStartSlideTransition\ provides a slide transition that automatically plays on initialization, while \ComplexWidget\ generates a large list of \ListTile\ items wrapped with \SmoothBuildPreemptPointWidget\ and \SmoothLayoutPreemptPointWidget\ for performance benchmarking. \CounterWidget\ displays a rotating box and a counter, utilizing \RepaintBoundary\ to isolate rendering for debugging. Additionally, \DurationRecorder\ and \DurationRecorders\ offer simple tools for tracking and reporting execution durations, and \PageUtils\ provides a helper to build navigation rows.

packages/smooth/example/lib/utils · high confidence

The example package now includes the standard web scaffolding files (\index.html\ and \manifest.json\), enabling the app to be served and installed as a web application. The HTML file configures the Flutter engine loader and base href, while the manifest defines the app name, theme colors, and icons for PWA support.

packages/smooth/example/web · high confidence

The Android side of the smooth plugin now exposes a native API that calculates the difference between the system date-time and the uptime clock (in microseconds). This capability is implemented via Pigeon-generated message channels, allowing Flutter code to query this specific timing offset directly from the native layer.

packages/smooth/android · high confidence

A new script in \scripts/generation/comments/transform\ now aggregates and normalizes comments from GitHub issues, Google Docs, and Discord into a unified format. The tool reads raw JSON data for each source, applies specific transformation logic (such as handling Discord image attachments or GitHub issue titles), maps internal author names to consistent identifiers, and outputs a single Markdown file (\\_conversation\_generated.mdx\) containing structured \\<DiscussionComment\>\ components for use in the documentation site.

scripts/generation/comments/transform · high confidence

The example app now initializes the SmoothWidgetsFlutterBinding and enables frame debug banners to assist with development. It wraps the application in SmoothParent to integrate the smooth rendering system and includes a navigation menu for ListView, Page transition, and List text layout demos. A new TestPage demonstrates the SmoothBuilder widget, and the demo is configured to exclude semantics to improve performance with large amounts of text.

packages/smooth/example/lib · high confidence

The \packages/smooth\ directory has been added as a new Flutter plugin package. It provides a solution to maintain smooth frame rates (\~60 FPS) even when the widget tree is heavy to build or layout, offering drop-in replacements like \SmoothListView\ and a flexible \SmoothBuilder\. This initial release includes the package structure, configuration files (such as \analysis\_options.yaml\ and \.metadata\), and documentation, while noting that the underlying framework and engine changes are being developed in separate Flutter pull requests.

packages/smooth · high confidence

The new \smooth\_dev\ package has been added to the repository, providing the foundational structure for the flutter\_smooth library. This release includes the core package metadata, a \.gitignore\ file tailored for Flutter/Dart development, and an \analysis\_options.yaml\ configuration that enforces strict linting rules (such as \strict-casts\ and \strict-inference\) via the \lint\ package. The package also contains initial documentation in \README.md\ and \CHANGELOG.md\, outlining the library's purpose of achieving smooth 60 FPS performance through drop-in replacements like \SmoothListView\ and flexible builders, while noting that the underlying framework changes are currently being submitted as upstream Flutter PRs.

_packages/smooth\dev · high confidence

The repository has been initialized with core project files, including a README describing the flutter\_smooth package's goal of achieving \~60 FPS, a CHANGELOG, a MIT LICENSE, and standard governance documents (CODE\_OF\_CONDUCT, CONTRIBUTING, SECURITY). It also includes a .gitignore, an .all-contributorsrc configuration for tracking contributors, and a git submodule pointing to a 'blob' repository for static assets.

(repo-wide) · high confidence

The website directory has been initialized with a new Docusaurus static site generator configuration. This includes the core \docusaurus.config.js\ setting up the 'flutter\_smooth' documentation site with GitHub Pages deployment, Algolia search integration, and Tailwind CSS support via a custom plugin. The entry also adds necessary build configuration files such as \babel.config.js\, \tailwind.config.js\, \tsconfig.json\, and a \sidebars.js\ file that defines the initial documentation structure (including sections for Usage, Benchmark, and Design).

website · high confidence

The new \packages/smooth/lib/smooth.dart\ entry point exposes a suite of smooth-rendering utilities, including \SmoothListView\ and \SmoothShift\ for list interactions, \SmoothBuilder\ for custom rendering logic, and \SmoothBrakePoint\ for performance debugging. It also provides infrastructure bindings like \SmoothWidgetsFlutterBinding\, point tracking via \SmoothPoint\, and preemptive build/layout widgets (\SmoothBuildPreemptPointWidget\, \SmoothLayoutPreemptPointWidget\), alongside time utilities and page route builders.

packages/smooth/lib · high confidence

A new \smooth\_dev\ package has been added to provide a collection of utilities designed for automated testing and development workflows. The package exports specific classes and extensions including \SmoothAutomatedTestWidgetsFlutterBinding\ for test bindings, \SpyBuilder\ for widget spying, \WindowRenderCapturer\ for capturing window renders, and various extensions for image and time handling, consolidating these tools into a single exportable module.

_packages/smooth\dev/lib · high confidence

This change introduces a new \SmoothListView\ widget and its supporting components (including \SmoothScrollController\, \SmoothScrollPhysics\, and \SmoothShift\) designed to provide enhanced scrolling behavior. It also adds a foundational infrastructure layer featuring an \Actor\ for preemptive rendering, \AuxiliaryTreePack\ for managing a secondary render tree, and \DualProxyAnimationController\ for animation handling. These additions enable the framework to intercept and modify the standard Flutter rendering pipeline, allowing for features like placeholder handling and custom ballistic simulations within list views.

packages/smooth/lib/src · high confidence

A new DiscussionComment component has been added to the website's UI, which renders individual discussion comments with styling provided by Tailwind CSS. The component now visually distinguishes the origin of each comment by displaying specific icons and labels for GitHub, Discord, and Google Doc sources, allowing users to quickly identify where a comment originated.

website/src/components · high confidence

The example app now includes a dedicated ListView demonstration page that allows users to toggle between standard and smooth scrolling behaviors. This demo provides specific configurations for testing, including options to enable debug headers that display layout performance counters, simulate workload delays to stress-test rendering, and control item creation behavior, giving developers a concrete way to observe and debug the smooth scrolling implementation.

_packages/smooth/example/lib/example\_list\view · high confidence

Added three new Python scripts to the repository: \scripts/analysis/simulations.py\ implements a \ClampingScrollSimulation\ class and associated plotting logic to visualize scroll physics (position, velocity, and derived metrics) using Matplotlib; \scripts/generation/comments/common.py\ provides utilities for reading and saving raw comment data, explicitly excluding the \retrieve\_time\ field from metadata to ensure data reproducibility; and \scripts/generation/readme\_video.py\ uses FFmpeg to crop, pad, stack, and apply color corrections (gamma, contrast, hue) to raw video inputs for generating README assets.

python · high confidence

A new Python module at scripts/generation/comments/gather has been added to collect discussion data from multiple sources. The script uses the GitHub CLI to fetch issue comments, the Discord Chat Exporter Docker image to export specific Discord channel ranges, and loads pre-exported JSON files for Google Docs comments. This tool consolidates these inputs into a unified raw data format for downstream processing.

scripts/generation/comments/gather · high confidence

The \smooth\_dev\ package introduces a suite of new components to support advanced testing scenarios. \WindowRenderCapturer\ and \WindowRenderPack\ enable capturing and verifying rendered frames against golden images with configurable toleration, addressing previous issues where auto-disposal was not correctly setting up captures. A new \SmoothAutomatedTestWidgetsFlutterBinding\ and associated mixins provide a test-specific binding that tracks frame numbers and validates timestamp consistency. Additionally, \AlwaysBuildBuilder\, \AlwaysLayoutBuilder\, and \AlwaysPaintBuilder\ widgets allow developers to force continuous rebuilds, layouts, or paints for debugging purposes, while \SpyBuilder\ offers callbacks for build and layout events. Supporting utilities include \TimeConverterTest\ for precise time handling in tests, \ProxyTestWindow\ for mocking window properties, and helper extensions for screen image creation and painter-based scene building.

_packages/smooth\dev/lib/src · high confidence

Added a new \scripts/analysis/timeline\ module containing utilities to parse Chrome DevTools trace events, synthesize diagnostic events (such as abnormal VSYNC durations, jank indicators, and preempt-render latency), and visualize scroll performance metrics including pointer events, smooth shifts, and frame offsets. Also added a \scripts/analysis/video\_to\_frame\ script to extract timestamped frames from video files using FFmpeg.

scripts/analysis, scripts/generation/comments · high confidence

The iOS side of the smooth package now includes a native Flutter plugin structure. This adds Objective-C and Swift entry points (SmoothPlugin) that register with the Flutter engine and delegate to a Swift implementation (SwiftSmoothPlugin). The plugin exposes a method channel named 'smooth' which currently returns the iOS system version. Additionally, autogenerated Pigeon code (messages.h/m) is included to support a host API for retrieving pointer event timestamp differences, establishing the native bridge for this capability.

packages/smooth/ios · high confidence

The default \main.dart\ file, which previously launched a standard Flutter demo application featuring a counter widget and a blue-themed Material app, has been deleted from the package. This removes the out-of-the-box sample UI and entry point from this specific library location, likely to clear the way for custom implementation or to prevent conflicts with other entry points in the project.

_packages/hello\package/lib · high confidence

The example package now includes an analysis\_options.yaml file that enforces stricter Dart language and linting rules. This configuration enables strict casts, inference, and raw types, treats several common issues (such as missing required parameters, unawaited futures, and missing returns) as errors, and activates specific linter rules like use\_super\_parameters and use\_enums. This change improves code quality and consistency for developers using or extending the example.

packages/smooth/example · high confidence

The scripts/generation module now includes automated tools to fetch open pull requests from the Flutter and Engine repositories and generate a status page (blob/doc\_generated/\_status\_generated.mdx) displaying their state and titles. Additionally, it updates the website documentation (website/docs/index.md) and package READMEs by injecting specific content, such as a video player component, into designated sections of the source README.

scripts/generation · high confidence

The example application in the \example\_page\_transition\ directory has been updated to include a dedicated demo for page transitions. It now features an \ExamplePageTransitionPage\ that lists two options: a standard Material transition and a smooth transition powered by \SmoothMaterialPageRoute\. Tapping the smooth option triggers a navigation to a second page that simulates loading latency with a placeholder, allowing users to visually compare the jankiness of the non-smooth route against the smoother experience provided by the library.

_packages/smooth/example/lib/example\_page\transition · high confidence

The website now uses a new global CSS file that establishes the Docusaurus Infima theme colors (primary blue) for both light and dark modes, integrates Tailwind CSS v3 utilities, and applies specific line-height and padding styles to discussion comments to improve readability.

website/src/css · high confidence

The iOS configuration files for the smooth package's example app have been updated to reflect its new identity. The bundle identifier was changed from com.example.helloPackage to com.example.example, and the app display name and bundle name were updated to 'Example' and 'example' respectively. Additionally, the build configurations now include the CocoaPods support files for both debug and release modes, ensuring proper dependency resolution.

packages/smooth/example/ios · high confidence

Added golden tests for the ExampleEnterPageAnimation demo; Added test utilities for animations, gestures, and widget lifecycle spying; Added unit and integration tests for SmoothListView and scroll physics; Added unit and widget tests for Smooth's frame scheduling and preemptive rendering logic; Added unit tests for binding, image, and time conversion logic; Added unit tests for the BrakeController and BrakePoint infrastructure; Removed default widget smoke test.

This change introduces the dependency manifests for the new 'smooth' Flutter plugin and its example app, including Android build configurations (Gradle 7.1.2, Kotlin 1.6.10) and iOS/macOS CocoaPods setup. It also adds the 'smooth\_dev' package for development tooling and initializes the Docusaurus-based website with React 17, Tailwind CSS, and Algolia search components. The example app's dependencies are updated to include 'clock', 'smooth', and 'smooth\_dev', while the website's lockfile (yarn.lock) and package.json are added to manage the new frontend stack.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 60.

• Code Health 94
• Architecture 85
• Maturity 53
• Readiness 51
• Security 76
• Domain Modelling 100

• 300 commits — 265 feature/other, 35 fixes

• website/docs — 105 commits
• packages/smooth — 71 commits
• (root) — 55 commits
• scripts/generation — 27 commits
• (repo) — 18 commits
• website/yarn.lock — 7 commits
• .github/workflows — 6 commits
• website/docusaurus.config.js — 3 commits
• website/src — 2 commits
• .github/settings.yml — 1 commit
• .github/stale.yml — 1 commit
• packages/smooth_example_control_group — 1 commit
• scripts/comments — 1 commit
• scripts/timeline — 1 commit
• website/static — 1 commit

• fix: Revert "fix _readDiffDateTimeToTimeStamp #6289"
• fix: Revert "hack experiment flutter web #6294"
• fix: Revert "more temp hacks to experiment web #6274"
• fix: Revert "more temporary hack for web; will break android/ios #6287"
• fix: Revert "naive experiment about worker #6292"
• fix: Revert "rm index.md"
• fix: Revert "rm log #6287"
• fix: Revert "temp hack and log #6287"
• fix: fix
• fix: fix _readDiffDateTimeToTimeStamp #6289
• fix: fix broken links
• fix: fix bug and see animation now #127
• fix: fix bug https://github.com/fzyzcjy/flutter_smooth/issues/127#issuecomment-1279978263
• fix: fix ci #134
• fix: fix compile error
• fix: fix compile failure
• fix: fix error #127
• fix: fix error given latest framework master
• fix: fix errors #134
• fix: fix further #127
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fzyzcjy/flutter_smooth was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.