How can I check if a Flutter application is running in debug?

Question

I'm looking for a way to execute code in Flutter when the app is in Debug mode. Is that possible in Flutter? I can't seem to find it anywhere in the documentation.

Something like this

If(app.inDebugMode) {
   print("Print only in debug mode");
}

How can I check if the Flutter application is running in debug or release mode?

[Check Flutter mode from Dart](https://github.com/flutter/flutter/issues/11392) — Raouf Rahiche, Apr 07 '18 at 11:59
I tried assert(() { print("Debug mode"); return true; }); but that just gives me an error that can't compile. The "Profile" they are talking about later in the post doesn't make much sense to me. Can you please explain how to use it ? — Kevin Walter, Apr 07 '18 at 12:24

score 570 · Answer 1 · edited May 01 '22 at 08:18

570

In later versions, you can use kDebugMode:

if (kDebugMode)
  doSomething();

While asserts can technically be used to manually create an "is debug mode" variable, you should avoid that.

Instead, use the constant kReleaseMode from package:flutter/foundation.dart

The difference is all about tree shaking.

Tree shaking (aka the compiler removing unused code) depends on variables being constants.

The issue is, with asserts our isInReleaseMode boolean is not a constant. So when shipping our app, both the dev and release code are included.

On the other hand, kReleaseMode is a constant. Therefore the compiler is correctly able to remove unused code, and we can safely do:

if (kReleaseMode) {

} else {
  // Will be tree-shaked on release builds.
}

edited May 01 '22 at 08:18

Peter Mortensen

30,738
21
105
131

answered Apr 10 '19 at 12:39

Rémi Rousselet

256,336
79
519
432

52

Just a small side note as well, to avoid pollution your class with unknowns import like following ```import 'package:flutter/foundation.dart' as Foundation;``` then you can do ```Foundation. kReleaseMode``` – Oliver Dixon May 26 '19 at 09:22
2

How is this so far down, this should be the accepted answer! – Empty2k12 Aug 16 '19 at 14:43
27

Also there is `kDebugMode` – Alexander Skvortsov Apr 10 '20 at 14:57
3

Will tree shaking also occur with widgets? So if I did a Visibility widget with visible: kDebugMode will that widget be removed by the compiler for release builds? – Ebsan Jun 28 '20 at 17:02
Can we also know if the .apk is signed with `signingConfigs.debug` with the same constant? – Shajeel Afzal Jul 24 '20 at 11:52
upvoted - but jus a note - @AlexanderSkvortsov mentioned kDebugMode (als upvoted). kDebugMode has the advantage of cleaning out your debug code while profiling (kReleaseMode is afaik false when profiling so !kReleaseMod is inferior to kDebugMode) – dancer42 Nov 15 '21 at 01:17
4

Another trick to avoid symbol pollution as @Oliver noted is to use the [`show`](https://dart.dev/guides/language/language-tour#libraries-and-visibility) command to import just the symbol(s) you want to use, i.e. `import 'package:flutter/foundation.dart' show kDebugMode;` – qix May 31 '22 at 06:37

score 103 · Answer 2 · edited May 01 '22 at 08:17

103

Here is a simple solution to this:

import 'package:flutter/foundation.dart';

Then you can use kReleaseMode like

if(kReleaseMode){ // Is Release Mode??
    print('release mode');
} else {
    print('debug mode');
}

edited May 01 '22 at 08:17

Peter Mortensen

30,738
21
105
131

answered Apr 10 '19 at 08:45

Kalpesh Kundanani

5,413
4
22
32

if you need code for release - use kReleaseMode... the else bit is either debug or profiling... use kDebugMode for debug and kProfileMode as needed – dancer42 Nov 15 '21 at 01:20

score 69 · Answer 3 · edited May 01 '22 at 08:16

69

Please use Remi's answer with kReleaseMode and kDebugMode or Dart compilation won't be able to tree-shake your code.

This little snippet should do what you need:

bool get isInDebugMode {
  bool inDebugMode = false;
  assert(inDebugMode = true);
  return inDebugMode;
}

If not, you can configure your IDE to launch a different main.dart in debug mode where you can set a Boolean.

edited May 01 '22 at 08:16

Peter Mortensen

30,738
21
105
131

answered Apr 07 '18 at 15:52

Hadrien Lejard

5,644
2
21
18

I put it as static in an `Application` class so I can write `Application.isInDebugMode` where I need it. – RobDil May 04 '18 at 09:34
2

this is called in release. use constants kDebugMode – dancer42 Nov 15 '21 at 01:21

score 67 · Answer 4 · edited May 01 '22 at 08:24

`kDebugMode`

You can now use the kDebugMode constant.

if (kDebugMode) {
  // Code here will only be included in debug mode.
  // As kDebugMode is a constant, the tree shaker
  // will remove the code entirely from compiled code.
} else {

}

This is preferable over !kReleaseMode as it also checks for profile mode, i.e., kDebugMode means not in release mode and not in profile mode.

`kReleaseMode`

If you just want to check for release mode and not for profile mode, you can use kReleaseMode instead:

if (kReleaseMode) {
  // Code here will only be run in release mode.
  // As kReleaseMode is a constant, the tree shaker
  // will remove the code entirely from other builds.
} else {

}

`kProfileMode`

If you just want to check for profile mode and not for release mode, you can use kProfileMode instead:

if (kProfileMode) {
  // Code here will only be run in release mode.
  // As kProfileMode is a constant, the tree shaker
  // will remove the code entirely from other builds.
} else {

}

score 59 · Accepted Answer · edited May 01 '22 at 08:14

59

While this works, using constants kReleaseMode or kDebugMode is preferable. See Rémi's answer below for a full explanation, which should probably be the accepted question.

The easiest way is to use assert as it only runs in debug mode.

Here's an example from Flutter's Navigator source code:

assert(() {
  if (navigator == null && !nullOk) {
    throw new FlutterError(
      'Navigator operation requested with a context that does not include a Navigator.\n'
      'The context used to push or pop routes from the Navigator must be that of a '
      'widget that is a descendant of a Navigator widget.'
    );
  }
  return true;
}());

Note in particular the () at the end of the call - assert can only operate on a Boolean, so just passing in a function doesn't work.

edited May 01 '22 at 08:14

Peter Mortensen

30,738
21
105
131

answered Apr 07 '18 at 13:19

rmtmckenzie

37,718
9
112
99

2

The "Note in particular" was the part that my IDE was tripping over. Thank you so much! – Kevin Walter Apr 07 '18 at 13:30
6

When you write `() { .... }` you're defining the function, but not calling it. Adding the `()` actually calls the function. – rmtmckenzie Oct 25 '18 at 20:47
This seems a lot more semantically correct than checking the kdebugmode const. – RichieHH Jul 24 '23 at 21:12

score 28 · Answer 6 · edited Apr 26 '22 at 22:03

28

Not to be picky, but the foundation package includes a kDebugMode constant.

So:

import 'package:flutter/foundation.dart' as Foundation;

if(Foundation.kDebugMode) {
   print("App in debug mode");
}

edited Apr 26 '22 at 22:03

Peter Mortensen

30,738
21
105
131

answered Feb 18 '20 at 22:55

Neeraj

2,376
2
24
41

score 10 · Answer 7 · answered Sep 13 '20 at 21:18

10

I believe the latest way to do this is:

const bool prod = const bool.fromEnvironment('dart.vm.product');

src

answered Sep 13 '20 at 21:18

Travis Reeder

38,611
12
87
87

1

Re *"the latest way"*: Can you add some version/date information? – Peter Mortensen May 01 '22 at 08:25
1

As of Dart 2.9.0, this is not recommended, see [do_not_use_environment](https://dart.dev/tools/linter-rules/do_not_use_environment): "Using values derived from the environment at compile-time, creates hidden global state and makes applications hard to understand and maintain." – MJ12358 Jul 09 '23 at 21:48
It strikes me that the assert() is the best way. No need to remember arbitrary const names. assert is documented to trigger in debug mode. Now, there may be fuzzy issues between debug and production but the OP was asking for how to detect if in debug mode. – RichieHH Jul 24 '23 at 21:14

Anand · Answer 8 · 2022-09-08T04:47:40.580

5

Just import this

import 'package:flutter/foundation.dart' 


String bulid = kReleaseMode ? "Release" : "";

or

String bulid = kDebugMode ? "Debug" : "";

or

String bulid = kProfileMode ? "Profile" : "";

Or try this

if (kDebugMode) {
   print("Debug");
} else if (kReleaseMode) {
    print("Release"); 
} else if (kProfileMode) {
  print("Profile"); 
}

edited Sep 08 '22 at 04:47

answered Sep 08 '22 at 04:39

Anand

4,355
2
35
45

score 2 · Answer 9 · edited Jun 20 '23 at 06:04

I've created this useful class, based on other answers and inspired on Android usage. If anything changes on "Foundation" package, it would not be necessary to change the entire application, it would be necessary to change only this class.

import 'package:flutter/foundation.dart' as Foundation;

abstract class Build {

    static const bool isDebugMode = Foundation.kDebugMode;

    static const bool isReleaseMode = Foundation.kReleaseMode;

    static const bool isWeb = Foundation.kIsWeb;

    static const bool isProfileMode = Foundation.kProfileMode;
}

score 1 · Answer 10 · edited Apr 26 '22 at 22:02

Make a file named constants.dart. Add these variables in it:

const bool kReleaseMode = bool.fromEnvironment('dart.vm.product');
const bool kProfileMode = bool.fromEnvironment('dart.vm.profile');
const bool kDebugMode = !kReleaseMode && !kProfileMode;

printk(String string) {
  if (kDebugMode) {
    // ignore: avoid_print
    print(string);
  }
}

Then import this constant file in any other file and use it like this:

    import 'package:package_name/constants.dart';

    if(kDebugMode){
        //Debug code
    }else{
        //Non-Debug code
    }

    printk("Debug Log");

score 0 · Answer 11 · answered Mar 20 '20 at 20:15

0

Extracted from Dart Documentation:

When exactly do assertions work? That depends on the tools and framework you’re using:

Flutter enables assertions in debug mode.

Development-only tools such as dartdevc typically enable assertions by default.

Some tools, such as dart and dart2js, support assertions through a command-line flag: --enable-asserts.

In production code, assertions are ignored, and the arguments to assert aren’t evaluated.

answered Mar 20 '20 at 20:15

teteArg

3,684
2
20
18

How does that answer the question? It is *"How can I check if the Flutter application is running in debug or release mode?"* Can you summarise in your own words? – Peter Mortensen May 01 '22 at 08:21

score 0 · Answer 12 · answered Jul 18 '23 at 11:21

0

you can use flutter's foundation library. You can get debug, profile and release

import 'package:flutter/foundation.dart';

then

if (kDebugMode) {
  // debug code
}

if (kProfileMode) {
 // profile code
}

if (kReleaseMode) {
    // release code
}

answered Jul 18 '23 at 11:21

Vahid Rajabi

191
3
3

How can I check if a Flutter application is running in debug?

12 Answers12

`kDebugMode`

`kReleaseMode`

`kProfileMode`

Linked

Related