imaNNeo/fl_chart

fl\_chart is a Flutter library for rendering interactive charts, supporting line, bar, pie, radar, scatter, candlestick, and gauge visualizations. It provides a modular architecture with dedicated render objects and data models for each chart type, enabling features like touch interaction, zooming, and panning. The system includes a comprehensive example application that demonstrates these capabilities across mobile, desktop, and web platforms.

16 changes.

This period focused on rebranding the project to 'fl\_chart' and establishing a robust development infrastructure, including a Makefile and contributor guidelines. The core library underwent significant architectural refactoring, introducing a functional rendering system, a modern touch event handling mechanism, and support for new chart types like scatter plots. Additionally, the example application was updated to support Linux desktops and modern Android/iOS standards.

20 changes.

This period focused on expanding the example application's reach to web, Linux, and macOS desktop platforms, alongside the introduction of a new RadarChart component. Concurrently, the codebase underwent significant refactoring and expansion of its test suite, with extensive unit tests added for chart components and utility classes.

18 changes.

The project focused on modernizing the example application with a new presentation layer, introducing structured chart samples, interactive features, and centralized resources. Concurrently, significant effort was directed toward improving test coverage for charting utilities and axis components, alongside migrating chart title rendering to a widget-based approach.

7 changes.

This period focused on introducing new charting capabilities, specifically implementing a CandlestickChart and a GaugeChart with full test coverage. The work also included adding sample implementations for these charts and establishing deployment automation for iOS and macOS platforms.

A new sample demonstrating a candlestick chart displaying Bitcoin price data for each month of 2023. The sample loads CSV data, parses it into monthly candlestick spots, and renders a monthly view with navigation controls to switch between months.

example/lib/presentation/samples/candlestick · high confidence

The example project now includes Fastlane configuration files (Appfile, Fastfile, Matchfile) and documentation to automate the deployment of iOS and macOS builds to their respective app stores. This introduces the capability to sync certificates and provisioning profiles, and to build and upload applications to the App Store and Mac App Store via CI pipelines.

example/fastlane · high confidence

The example project now includes the necessary CMake configuration and plugin registration files to support Linux desktop builds. This enables users to build and run the example application on Linux, with the \url\_launcher\_linux\ plugin automatically registered for that platform.

example/linux/flutter · high confidence

Axis-based charts now support zooming and panning via the new \FlTransformationConfig\ and \FlScaleAxis\ classes. Users can configure which axes are scalable, set minimum and maximum scale limits, and enable or disable panning and scaling interactions. The \AxisChartScaffoldWidget\ manages the transformation state, allowing users to interactively zoom and pan the chart area.

_lib/src/chart/base/axis\chart · high confidence

A new shell script, open\_link, has been added to the scripts directory. This utility allows users to open a specified URL in the default web browser across different operating systems (macOS, Linux, and Windows) by invoking the appropriate system command (open, xdg-open, or start).

scripts · high confidence

The example project now includes a complete macOS desktop implementation, providing a functional macOS app bundle. This includes the Swift entry point (AppDelegate) and main window (MainFlutterWindow) to host the Flutter engine, alongside the necessary Info.plist configuration and entitlements (DebugProfile and Release) to enable network access and JIT execution for development, while the release build enforces app sandboxing.

example/macos/Runner · high confidence

A new radar chart sample (RadarChartSample1) has been added to the presentation layer, featuring an interactive UI that allows users to adjust title rotation via a slider and toggle between relative and absolute angle modes. The sample demonstrates the use of switch-case return expressions and includes a title configuration section that dynamically updates based on user interaction.

example/lib/presentation/samples/radar · medium confidence

A new CSV dataset containing daily weather statistics for Amsterdam in 2024 has been added to the example assets. This data, which includes metrics such as temperature, humidity, and precipitation, is intended to support charting examples, specifically the line chart demonstration featuring error indicators.

example/assets · high confidence

