Old vs New Flutter

Flutter moves fast. A tutorial or Stack Overflow answer from a few years ago may use buttons that no longer exist, code without null safety, or theme properties that were renamed. Copying such code into a Flutter 3.47 project gives errors or a wall of deprecation warnings, and beginners often think they made a mistake.

This lesson gives you a short history of Flutter and Dart, a table of old APIs and their modern replacements, and the tools that update old code for you. Use it as a reference whenever you meet unfamiliar older code.

A short timeline

Flutter now ships a stable release roughly every three months, so expect a few deprecations with each one. Deprecated APIs usually keep working for a while (with a warning) and are removed in a later release.

The null safety migration

Code written before Dart 2.12 has no ? in its types, because every type could hold null. You will recognise it by patterns like these:

- String name;                 // could silently be null
- int count = map['count'];    // no null check
- MyWidget({Key key, this.title}) : super(key: key);
+ String? name;                // nullable only when it really can be missing
+ int count = map['count'] ?? 0;
+ const MyWidget({super.key, required this.title});

The old style also used @required (from package:meta) instead of the required keyword, and constructors passed key manually with : super(key: key) instead of the newer super.key super parameter (Dart 2.17).

During the move to null safety, Dart offered a tool called dart migrate, and files could opt out with a // @dart=2.9 comment. Since Dart 3.0 (May 2023) all code must be null safe: the migration tool was removed, opt-out comments no longer work, and packages that were never migrated cannot be used. If a tutorial's code has no ? anywhere, translate it using Variables & Sound Null Safety rather than trying to run it as is.

Old widgets and APIs, and their replacements

Here is a typical piece of 2020-era code and its modern version:

- RaisedButton(
-   color: Theme.of(context).accentColor,
-   onPressed: _save,
-   child: Text('Save', style: Theme.of(context).textTheme.button),
- )
+ FilledButton(
+   onPressed: _save,
+   child: const Text('Save'),
+ )

The new button takes its colour and text style from the Material 3 theme automatically, so most of the old styling code simply disappears. If you need to style it, use FilledButton.styleFrom(...) or a filledButtonTheme (see Material 3 Theming).

Language features older code does not use

Older code also predates many Dart features you have learned. It still compiles, but modern code is shorter and safer:

// Old style
String gradeOld(int marks) {
  if (marks >= 90) {
    return 'A+';
  } else if (marks >= 75) {
    return 'A';
  }
  return 'B';
}

List<Object> splitOld(String fullName) {
  final parts = fullName.split(' ');
  return [parts.first, parts.length];
}

// Modern style (Dart 3)
String grade(int marks) => switch (marks) {
  >= 90 => 'A+',
  >= 75 => 'A',
  _ => 'B',
};

(String, int) split(String fullName) {
  final parts = fullName.split(' ');
  return (parts.first, parts.length);
}

void main() {
  print('${gradeOld(92)} ${grade(92)}');
  final old = splitOld('Ananya Rao');
  final (first, words) = split('Ananya Rao');
  print('${old[0]} ${old[1]} | $first $words');
}

A+ A+
Ananya 2 | Ananya 2

The old function returns a List<Object>, so the caller loses the types and must cast; the record (String, int) keeps them. Other things to modernise when you see them: MainAxisAlignment.center can become .center (dot shorthands, Dart 3.10), a SizedBox between Row/Column children can become spacing:, and AnimatedBuilder used only to listen to a model can become ListenableBuilder.

Let the tools do the work

You rarely need to update old code by hand:

flutter analyze             # lists deprecated API uses and other issues
dart fix --dry-run          # shows the automatic fixes it can apply
dart fix --apply            # applies them to the whole project
flutter pub outdated        # shows which packages are behind
flutter upgrade             # updates the Flutter SDK itself

dart fix knows many Flutter migrations (it reads fix rules that the Flutter team ships with the SDK), so it can rename deprecated APIs such as MaterialState to WidgetState across your project in one step. Review the changes with Git before committing. For bigger changes, read the breaking changes page on docs.flutter.dev, which has a migration guide for every breaking change, release by release.

Common mistakes

• Copying old tutorial code blindly. Check the date; anything before 2021 lacks null safety and uses old buttons.
• Ignoring deprecation warnings. Today's warning is next year's compile error. Fix them while they are few.
• Upgrading Flutter without running tests. Upgrade, run dart fix --apply, flutter analyze and flutter test, then commit.
• Pinning a very old Flutter version forever. Store requirements (such as target Android API levels) eventually force you to upgrade.

Key points

• Flutter 2 (2021) brought sound null safety; Dart 3 (2023) made it mandatory and added records and patterns.
• Material 3 has been the default since Flutter 3.16; old headline1-style text names are gone.
• Old buttons and Scaffold.of(...).showSnackBar were removed; WillPopScope, ButtonBar, withOpacity and MaterialState are deprecated.
• Modern Dart prefers switch expressions, records, super.key, dot shorthands and spacing.
• flutter analyze and dart fix --apply find and fix most deprecated code automatically.

import 'package:flutter/material.dart';

class SaveBar extends StatelessWidget {
  const SaveBar({super.key, required this.title, this.onSave});

  final String title;
  final VoidCallback? onSave;

  @override
  Widget build(BuildContext context) {
    return OverflowBar(
      alignment: MainAxisAlignment.end,
      spacing: 8,
      children: [
        Text(title, style: Theme.of(context).textTheme.titleLarge),
        FilledButton(onPressed: onSave, child: const Text('Save')),
      ],
    );
  }
}