But recently, I tried Isar for one of my projects, and the difference in performance was very clear. This article is my honest, humble experience of how Isar feels faster than Hive, especially when the app grows.

Hive is Good… Until Data Grows

Hive is perfect for simple things:

• Storing small objects
• Saving a few settings
• Keeping user preferences

But when I started storing large lists, like:

• products
• categories
• cart items
• offline caching

Hive started slowing down.
Searching, sorting, and filtering needed manual loops in Dart, and the performance dropped when the data increased.

Isar Feels Modern and Fast

Isar is built differently.
It uses a native engine under the hood and supports:

• indexing
• relations
• fast filtering
• instant queries

When I moved the same product list to Isar, I noticed:

• Faster write
• Faster read
• Faster search
• No lag in UI

Even with hundreds or thousands of records, Isar stays smooth.

The Surprising Part: Fewer Downloads, Better Performance

Yes, Hive has 1M+ downloads,
and Isar has around 8K.

But that doesn’t mean Hive is better.

Hive has been around for many years.
Isar is new, and new things always start small.

But the performance speaks for itself.

Where Isar Makes a Big Difference

If your project needs:

• Offline mode
• Fast product loading
• Search and filters
• Large lists
• User data + relations

Isar handles these cases much better.
Hive is simple, but it is not designed for heavy offline apps.

When Hive Still Makes Sense

I still use Hive for:

• Theme settings
• Simple key-value storage
• Very small data

For everything else, I now prefer Isar.

My Personal Verdict

Both Hive and Isar are good.
But for modern Flutter apps, especially e-commerce or apps with offline features, Isar feels faster, cleaner, and more future-ready.

This is just my humble experience.
Your use case might be different, but if you haven’t tried Isar yet, it’s worth giving it a chance.

isar 3.1.0+1

https://pub.dev/packages/isar/versions

Huawei devices without Google Mobile Services (GMS) behave differently from regular Android phones. Many Flutter apps break on Huawei phones because they rely on Firebase, Google Maps, YouTube APIs, or Google Sign-In.

In this article, I will walk you through everything you need to make your Flutter app compatible with Huawei HMS devices — including package replacements, flavor setup, YouTube alternatives, and real-world code snippets.

Why You Must Add Huawei Support

Since Huawei devices ship without GMS, the following Google services will not work:

Firebase Messaging

Google Maps

Google Places

Google Login

YouTube player APIs

Some WebViews that depend on GMS codecs

MLKit Text Recognition

Step 1 — Detect Whether the Device Is Huawei (Without GMS)

import 'package:device_info_plus/device_info_plus.dart';
import 'dart:io';

Future<bool> isHuaweiDevice() async {
  final deviceInfo = DeviceInfoPlugin();

  if (Platform.isAndroid) {
    final androidInfo = await deviceInfo.androidInfo;
    return androidInfo.manufacturer.toLowerCase().contains('huawei') ||
           androidInfo.brand.toLowerCase().contains('huawei');
  }
  return false;
}
//Create utils fucntions

Usage:
final isHuawei = await isHuaweiDevice();

Step 2 — Replace Firebase Packages with Huawei HMS Alternatives

Add these to pubspec.yaml:

huawei_agconnect: ^1.8.0
huawei_analytics: ^6.12.0
agconnect_crash: ^1.9.0+300
huawei_push: ^6.13.0
huawei_remoteconfig: ^6.7.0

Push Notifications Migration

import 'package:huawei_push/huawei_push.dart';

void initHuaweiPush() async {
  Push.getTokenStream.listen((token) {
    print("Huawei Token: $token");
  });

  await Push.getToken("");
}

Step 3 — Replace Google-specific Packages

huawei_account: ^6.12.0
huawei_map: ^6.5.0
huawei_site: ^6.7.0
huawei_mltext: ^3.12.0
huawei_player: ^6.7.0

Step 4 — YouTube Playback on Huawei Devices

YouTube depends heavily on Google Play Services.
On Huawei devices, the YouTube Player plugin often fails.
Solution 1 — Use WebView with Huawei WebView

huawei_webview: ^6.6.0

Solution 2 — Use Huawei Player as Fallback

if (await isHuaweiDevice()) {
  HuaweiPlayer.play('your_video_url');
} else {
  // Open YouTube embed
  final url = "https://youtube.com/embed/$videoId";
  // use your normal player
}