The example app now includes a complete Linux desktop implementation, providing a native GTK-based window with a header bar on GNOME and a standard title bar on other desktop environments. This adds the necessary CMake build configuration, application entry point, and GTK integration files to support running the Flutter application on Linux.

example/linux, example/windows · high confidence

A new \CustomInteractiveViewer\ widget was added to \lib/src/chart/base/custom\_interactive\_viewer.dart\, providing a modified version of Flutter's \InteractiveViewer\ that allows the child to be transformed without wrapping it in a \Transform\ widget, enabling custom reaction to transformations. Additionally, \lib/src/chart/base/line.dart\ was added to provide a \Line\ model with helper methods for calculating magnitude, direction, and normalization.

lib/src/chart/base · high confidence

The example app now includes the necessary iOS project files (project.pbxproj and scheme) to support building and running on iOS devices and simulators, enabling developers to test the Flutter charts library on the Apple platform.

example/ios/Runner.xcodeproj · high confidence

The macOS example application is now fully supported with the addition of the Xcode project configuration files (project.pbxproj, workspace settings, and schemes). This change enables developers to build and run the fl\_chart example on macOS, providing a native desktop experience for the library.

example/macos/Runner.xcodeproj · high confidence

Added new utility extensions to simplify common operations: Color extensions for darkening, lightening, and averaging colors; an extension on Iterable\<MapEntry\> to convert to a Map; and a similar extension on List\<MapEntry\>. These additions provide convenient helper methods for color manipulation and collection conversion within the example application.

example/lib/util/extensions · high confidence

The example app now uses a dedicated resources package to manage UI constants. New files define color palettes (app\_colors.dart), asset paths for chart icons and logos (app\_assets.dart), dimensional values for menus and charts (app\_dimens.dart), and text strings such as the application name (app\_texts.dart). These changes consolidate styling and layout values, making it easier to maintain and update the example app's appearance.

example/lib/presentation/resources · high confidence

The example application now includes full Linux desktop support, enabling users to run the charting app on Linux systems. This update adds the necessary C++ and CMake configuration files to build and run the Flutter application on the Linux platform, expanding the example's cross-platform capabilities.

example · high confidence

Added a new CandlestickChart widget and its supporting classes (CandlestickChartData, CandlestickChartPainter, etc.) to render candlestick charts. The implementation includes built-in touch handling that displays a touched point indicator and tooltips on hover or touch, with the ability to customize the indicator and tooltip appearance via the new touchedPointIndicator and candlestickTouchData properties.

_lib/src/chart/candlestick\chart · high confidence

Added a new \CanvasWrapper\ class that proxies Flutter's \Canvas\ drawing methods, enabling the charting library to test its rendering logic. Also added a singleton \Utils\ class for geometric calculations (radians/degrees, rotation offsets) and interval rounding, alongside a \lerp.dart\ file providing linear interpolation helpers for chart data types. These changes support more robust testing and consistent visual calculations across the library.

lib/src/utils · high confidence

Adds a new GaugeChart widget that renders concentric rings along a shared arc, supporting both progress rings (for single-value indicators) and zone rings (for threshold bands). The chart supports animated transitions between data states, touch interaction with hit-testing on individual rings, and visual markers. Example implementations demonstrate a single-ring progress gauge with a needle and markers, a multi-ring dashboard-style gauge, and a speedometer-style gauge combining progress and zone rings.

_example/lib/presentation/samples/gauge, lib/src/chart/gauge\chart · high confidence

Adds the RadarChart widget and its supporting classes (RadarChartData, RadarChartPainter, RenderRadarChart) to the library. Users can now render radar charts with configurable data sets, background colors, border styles, and title positioning. The implementation supports both circle and polygon shapes, allows rotation of titles, and includes touch handling for interaction. The data model includes properties for tick counts, text styles, and grid customization, enabling full control over the chart's appearance and behavior.

_lib/src/chart/radar\chart · high confidence

