Why update Material at all?

In 2022, a UX research intern at Google asked a deceptively simple question:

“Why do all our apps look the same… and kinda boring?”

That single question led to:

• 3 years of design iteration
• 46 research studies
• 18,000+ user interactions

The result?

Material 3 Expressive > a bold, emotional evolution of Google’s design system.

What is M3 Expressive?

It’s Material, but with feeling.

M3 Expressive brings a more vibrant and human layer to apps with:

• Vibrant color
• Intuitive motion
• Bolder shapes
• Flexible typography
• Customizable components

This isn’t just about aesthetics. It performs better, too.

What’s New in M3 Expressive

Here are just a few of the updates:

🔹 Toolbar: A more modern top app bar
🔹 Split Button: Combines primary action + dropdown
🔹 Button Groups: Visually connected action clusters
🔹 Progress Indicators: Now with a dynamic waveform style
🔹 15+ Components: Redesigned for impact and emotion

A New Motion Physics System

Motion is no longer just flair. It’s functional.

M3 introduces a token-based motion system:

• Easier to customize
• Smoother transitions
• Feels more intentional and expressive

Why This Actually Matters

M3 Expressive isn’t just prettier

It’s proven.

In research-backed testing:

• 👁 Users spotted key actions 4x faster
• 🧠 Older adults (45+) understood UI faster
• 💬 Interfaces rated as more intuitive and modern

That’s a win for accessibility, usability, and performance.

Expressive Design Drives Emotion

In perception studies, M3 Expressive UIs were rated:

• +34% more modern
• +32% more subcultural appeal
• +30% more rebellious

Ideal for brands seeking to feel fresh, bold, and human.

But It’s Not a Free Pass

With great design power comes great UX responsibility.

Misusing expressive tools (like removing labels or reordering UI just for style) reduced usability in some tests (right image).

Expressive doesn’t mean decorative. Expressive means intentional.

Good Design = Inclusive Design

Here’s the most exciting bit:

In testing, older users performed as well as younger users when using M3 Expressive designs.

That means:

✅ Less friction for everyone

✅ More people completing tasks faster

✅ Apps that age gracefully with your audience

TL;DR: Time to Make Your App Feel Something

Material 3 Expressive is:

• Research-backed
• Visually bold
• Emotionally resonant
• Easier to use
• Better for everyone

This is design that connects.

Ready to Explore?

Are you thinking about migrating your UI to M3 Expressive?

Let’s discuss what that migration could look like for your app.

Book a Free Consultation

In this article, we’ll explore two standout packages: animations and flutter_animate. We’ll also look at how you can combine them for even richer animations.

Before we dive into these packages, let’s briefly recap Flutter’s built-in animation capabilities:

Flutter’s core animation system includes:

• AnimationController – Drives the animation, controlling its duration and playback.
• Tween – Defines the range of values for an animation.
• AnimatedBuilder – Rebuilds the UI whenever the animation value updates.

A typical code snippet using flutter core animation system would look like

class AnimatedLogo extends StatefulWidget {
  @override
  _AnimatedLogoState createState() => _AnimatedLogoState();
}

class _AnimatedLogoState extends State<AnimatedLogo> with SingleTickerProviderStateMixin {
  late AnimationController _controller;
  late Animation<double> _animation;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      duration: const Duration(seconds: 2),
      vsync: this,
    );
    _animation = Tween<double>(begin: 0, end: 300).animate(_controller);
    _controller.forward();
  }

  @override
  Widget build(BuildContext context) {
    return AnimatedBuilder(
      animation: _animation,
      builder: (context, child) {
        return Container(
          height: _animation.value,
          width: _animation.value,
          child: FlutterLogo(),
        );
      },
    );
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

While this approach gives you fine-grained control, it can become cumbersome for more complex animations or when you need to prototype ideas quickly. This is what makes packages like animations and flutter_animate crucial.

Animations Package

The animation package, provided by the Flutter team, offers pre-built animations for common Material Design patterns.

Key Features:

• Container Transform – Seamlessly animates transitions between two elements.
• Shared Axis Transition – Visually links elements with spatial relationships.
• Fade Through Transition – Smoothly fades between unrelated elements.
• Fade Scale Transition – Fades and scales an element as it appears/disappears.

A typical animation code using the animations package would look like

import 'package:animations/animations.dart';

SharedAxisTransition(
  animation: animation,
  secondaryAnimation: secondaryAnimation,
  transitionType: SharedAxisTransitionType.horizontal,
  child: child,
)

Flutter Package – https://pub.dev/packages/animations

This snippet dramatically simplifies complex animations while keeping your code readable.

The flutter_animate Package: Chainable, Intuitive Animations

flutter_animate provides a powerful and intuitive API for creating complex animations with minimal code.

Key Features:

• Chainable effects – Easily combine multiple effects in a single line.
• Predefined animations – Common transitions made simple.
• Custom effects – Fine-tune animations to fit your needs.
• Performance optimized – Adapts based on device capabilities.

A typical code using the Flutter animate package would look like

import 'package:flutter_animate/flutter_animate.dart';

Text('Hello, World!')
  .animate()
  .fade(duration: 500.ms)
  .scale(delay: 200.ms)
  .move(delay: 400.ms, duration: 600.ms)

Flutter Package Link – https://pub.dev/packages/flutter_animate

Combining Both Packages

For more complex UI transitions, you can combine both packages, lets say we want to create a container that opens with a Material container transform, while also fading in and scaling up.

import 'package:animations/animations.dart';
import 'package:flutter_animate/flutter_animate.dart';

OpenContainer(
            closedBuilder: (context, action) => ListTile(title: Text('Tap me')),
            openBuilder: (context, action) => DetailPage(),
          ).animate().fade(duration: 300.ms).scale(begin: Offset(0.8, 0.8)),
        ),

Best Practices for High-Quality Animations

To create smooth and performant animations, keep these best practices in mind:

• Optimize Performance – Use const constructors and avoid unnecessary widget rebuilds.
• Keep Animations Short – Ideally under 500ms for a responsive feel.
• Use Easing Curves Wisely – Experiment with curves like Curves.easeInOut for natural motion.
• Ensure Responsiveness – Don’t block user interactions while animations are running.

By leveraging these tools, you can craft fluid, engaging animations that enhance the user experience—without the boilerplate code.

🚀 Ready to take your Flutter animations to the next level? Try out these packages and bring your UI to life!

Or want ambeego to help you make your app’s transition super fluid, jump on a call and let’s discuss.