Skip to content
CAI
Software that uses CAICheck a score

OpenFlutter/flutter_screenutil

62.9

Adequate · 12 November 2026

2.2k

lines of production code

Dart

with C++, C

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a Flutter library designed to handle responsive UI scaling and screen adaptation. It provides utilities for font scaling, dimension conversion, and granular control over widget rebuilds based on device metrics. The package includes both programmatic extensions and dedicated responsive layout widgets to simplify cross-platform design implementation.

How it got here

2018 — Initial release and example scaffolding

13 changes.

This period marks the initial commit of the flutter\_screenutil package, introducing font scaling disable support and a unified library entry point. The work focused on establishing a comprehensive example application with full Android and iOS scaffolding, including V2 embedding migration and PWA support. Additionally, widget tests were added to verify responsive dimension scaling across different viewport sizes.

2021–2023 — Flutter 3.0 alignment and Linux support

5 changes.

The project updated its Windows and Linux example applications to support Flutter 3.0.0, introducing modern CMake build configurations and native engine integrations. It also expanded the core library with new adaptive layout widgets, granular rebuild control, and comprehensive test coverage to ensure stability across platforms.

Features

Add Linux desktop support to the example app

The example application now includes the necessary build configuration and native source files to run on Linux desktop environments. This change adds a CMake build system (CMakeLists.txt) that links against GTK+ 3, GLib, and GIO, along with native entry points (main.cc, my\_application.cc) that initialize the Flutter engine and register plugins. Users can now build and run the example app on Linux using the standard Flutter tooling.

example/linux · high confidence

Added Flutter example project scaffolding

The example directory now includes the standard scaffolding for a Flutter application, enabling users to run and test the library in a real environment. This addition includes configuration files for IDEs (IntelliJ/Android Studio), a \.gitignore\ to exclude build artifacts, a \.metadata\ file tracking the Flutter beta channel, and the necessary web entry points (\index.html\ and \manifest.json\) to support Progressive Web App (PWA) functionality.

example · high confidence

Added iOS Flutter build configuration files

The example iOS project now includes the standard Flutter build configuration files (AppFrameworkInfo.plist, Debug.xcconfig, Release.xcconfig, and flutter\_export\_environment.sh). These files establish the necessary environment variables and build settings required to compile and run the Flutter application on iOS devices.

example/ios/Flutter · high confidence

Added iOS example app project configuration

The iOS example application project files have been added, including the Xcode project file (project.pbxproj) and the shared scheme (Runner.xcscheme). This provides the necessary build configuration, target settings, and scheme definitions to build and run the iOS example app using Xcode.

example/ios/Runner.xcodeproj · high confidence

Added iOS example app scaffolding

The iOS example project (Runner) has been added, providing a complete native iOS application structure for the flutter\_screenutil package. This includes the necessary AppDelegate implementations in both Objective-C and Swift, standard iOS asset catalogs for app icons and launch screens, storyboard files for the main and launch interfaces, and the Info.plist configuration file.

example/ios/Runner · high confidence

Added iOS example workspace configuration

The iOS example project now includes a dedicated workspace configuration that groups the main Runner project with the CocoaPods dependencies. This setup ensures that the Xcode workspace correctly references the generated Pods project and applies standard IDE settings, such as disabling the 32-bit warning and preview features, to provide a consistent build environment for the example app.

example/ios/Runner.xcworkspace · high confidence

Android example project scaffolded with Gradle wrapper and IDE settings

The Android example project now includes the necessary build infrastructure, specifically adding a .gitignore file to exclude generated build artifacts and IDE configuration files for Eclipse Buildship. Additionally, the Gradle wrapper properties are introduced, configuring the project to use Gradle 7.2 for building the Android application.

example/android · high confidence

Initial commit of flutter\_screenutil v5.9.3 with font scaling disable support

This entry marks the initial commit of the flutter\_screenutil package (version 5.9.3), introducing a new feature to support disabling font scaling. The commit also includes the full project documentation (README in English, Chinese, and Portuguese), the Apache 2.0 license, and updated configuration files like .gitignore and .gitattributes.

(repo-wide) · high confidence

Introduce flutter\_screenutil library entry point

The library now exposes a main entry point file that re-exports its core components, including screen utility classes, initialization helpers, size extensions, and layout widgets (padding and sized box). This allows users to import the library with a single statement to access all provided screen-adaptation features.