A new ScatterChart widget and its supporting classes (ScatterChartData, ScatterChartPainter, etc.) have been added to the library. This introduces the ability to render scatter plots, including support for scatter spots, tooltips, labels, and error indicators. Users can now create scatter charts by instantiating the new widget and providing a ScatterChartData configuration.

_lib/src/chart/scatter\chart · high confidence

The side menu now includes a dedicated documentation button for each chart type, allowing users to open the corresponding documentation page directly from the menu. Additionally, the menu footer displays the app version, the fl\_chart library version (which is clickable to open the Flutter release page), and an 'About' button that launches the about page. The menu also features a FlChart banner at the top.

example/lib/presentation/menu · high confidence

The bar chart samples directory now includes eight distinct examples (bar\_chart\_sample1 through bar\_chart\_sample8) demonstrating various bar chart configurations. These samples cover basic bar charts with dynamic data, grouped and stacked bars with gradients, horizontal bar charts with rotation, and charts featuring error indicators and dashed borders. The updates provide practical templates for implementing complex bar chart visualizations in Flutter applications.

example/lib/presentation/samples/bar · high confidence

The example app now uses a structured \ChartSample\ hierarchy to organize and display various chart types, including line, bar, pie, scatter, radar, candlestick, and gauge charts. A new \presentation\_utils.dart\ file provides a currency formatting utility, while \chart\_sample.dart\ defines the base classes and specific sample wrappers for each chart type. The \chart\_samples.dart\ file aggregates all these samples into a centralized registry, enabling the example app to dynamically list and render each chart configuration.

example/lib/presentation/samples · high confidence

The app now features a dedicated ChartSamplesPage that displays a grid of chart samples for a specific chart type, and a new HomePage that serves as the main entry point. The HomePage integrates the chart samples with a navigation menu (AppMenu) and conditionally renders a DownloadNativeAppButton at the bottom of the screen. This introduces a new page structure for browsing chart examples and provides a central hub for navigation and app download options.

example/lib/presentation/pages · high confidence

The line chart examples now include several new samples: sample 10 demonstrates dynamic data updates using a timer; sample 11 shows interactive baseline adjustment via sliders; sample 12 implements pan and scale gestures for zooming into time-series data; and sample 13 visualizes Amsterdam weather data with error indicators. Additionally, sample 5 now supports toggling tooltip visibility on specific spots, and sample 6 allows showing tooltips on a single spot.

example/lib/presentation/samples/line · high confidence

The pie chart samples in the example app have been refreshed with modern Flutter patterns, including the use of switch-case return expressions for cleaner section generation. A new sample (sample4) has been added to demonstrate stacked segment support, where each pie slice is composed of multiple layered segments (e.g., a background layer and a foreground layer) to create a stacked visual effect. Additionally, sample3 now utilizes SVG badge widgets on the pie chart sections, and sample2 employs switch-case returns for its section definitions.

example/lib/presentation/samples/pie · high confidence

The example app introduces several new UI components in the presentation layer. A \ChartHolder\ widget now wraps chart samples with a title, source code link, and background styling. A \DownloadNativeAppButton\ widget provides a styled button for downloading the native application. Additionally, \Indicator\ and \LegendWidget\ components are added to support chart legend and indicator rendering.

example/lib/presentation/widgets · high confidence

Added two new scatter chart examples in the presentation layer. The first demonstrates a basic scatter plot with animated transitions. The second introduces interactive features: users can select data points to display tooltips, and a new \PainterType\ option allows switching between circle, square, and cross dot painters for the scatter spots.

example/lib/presentation/samples/scatter · high confidence

The example app now includes a set of shared utility classes to support its features. AppHelper defines a ChartType enum with display names, documentation URLs, and asset icons for each chart type. AppUtils provides a singleton for mathematical conversions and a centralized method to launch external URLs. CsvParser handles the parsing of CSV data into headers and rows. DeviceInfo offers platform detection (iOS, Android, etc.) and screen form factor classification (phone, tablet, monitor) based on device metrics.