Step 5 — Configure Android Flavors for Firebase & Huawei

The cleanest setup is using two app flavors:

• huawei (HMS only)
• appMarket2 / google / global (normal GMS version)

android {
    flavorDimensions "flavor"

    productFlavors {
        huawei {
            applicationId "com.myapp.huawei"
            dimension "flavor"
        }
        appMarket2 {
            applicationId "com.myapp.global"
            dimension "flavor"
        }
    }
}

Add config files

./gradlew assembleHuaweiDebug
./gradlew assembleAppMarket2Debug

Step 6— Final Recommendations

Test on Real HMS Device or Huawei Cloud Debugging

Huawei provides cloud-based P40/P50/ Mate devices for testing.

Do Not Break Your Existing GMS App

Keep two flavor builds — safest architecture.

Disable Google Login Button on Huawei Devices

User experience stays clean, avoids crashes.

GraphQL is a query language for APIs that provides a more efficient, powerful, and flexible alternative to REST. When using GraphQL in a Flutter application, you can query exactly the data you need and nothing more. This helps reduce the amount of data transferred over the network, leading to better performance and user experience. Here are the steps to integrate GraphQL in a Flutter app:

Yes, GraphQL offers three primary operations that greatly simplify how we interact with data: queries, mutations, and subscriptions. Each serves a different purpose and provides flexibility in managing data interactions within your application.

Queries

Queries are used to fetch data from the server. They allow you to specify exactly what data you need, reducing the amount of data transferred and improving efficiency. Here’s an example of a simple query to fetch user details:

Mutations

Mutations are used to modify data on the server (create, update, delete). They work similarly to queries but are designed to change data and often require input parameters. Here’s an example mutation to update a user’s email:

Subscriptions

Subscriptions allow you to listen for real-time updates from the server. They are useful for applications that need to react to data changes instantly, such as chat applications or live updates. Here’s an example of a subscription to listen for new user creations:

Step 1: Add Dependencies

graphql_flutter: ^5.0.0
graphql: ^5.1.3 # To call graphql api, platform: All.
graphql_codegen: ^0.14.0 # To generate graphql related classes, platform: All.
hive: ^2.2.3
dio:
graphql_flutter: ^5.1.2
build_runner:

Step 2: Create build.yaml file

# build.yaml

targets:
  $default:
    builders:
      graphql_codegen:
        options:
          clients:
            - graphql
          outputDirectory: graphql_gen
          addTypename: false
          generatedFileHeader: "/// GENERATED CODE - DO NOT MODIFY BY HAND\n
/// *****************************************************\n
///  FlutterGen\n
/// *****************************************************\n\n
// coverage:ignore-file\n
// ignore_for_file: type=lint\n
// ignore_for_file: directives_ordering,unnecessary_import,implicit_dynamic_list_literal,deprecated_member_use\n\n"

Step 3: Add graphQL Schema in lib folder

After schema add in your project

flutter pub run build_runner build

flutter pub run build_runner build

Here all your project is successfully setup graphql

Now move Graphql client

Step 4: Create GraphQLConfig client class

class GraphQLConfig {
  final connectivity = Connectivity();
  static HttpLink httpLink = HttpLink('Add your graphql server url');

  GraphQLClient clientToQuery() => GraphQLClient(
      link: httpLink,
      cache: GraphQLCache(store: InMemoryStore()),
      defaultPolicies: DefaultPolicies(
        mutate: Policies(
          cacheReread: CacheRereadPolicy.ignoreAll,
          error: ErrorPolicy.all,
          fetch: FetchPolicy.noCache,
        ),
        query: Policies(
          cacheReread: CacheRereadPolicy.ignoreAll,
          error: ErrorPolicy.all,
          fetch: FetchPolicy.noCache,
        ),
      ));
}

Step 5: Create GraphQLService class

class GraphQLService {
  static GraphQLConfig graphQLConfig = GraphQLConfig();
  GraphQLClient client = graphQLConfig.clientToQuery();
}

Step 6: Wrap Material app into GraphQLProvider

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return GraphQLProvider(
      client: ValueNotifier(GraphQLService().client),
      child: MaterialApp(
        title: 'Flutter Demo',
        debugShowCheckedModeBanner: false,
        theme: ThemeData(
          colorScheme: ColorScheme.fromSwatch(primarySwatch: Colors.deepPurple),
          // Consider removing useMaterial3: true if you're not targeting Flutter 3.0 or later
          useMaterial3: true,
        ),
        home: const OtpPage(), // Set the OTP page as the home page
      ),
    );
  }
}