lib · high confidence

New adaptive widgets and granular rebuild control

This release introduces new responsive layout widgets—RPadding, REdgeInsets (and REdgeInsetsDirectional), and RSizedBox (including vertical, horizontal, and square variants)—which automatically scale their dimensions based on the design size. It also adds granular control over widget rebuilds via the \rebuildFactor\ callback in ScreenUtilInit, allowing developers to specify exactly which MediaQuery changes (size, orientation, view insets, or any custom logic) should trigger a rebuild, alongside options to exclude specific widgets from the rebuild list.

lib/src · high confidence

New example app with dual initialization methods and responsive widget generation

The example application now supports two distinct initialization approaches, selectable via the 'method' environment variable: the first method wraps the app in DevicePreview (enabled in debug/web modes), while the second method runs the app directly. Additionally, the example now includes generated files for responsive widget handling via the flutter\_screenutil\_generator plugin, defining a set of responsive widgets including 'MyThemedApp', 'MyApp', and 'HomePageScaffold'.

example/lib · high confidence

Behavioural changes

Added iOS workspace configuration files for the example app

The example iOS project now includes the standard Xcode workspace configuration files (contents.xcworkspacedata, IDEWorkspaceChecks.plist, and WorkspaceSettings.xcsettings). These files ensure the workspace is correctly recognized by Xcode, suppresses the 32-bit warning, and disables SwiftUI previews by default.

example/ios/Runner.xcodeproj/project.xcworkspace · high confidence

Example app migrated to Android V2 embedding

The Android example application has been updated to use Flutter's Android V2 embedding. This involves adding the \flutterEmbedding\ meta-data with value \2\ to the main AndroidManifest.xml, switching the MainActivity to extend \FlutterActivity\ from the embedding package, and introducing NormalTheme styles required for the V2 lifecycle. This change ensures the example app is compatible with modern Flutter Android integration standards.

example/android/app/src · high confidence

Updated Windows example runner for Flutter 3.0.0

The Windows example application has been updated to align with Flutter 3.0.0. This includes a new CMake build configuration that supports Debug, Profile, and Release build types, and a refactored native runner that utilizes the modern \FlutterViewController\ and \DartProject\ APIs. The update also introduces a custom run loop to better manage the integration between Windows messages and Flutter engine events, along with improved high-DPI scaling support for the main window.

example/windows · high confidence

Updated example app with new initialization methods and UI demonstrations

The example application has been updated to demonstrate two distinct ways to initialize the flutter\_screenutil library: the 'First Method' using ScreenUtilInit as a wrapper around MaterialApp (with an ensureScreenSize option), and the 'Second Method' calling ScreenUtil.init() within the widget build process. The included home screens now showcase responsive sizing extensions (.w, .h, .sp, .r) alongside traditional ScreenUtil() static calls, and include interactive UI elements like dialogs and bottom sheets to test keyboard insets and layout behavior across different screen configurations.

example/lib/src · high confidence

Test coverage

Added unit and widget tests for flutter\_screenutil; Added widget test for screen responsiveness.

Dependencies

Example project scaffolding and library dependency updates

The example application has been initialized with standard Android (Gradle 7.1.2, Kotlin 1.6.10, compileSdk 33) and iOS (CocoaPods) build configurations, establishing a functional demo environment. The main library (pubspec.yaml) now requires Dart SDK \>=2.17.0 and Flutter \>=3.10.0, and the example app explicitly depends on flutter\_screenutil via path and includes device\_preview ^1.1.0 for testing.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 57 → 63 (+5.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 98 → 98 (+0.0)
  • Architecture 97 → 95 (-1.7)
  • Maturity 46 → 54 (+8.0)
  • Readiness 51 → 59 (+7.7)
  • Security 67 → 67 (+0.0)
  • Performance 100 → 100 (+0.0)

New (1)

  • Edited copy of a member (13 corresponding lines) (example/lib/src/home.dart)

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

Survey your own repository

OpenFlutter/flutter_screenutil 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.

About this page

  • The score is its most recent published measurement, taken on 12 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 65a9f0c031f8ecc11d2f5d6649f5030c676c1be8 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.42+preprod-6bc2a431cb25.