example/lib/util · high confidence

The library has been renamed from 'flutter\_smooth\_chart' to 'fl\_chart', including the project file and repository references. A comprehensive development environment has been established, featuring a Makefile with commands for formatting, linting, testing, and code generation, alongside a CLAUDE.md file detailing the architecture and conventions. The project now enforces code style and test coverage via .codecov.yml and analysis\_options.yaml, and includes a CONTRIBUTING.md guide for contributors. Additionally, the project license was updated to MIT, and the README was expanded with badges, chart previews, and donation links.

(repo-wide) · high confidence

The BarChart widget has been refactored to use a new functional rendering approach, introducing dedicated classes like BarChartLeaf and RenderBarChart that extend RenderBaseChart. This change separates the widget layer from the rendering logic, allowing the BarChart to support touch events, animations, and scaling more effectively. The data model (BarChartData) and helper classes have been updated to support this new structure, including the addition of error indicator data and improved handling of bar groups and touch responses.

_lib/src/chart/bar\chart · high confidence

The example project now includes the necessary macOS configuration files and a MainMenu.xib interface, enabling the app to run as a native desktop application on macOS.

example/macos/Runner.xcworkspace, example/macos/Runner/Base.lproj · high confidence

The example app now includes a complete web build, providing a standalone web application with a loading spinner, a web manifest for PWA support, and a CNAME file for custom domain configuration.

example/web · high confidence

The example project now includes the necessary build configuration files (Flutter-Debug.xcconfig and Flutter-Release.xcconfig) to support macOS builds, along with a generated plugin registrant that registers package\_info\_plus, path\_provider, and url\_launcher plugins for the macOS platform.

example/macos/Flutter · high confidence

The rendering of axis titles on chart sides has been migrated from a custom render-object approach to a widget-based implementation. This change introduces new components, including SideTitlesWidget and SideTitlesFlex, which handle the layout and display of side titles. This shift allows for more flexible styling and layout of titles, potentially resolving previous issues with title visibility and padding calculations.

_lib/src/chart/base/axis\_chart/side\titles · high confidence

The \lib/src/extensions\ directory has been reorganized by extracting specific calculation and rendering logic into new, dedicated extension files. This includes \BarChartDataExtension\ for calculating bar group positions, \FlTitlesDataExtension\ for title padding, \SideTitlesExtension\ for reserved size calculations, and \PaintExtension\ for handling stroke and gradient application. Additional extensions were added for \Border\, \Color\, \EdgeInsets\, \Gradient\, \Path\, \RRect\, and \Size\, each encapsulating related functionality such as dashed line paths, color darkening, and text alignment mapping.

lib/src/extensions · high confidence

The library has been renamed from 'flutter\_smooth\_chart' to 'fl\_chart'. The main entry point 'flutter\_smooth\_chart.dart' has been removed and replaced with 'fl\_chart.dart', which now exports all chart types (bar, candlestick, gauge, line, pie, radar, and scatter charts) along with their corresponding data classes and base chart components.

lib · high confidence

The external path\_drawing dependency has been removed and its dashPath() implementation is now included directly in the codebase as lib/src/utils/path\_drawing/dash\_path.dart. This change eliminates the need for an external package by providing the dash path functionality internally.

_lib/src/utils/path\drawing · high confidence

The line chart implementation has been refactored to use a new functional rendering approach, moving from direct Canvas access to a CanvasWrapper for better testability and consistency. The LineChart widget now utilizes an ImplicitlyAnimatedWidget with a dedicated state class that manages touch interactions and tooltip indicators. Data handling has been updated to automatically calculate min/max axis values if not provided, and the LineChartData class now includes a lerp function for smoother animations. Touch handling has been improved with a new LineTouchData configuration that supports built-in touch responses and custom callbacks, while the painter now correctly handles empty data sets and null spots without crashing.