GraphQLProvider

Step 7: Add your Mutation or query as per you requirement

mutation SendOtp($input:SendOTPInput!) {
    sendOTP(input: $input) {
        meta {
            status
            message
            message_code
            status_code
        }
    }
}

send_otp.graphql

file name

Step 8 : Create Repository

import 'package:graphql_flutter/graphql_flutter.dart';
import '../graphql/graphql_gen/send_otp.graphql.dart';

class OtpRepository {
  final GraphQLClient _client;

  OtpRepository(this._client);

  Future<Mutation$SendOtp$sendOTP$meta?> sendOTP({
    required String version,
    required String platform,
    required String phoneCountryId,
    required String mobileNumber,
  }) async {
    const String mutation = r'''
      mutation SendOtp($input: SendOTPInput!) {
        sendOTP(input: $input) {
          meta {
            status
            message
            message_code
            status_code
          }
        }
      }
    ''';

    final options = MutationOptions(
      document: gql(mutation),
      variables: {
        'input': {
          'version': version,
          'platform': platform,
          'phone_country_id': phoneCountryId,
          'mobile_number': mobileNumber,
        },
      },
    );

    final result = await _client.mutate(options);

    print('sajid : ${result.data}');

    if (result.hasException) {
      print('GraphQL Exception: ${result.exception.toString()}');
      throw Exception('Failed to send OTP'); // Throw an error to handle in UI
    }

    final meta = result.data?['sendOTP']['meta'];
    return meta != null
        ? Mutation$SendOtp$sendOTP$meta.fromJson(meta)
        : null; // Return parsed meta data or null if not present
  }
}

Step 8 : Create this function calling in controller or cubit if you are using state management but in this demo normal UI

void _sendOTP() async {
    final otpRepository = OtpRepository(GraphQLService().client);
    try {
      final result = await otpRepository.sendOTP(
        version: '1.0',
        platform: 'Android',
        phoneCountryId: '1',
        mobileNumber: phoneNumber,
      );

      if (kDebugMode) {
        print("result sajid  ${result?.message}");
        print("result sajid  ${result?.message_code}");
        print("result sajid  ${result?.status_code}");
      }

      if (result != null) {
        if (result.status_code == 200) {
          Navigator.push(
            context,
            MaterialPageRoute(builder: (context) =>  VerifyOtpPage()),
          );
        }
        ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(content: Text('OTP sent successfully')),
        );
      } else {
        ScaffoldMessenger.of(context).showSnackBar(
          const SnackBar(content: Text('Failed to send OTP')),
        );
      }
    } catch (e) {
      print('Error sending OTP: $e');
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('Failed to send OTP')),
      );
    }
  }

Step 9: Call into our widget

class MyCustomForm extends StatefulWidget {
  const MyCustomForm({super.key});

  @override
  MyCustomFormState createState() => MyCustomFormState();
}

class MyCustomFormState extends State<MyCustomForm> {
  final _formKey = GlobalKey<FormState>();
  final String phoneNumber = "7415311601";

  @override
  void initState() {
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Form(
      key: _formKey,
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
          TextFormField(
            initialValue: phoneNumber,
            keyboardType: TextInputType.number,
            inputFormatters: [FilteringTextInputFormatter.digitsOnly],
            decoration: const InputDecoration(
              labelText: 'Enter Phone Number',
              border: OutlineInputBorder(),
            ),
            validator: (value) {
              if (value == null || value.isEmpty) {
                return 'Please enter some text';
              }
              return null;
            },
            onChanged: (value) {
              //phoneNumber = value.toString();
            },
          ),
          Padding(
            padding: const EdgeInsets.symmetric(vertical: 16),
            child: ElevatedButton(
              onPressed: () {
                if (_formKey.currentState!.validate()) {
                  // Call sendOTP mutation here
                  _sendOTP();
                }
              },
              child: const Text('Submit'),
            ),
          ),
        ],
      ),
    );
  }

GitHub - sajidshaikh20/Flutter_graphQL_demo

Switch master branch

Thank you for taking the time to read through this tutorial on [Graoh ql in flutter I hope you found it helpful and that it gave you a better understanding of [ Graphql concept ]. If you have any questions or need further clarification, feel free to leave a comment below or reach out to me directly.