Does dart:math's Random class behave the same on all platforms?

frankpape · January 13, 2026, 3:08pm

I’m building something with procedural generation, and I’d like the behavior to be consistent across platforms. If I create Random instances using the same seed, will they generate the same sequence of numbers on every platform, including web?

FWIW, that does experimentally seem to be the case across iOS, Android, and web, but I’m wondering if it can be depended upon, and if the pseudorandom number generation algorithm is likely to change across flutter releases.

julemand101 · January 14, 2026, 6:14am

The implementation for the non-secure random generation are likely implemented similar since they all seems to be based on Multiply-with-carry pseudorandom number generator - Wikipedia, but there are still implemented, at least, in four different versions depending on target platform so I would not depend on them being the same in all situations:

github.com/dart-lang/sdk

sdk/lib/_internal/vm/lib/math_patch.dart

32a4214f9


      
                .._nextState()
                .._nextState()
                .._nextState()
                .._nextState();
            }
          
            @patch
            factory Random.secure() => _secureRandom;
          }
          
          class _Random implements Random {
            int _state;
          
            _Random._withState(this._state);
          
            // The algorithm used here is Multiply with Carry (MWC) with a Base b = 2^32.
            // http://en.wikipedia.org/wiki/Multiply-with-carry
            // The constant A is selected from "Numerical Recipes 3rd Edition" p.348 B1.
            void _nextState() {
              const A = 0xffffda61;
              final state_lo = _state & 0xFFFFFFFF;

github.com/dart-lang/sdk

sdk/lib/_internal/wasm/lib/math_patch.dart

32a4214f9


      
                .._nextState()
                .._nextState()
                .._nextState()
                .._nextState();
            }
          
            @patch
            factory Random.secure() => _secureRandom;
          }
          
          class _Random implements Random {
            // Internal state of the random number generator.
            int _state;
          
            int get _stateLow => _state & 0xFFFFFFFF;
            int get _stateHigh => _state >>> 32;
          
            _Random._withState(this._state);
          
            // The algorithm used here is Multiply with Carry (MWC) with a Base b = 2^32.
            // http://en.wikipedia.org/wiki/Multiply-with-carry

github.com/dart-lang/sdk

sdk/lib/_internal/js_runtime/lib/math_patch.dart

32a4214f9


      
            }
          
            /// Generates a positive random floating point value uniformly distributed on
            /// the range from 0.0, inclusive, to 1.0, exclusive.
            double nextDouble() => JS('double', 'Math.random()');
          
            /// Generates a random boolean value.
            bool nextBool() => JS('bool', 'Math.random() < 0.5');
          }
          
          class _Random implements Random {
            // Constants used by the algorithm or masking.
            static const double _POW2_53_D = 1.0 * (0x20000000000000);
            static const double _POW2_27_D = 1.0 * (1 << 27);
            static const int _MASK32 = 0xFFFFFFFF;
          
            // State comprised of two unsigned 32 bit integers.
            int _lo = 0;
            int _hi = 0;
          
            // Implements:

github.com/dart-lang/sdk

sdk/lib/_internal/js_dev_runtime/patch/math_patch.dart

32a4214f9


      
            /// Generates a positive random floating point value uniformly distributed on
            /// the range from 0.0, inclusive, to 1.0, exclusive.
            @notNull
            double nextDouble() => JS<double>("double", "Math.random()");
          
            /// Generates a random boolean value.
            @notNull
            bool nextBool() => JS<bool>("bool", "Math.random() < 0.5");
          }
          
          class _Random implements Random {
            // Constants used by the algorithm or masking.
            static const double _POW2_53_D = 1.0 * (0x20000000000000);
            static const double _POW2_27_D = 1.0 * (1 << 27);
            static const int _MASK32 = 0xFFFFFFFF;
          
            // State comprised of two unsigned 32 bit integers.
            @notNull
            int _lo = 0;
            @notNull
            int _hi = 0;

I would regardless strongly suggest to have your own pseudorandom implementation as part of your solution if you are depended on it’s output are fixed across platforms and releases since the implementation of the random generator are not part of the API and can therefore change for any reason.

frankpape · January 14, 2026, 4:19pm

Fair point - thank you!

filip · January 15, 2026, 9:43am

AFAIK, there are some crypto-level random generators implemented in pure Dart, as pub packages.

If you just need something pseudorandom and quick, I have been using this:

github.com/filiph/egamebook

edgehead/lib/stateful_random/stateful_random.dart

master

import 'dart:math';

/// A function that returns a random id. Similar to [RandomIntGetter]
/// but will pick any integer, without bounds.
typedef RandomIdGetter = int Function();

/// A function that takes a [max] argument and returns a random
/// integer between `0` (inclusive) and [max] (exclusive).
///
/// Corresponds to the [StatefulRandom.nextInt()] function. This typedef is used
/// for functions that wrap [StatefulRandom.nextInt()] with other logic, such
/// as [WorldState.randomInt].
typedef RandomIntGetter = int Function([int? max]);

/// A pseudo-random number generator that can save its complete state.
///
/// This allows users to get a predictable string of random numbers. This is
/// different from Dart library's [Random] class, which allows you to seed the
/// initial state but not states after that.
///

This file has been truncated. show original

It implements a very simple Xorshift - Wikipedia and is so simple that is should work the same everywhere (though, now that I think of it, I’m not sure that it does so when compiled to JavaScript — there’s no int in JavaScript).

frankpape · January 15, 2026, 2:47pm

That’s great, thank you!

(though, now that I think of it, I’m not sure that it does so when compiled to JavaScript — there’s no int in JavaScript)

Yeah, that was one of my main concerns, but your algorithm in particular does this:

// Dart doesn't have uint32 so we have to clamp the number like this.`
x &= _maxInt32;

which I think is going to give us consistent behavior across platforms, including javascript, considering Dart’s documentation on bitwise operators has this to say:

For performance reasons on the web, bitwise (&, |, ^, ~) and shift (<<,>>, >>>) operators on int use the native JavaScript equivalents. In JavaScript, the operands are truncated to 32-bit integers that are treated as unsigned. This treatment can lead to surprising results on larger numbers. In particular, if operands are negative or don’t fit into 32 bits, they’re likely to produce different results between native and web.

Worth some testing to be safe, though.