_lib/src/chart/line\chart · medium confidence

The macOS example app's build configuration has been updated. The AppInfo.xcconfig now sets the application name to 'FL Chart App' and the bundle identifier to 'dev.flchart.app', while the Debug and Release xcconfig files now include a new Warnings.xcconfig that enforces stricter compiler warning flags for both debug and release builds.

example/macos/Runner/Configs · medium confidence

The example app's state management has been refactored to use the BLoC/Cubit pattern. A new AppCubit and AppState class manage application-level state, including package versioning, UI flags for the download button, and version release links. The main entry point now provides the AppCubit via MultiBlocProvider, enabling consistent state handling across the example application.

example/lib · high confidence

The charting library introduces a new touch handling system that supports a wider range of pointer and touch events, including long press, pan, and secondary button clicks. Users can now configure touch behavior via \FlTouchData\, which allows enabling/disabling the touch system, setting custom callbacks for specific events, and resolving mouse cursors. The system also supports long press duration customization and provides detailed touch response objects containing the touch location and chart coordinates. This change replaces the previous, simpler touch callback mechanism with a more robust, event-driven approach that works across mobile and desktop platforms.

_lib/src/chart/base/base\chart · high confidence

The PieChart widget has been restructured into separate, focused files: the main widget (pie\_chart.dart), data classes (pie\_chart\_data.dart), a helper utility (pie\_chart\_helper.dart), the canvas painter (pie\_chart\_painter.dart), and the render object (pie\_chart\_renderer.dart). This change improves code organization and testability, and introduces support for stacked segments and badge widgets within the pie chart sections.

_lib/src/chart/pie\chart · high confidence

The Android example app has been updated to align with modern Flutter and Android development practices. This includes adding a .gitignore file to exclude build artifacts and sensitive files, configuring the AndroidManifest.xml with necessary permissions and queries for URL launching and text processing, and setting up the MainActivity in Kotlin. Additionally, launch themes and icons have been configured for both light and dark modes, and the Gradle wrapper has been upgraded to version 8.12.

example/android · medium confidence

The iOS example app has been updated with new configuration files and assets. The Info.plist now includes the 'ITSAppUsesNonExemptEncryption' key, and the app name is set to 'FL Chart App' with the display name 'FL Chart'. The app icon has been updated to use 'app\_logo\_1024.jpg' in the asset catalog. Additionally, the 'CFBundleName' in the AppFrameworkInfo.plist has been changed to 'App'.

example/ios/Runner · medium confidence

The iOS example app's Xcode workspace has been updated with new configuration files, including the workspace data, IDE workspace checks, and workspace settings (specifically disabling previews). This change aligns the example app's project structure with current Xcode standards.

example/ios/Runner.xcodeproj/project.xcworkspace, example/ios/Runner.xcworkspace · medium confidence

Added chart data pool for unit tests; Added initial placeholder unit tests for iOS and macOS runners; Added test helper utilities and matchers for chart components; Added tests for the new GaugeChart component; Added unit and widget tests for axis chart components; Added unit tests for LineChart components; Added unit tests for PieChart components; Added unit tests for axis side titles rendering and configuration; Added unit tests for bar chart components; Added unit tests for canvas wrapper, lerp utilities, and utils singleton; Added unit tests for chart base rendering and line math utilities; Added unit tests for charting extension utilities; Added unit tests for the RadarChart component; Added unit tests for the ScatterChart component; Added unit tests for the candlestick chart component.

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

• CAI 64 → 64 (+0.0)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 93 → 93 (+0.0)
• Architecture 100 → 100 (+0.0)
• Maturity 72 → 72 (+0.0)
• Readiness 56 → 56 (+0.0)
• Security 56 → 56 (+0.0)
• Domain Modelling 100 → 100 (+0.0)

• Off-boarding risk: anonymized user #1

• Off-boarding risk: anonymized user #1

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

imaNNeo/fl_chart 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.