From 4f9272f4a8618da337ed94b2e81da5eae526732f Mon Sep 17 00:00:00 2001
From: Christian Legnitto <christian.legnitto@robinhood.com>
Date: Fri, 18 Jun 2021 00:25:46 -0700
Subject: [PATCH 1/5] Add random number generator resources (optionally
 specified with a seed)

---
 crates/bevy_core/src/lib.rs        |  14 +++-
 crates/bevy_core/src/rng.rs        | 104 +++++++++++++++++++++++++++++
 examples/2d/contributors.rs        |  19 +++---
 examples/2d/many_sprites.rs        |   5 +-
 examples/ecs/change_detection.rs   |   9 ++-
 examples/ecs/iter_combinations.rs  |   3 +-
 examples/game/alien_cake_addict.rs |  15 +++--
 examples/tools/bevymark.rs         |   8 ++-
 8 files changed, 148 insertions(+), 29 deletions(-)
 create mode 100644 crates/bevy_core/src/rng.rs

diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 75fd87adb5ebb..7b941ae0ccf4e 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -2,6 +2,7 @@ mod bytes;
 mod float_ord;
 mod label;
 mod name;
+mod rng;
 mod task_pool_options;
 mod time;
 
@@ -9,12 +10,16 @@ pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
 pub use name::*;
+pub use rng::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Name, Time, Timer};
+    pub use crate::{
+        CryptoRng, DefaultRngOptions, DefaultTaskPoolOptions, EntityLabels, InsecureRng, Labels,
+        Name, Rng, RngCore, SecureRng, Time, Timer, SliceRandom
+    };
 }
 
 use bevy_app::prelude::*;
@@ -46,6 +51,13 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(app.world_mut());
 
+        // Setup the default bevy random number generators
+        app.world_mut()
+            .get_resource::<DefaultRngOptions>()
+            .cloned()
+            .unwrap_or_else(DefaultRngOptions::default)
+            .create_default_rngs(app.world_mut());
+
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
             .init_resource::<FixedTimesteps>()
diff --git a/crates/bevy_core/src/rng.rs b/crates/bevy_core/src/rng.rs
new file mode 100644
index 0000000000000..13b2e157acf09
--- /dev/null
+++ b/crates/bevy_core/src/rng.rs
@@ -0,0 +1,104 @@
+use bevy_ecs::world::World;
+use bevy_utils::tracing::trace;
+use getrandom::getrandom;
+pub use rand::{
+    rngs::{SmallRng, StdRng},
+    CryptoRng, Rng, RngCore, SeedableRng, seq::SliceRandom,
+};
+
+#[derive(Clone, Debug)]
+pub struct DefaultRngOptions {
+    /// The seed to use for secure / cryptographic operations.
+    pub secure_seed: [u8; 32],
+    /// The seed to use for insecure / non-cryptographic operations.
+    pub insecure_seed: [u8; 32],
+}
+
+impl Default for DefaultRngOptions {
+    fn default() -> Self {
+        let mut seed: [u8; 32] = [0; 32];
+        getrandom(&mut seed).expect("failed to get seed for crypto rng");
+
+        // The default is to use the same secure / cryptographic seed for both Rngs.
+        DefaultRngOptions {
+            secure_seed: seed,
+            insecure_seed: seed,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct SecureRng(StdRng);
+
+impl SecureRng {
+    fn from_seed(seed: [u8; 32]) -> Self {
+        SecureRng(StdRng::from_seed(seed))
+    }
+}
+impl RngCore for SecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+#[derive(Clone)]
+pub struct InsecureRng(SmallRng);
+
+impl InsecureRng {
+    fn from_seed(seed: [u8; 32]) -> Self {
+        InsecureRng(SmallRng::from_seed(seed))
+    }
+}
+impl RngCore for InsecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
+
+impl DefaultRngOptions {
+    /// Create a configuration that forces using a particular secure seed.
+    pub fn with_secure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            secure_seed: seed,
+            ..Default::default()
+        }
+    }
+
+    /// Create a configuration that forces using a particular insecure seed.
+    pub fn with_insecure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            insecure_seed: seed,
+            ..Default::default()
+        }
+    }
+
+    /// Inserts the default Rngs into the given resource map based on the configured values.
+    pub fn create_default_rngs(&self, world: &mut World) {
+        if !world.contains_resource::<SecureRng>() {
+            trace!("Creating secure RNG with seed: {:x?}", self.secure_seed);
+            world.insert_resource(SecureRng::from_seed(self.secure_seed));
+        }
+        if !world.contains_resource::<InsecureRng>() {
+            trace!("Creating insecure RNG with seed: {:x?}", self.insecure_seed);
+            world.insert_resource(InsecureRng::from_seed(self.insecure_seed));
+        }
+    }
+}
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 7dd7db7bb9fa3..dfeeab83ab6ea 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -1,5 +1,4 @@
 use bevy::prelude::*;
-use rand::{prelude::SliceRandom, Rng};
 use std::{
     collections::BTreeSet,
     io::{BufRead, BufReader},
@@ -52,6 +51,7 @@ fn setup(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     let contribs = contributors();
 
@@ -65,16 +65,14 @@ fn setup(
         idx: 0,
     };
 
-    let mut rnd = rand::thread_rng();
-
     for name in contribs {
-        let pos = (rnd.gen_range(-400.0..400.0), rnd.gen_range(0.0..400.0));
-        let dir = rnd.gen_range(-1.0..1.0);
+        let pos = (rng.gen_range(-400.0..400.0), rng.gen_range(0.0..400.0));
+        let dir = rng.gen_range(-1.0..1.0);
         let velocity = Vec3::new(dir * 500.0, 0.0, 0.0);
-        let hue = rnd.gen_range(0.0..=360.0);
+        let hue = rng.gen_range(0.0..=360.0);
 
         // some sprites should be flipped
-        let flipped = rnd.gen_bool(0.5);
+        let flipped = rng.gen_bool(0.5);
 
         let transform = Transform::from_xyz(pos.0, pos.1, 0.0);
 
@@ -106,7 +104,7 @@ fn setup(
         sel.order.push((name, e));
     }
 
-    sel.order.shuffle(&mut rnd);
+    sel.order.shuffle(&mut *rng);
 
     commands.spawn_bundle((SelectTimer, Timer::from_seconds(SHOWCASE_TIMER_SECS, true)));
 
@@ -245,10 +243,9 @@ fn velocity_system(time: Res<Time>, mut q: Query<&mut Velocity>) {
 /// force.
 fn collision_system(
     wins: Res<Windows>,
+    mut rng: ResMut<InsecureRng>,
     mut q: Query<(&mut Velocity, &mut Transform), With<Contributor>>,
 ) {
-    let mut rnd = rand::thread_rng();
-
     let win = wins.get_primary().unwrap();
 
     let ceiling = win.height() / 2.;
@@ -267,7 +264,7 @@ fn collision_system(
         if bottom < ground {
             t.translation.y = ground + SPRITE_SIZE / 2.0;
             // apply an impulse upwards
-            v.translation.y = rnd.gen_range(700.0..1000.0);
+            v.translation.y = rng.gen_range(700.0..1000.0);
         }
         if top > ceiling {
             t.translation.y = ceiling - SPRITE_SIZE / 2.0;
diff --git a/examples/2d/many_sprites.rs b/examples/2d/many_sprites.rs
index fcf10d83322a9..3324f248509a8 100644
--- a/examples/2d/many_sprites.rs
+++ b/examples/2d/many_sprites.rs
@@ -5,8 +5,6 @@ use bevy::{
     sprite::SpriteSettings,
 };
 
-use rand::Rng;
-
 const CAMERA_SPEED: f32 = 1000.0;
 
 pub struct PrintTimer(Timer);
@@ -32,10 +30,9 @@ fn main() {
 fn setup(
     mut commands: Commands,
     assets: Res<AssetServer>,
+    mut rng: ResMut<InsecureRng>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-    let mut rng = rand::thread_rng();
-
     let tile_size = Vec2::splat(64.0);
     let map_size = Vec2::splat(320.0);
 
diff --git a/examples/ecs/change_detection.rs b/examples/ecs/change_detection.rs
index 59d5d80591977..a7bba58cd5a95 100644
--- a/examples/ecs/change_detection.rs
+++ b/examples/ecs/change_detection.rs
@@ -1,5 +1,4 @@
 use bevy::prelude::*;
-use rand::Rng;
 
 // This example illustrates how to react to component change
 fn main() {
@@ -20,9 +19,13 @@ fn setup(mut commands: Commands) {
     commands.spawn().insert(Transform::identity());
 }
 
-fn change_component(time: Res<Time>, mut query: Query<(Entity, &mut MyComponent)>) {
+fn change_component(
+    time: Res<Time>,
+    mut rng: ResMut<InsecureRng>,
+    mut query: Query<(Entity, &mut MyComponent)>,
+) {
     for (entity, mut component) in query.iter_mut() {
-        if rand::thread_rng().gen_bool(0.1) {
+        if rng.gen_bool(0.1) {
             info!("changing component {:?}", entity);
             component.0 = time.seconds_since_startup();
         }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 97ed7b3280f48..e7dbc60dcd870 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -1,5 +1,4 @@
 use bevy::{core::FixedTimestep, prelude::*};
-use rand::{thread_rng, Rng};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
@@ -44,6 +43,7 @@ struct BodyBundle {
 
 fn generate_bodies(
     mut commands: Commands,
+    mut rng: ResMut<InsecureRng>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
@@ -56,7 +56,6 @@ fn generate_bodies(
     let color_range = 0.5..1.0;
     let vel_range = -0.5..0.5;
 
-    let mut rng = thread_rng();
     for _ in 0..NUM_BODIES {
         let mass_value_cube_root: f32 = rng.gen_range(0.5..4.0);
         let mass_value: f32 = mass_value_cube_root * mass_value_cube_root * mass_value_cube_root;
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index 464d281d9511c..0fab390f948d5 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -4,7 +4,6 @@ use bevy::{
     prelude::*,
     render::{camera::Camera, render_graph::base::camera::CAMERA_3D},
 };
-use rand::Rng;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
 enum GameState {
@@ -98,7 +97,12 @@ fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
     commands.spawn_bundle(UiCameraBundle::default());
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMut<Game>) {
+fn setup(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut game: ResMut<Game>,
+    mut rng: ResMut<InsecureRng>,
+) {
     // reset the game state
     game.cake_eaten = 0;
     game.score = 0;
@@ -116,7 +120,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMu
         .map(|j| {
             (0..BOARD_SIZE_I)
                 .map(|i| {
-                    let height = rand::thread_rng().gen_range(-0.1..0.1);
+                    let height = rng.gen_range(-0.1..0.1);
                     commands
                         .spawn_bundle((
                             Transform::from_xyz(i as f32, height - 0.2, j as f32),
@@ -296,6 +300,7 @@ fn spawn_bonus(
     mut state: ResMut<State<GameState>>,
     mut commands: Commands,
     mut game: ResMut<Game>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     if *state.current() != GameState::Playing {
         return;
@@ -312,8 +317,8 @@ fn spawn_bonus(
 
     // ensure bonus doesn't spawn on the player
     loop {
-        game.bonus.i = rand::thread_rng().gen_range(0..BOARD_SIZE_I);
-        game.bonus.j = rand::thread_rng().gen_range(0..BOARD_SIZE_J);
+        game.bonus.i = rng.gen_range(0..BOARD_SIZE_I);
+        game.bonus.j = rng.gen_range(0..BOARD_SIZE_J);
         if game.bonus.i != game.player.i || game.bonus.j != game.player.j {
             break;
         }
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 258c4715408e7..2f1d827809ac2 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -2,7 +2,6 @@ use bevy::{
     diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin},
     prelude::*,
 };
-use rand::Rng;
 
 const BIRDS_PER_SECOND: u32 = 1000;
 const BASE_COLOR: Color = Color::rgb(5.0, 5.0, 5.0);
@@ -116,9 +115,9 @@ fn mouse_handler(
     mut bird_material: ResMut<BirdMaterial>,
     mut counter: ResMut<BevyCounter>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut rnd: ResMut<InsecureRng>,
 ) {
     if mouse_button_input.just_pressed(MouseButton::Left) {
-        let mut rnd = rand::thread_rng();
         let color = gen_color(&mut rnd);
 
         let texture_handle = asset_server.load("branding/icon.png");
@@ -207,7 +206,10 @@ fn counter_system(
 ///
 /// Because there is no `Mul<Color> for Color` instead `[f32; 3]` is
 /// used.
-fn gen_color(rng: &mut impl Rng) -> [f32; 3] {
+fn gen_color<R>(rng: &mut ResMut<R>) -> [f32; 3]
+where
+    R: Rng + Sync + Send + 'static,
+{
     let r = rng.gen_range(0.2..1.0);
     let g = rng.gen_range(0.2..1.0);
     let b = rng.gen_range(0.2..1.0);

From f270c6ba95e9cb180e7d87a3fa796fd927d4f9ec Mon Sep 17 00:00:00 2001
From: Christian Legnitto <christian.legnitto@robinhood.com>
Date: Tue, 6 Jul 2021 18:27:38 -0700
Subject: [PATCH 2/5] Refactor code and write an example

---
 crates/bevy_core/src/rng/insecure.rs | 55 +++++++++++++++++++
 crates/bevy_core/src/rng/mod.rs      | 79 ++++++++++++++++++++++++++++
 crates/bevy_core/src/rng/secure.rs   | 53 +++++++++++++++++++
 examples/app/custom_rng_seeds.rs     | 16 ++++++
 4 files changed, 203 insertions(+)
 create mode 100644 crates/bevy_core/src/rng/insecure.rs
 create mode 100644 crates/bevy_core/src/rng/mod.rs
 create mode 100644 crates/bevy_core/src/rng/secure.rs
 create mode 100644 examples/app/custom_rng_seeds.rs

diff --git a/crates/bevy_core/src/rng/insecure.rs b/crates/bevy_core/src/rng/insecure.rs
new file mode 100644
index 0000000000000..954abb7493830
--- /dev/null
+++ b/crates/bevy_core/src/rng/insecure.rs
@@ -0,0 +1,55 @@
+pub use rand::{
+    rngs::{SmallRng, StdRng},
+    seq::SliceRandom,
+    CryptoRng, Rng, RngCore, SeedableRng,
+};
+use std::ops::Deref;
+
+/// A seed for seeding an [`InsecureRng`].
+pub struct InsecureSeed([u8; 32]);
+
+impl From<[u8; 32]> for InsecureSeed {
+    fn from(item: [u8; 32]) -> Self {
+        InsecureSeed(item)
+    }
+}
+
+impl Deref for InsecureSeed {
+    type Target = [u8; 32];
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// A random number generator for use in non-cryptographic operations.
+///
+/// For cryptographic operations, use [`SecureRng`](super::secure::SecureRng).
+#[derive(Clone)]
+pub struct InsecureRng(SmallRng);
+
+impl Deref for InsecureRng {
+    type Target = SmallRng;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl InsecureRng {
+    pub(crate) fn from_seed(seed: [u8; 32]) -> Self {
+        InsecureRng(SmallRng::from_seed(seed))
+    }
+}
+impl RngCore for InsecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
diff --git a/crates/bevy_core/src/rng/mod.rs b/crates/bevy_core/src/rng/mod.rs
new file mode 100644
index 0000000000000..2deb40534115a
--- /dev/null
+++ b/crates/bevy_core/src/rng/mod.rs
@@ -0,0 +1,79 @@
+mod insecure;
+mod secure;
+
+pub use self::insecure::{InsecureRng, InsecureSeed};
+pub use self::secure::{SecureRng, SecureSeed};
+use bevy_ecs::world::World;
+use bevy_utils::tracing::trace;
+use getrandom::getrandom;
+#[doc(hidden)]
+pub use rand::{
+    rngs::{SmallRng, StdRng},
+    seq::SliceRandom,
+    CryptoRng, Rng, RngCore, SeedableRng,
+};
+
+/// Helper for configuring and creating the default random number generators.
+/// For end-users who want full control, insert the default random number generators into the resource map manually.
+/// If the random number generators are already inserted, this helper will do nothing.
+#[derive(Clone, Debug)]
+pub struct DefaultRngOptions {
+    /// The seed to use for secure / cryptographic operations.
+    secure_seed: [u8; 32],
+    /// The seed to use for insecure / non-cryptographic operations. If set to `None`,
+    /// the seed from `secure_seed` will be reused, saving an allocation.
+    insecure_seed: Option<[u8; 32]>,
+}
+
+impl Default for DefaultRngOptions {
+    fn default() -> Self {
+        let mut seed: [u8; 32] = [0; 32];
+        getrandom(&mut seed).expect("failed to get cryptographic seed for rng");
+
+        // The default is t o use the same secure / cryptographic seed for both Rngs.
+        DefaultRngOptions {
+            secure_seed: seed,
+            insecure_seed: None,
+        }
+    }
+}
+
+impl DefaultRngOptions {
+    /// Create a configuration that forces using a particular secure seed.
+    pub fn with_secure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            secure_seed: seed,
+            ..Default::default()
+        }
+    }
+
+    /// Create a configuration that forces using a particular insecure seed.
+    pub fn with_insecure_seed(seed: [u8; 32]) -> Self {
+        DefaultRngOptions {
+            insecure_seed: Some(seed),
+            ..Default::default()
+        }
+    }
+
+    /// Create a configuration that forces using particular seeds.
+    pub fn with_seeds(secure_seed: SecureSeed, insecure_seed: InsecureSeed) -> Self {
+        DefaultRngOptions {
+            secure_seed: *secure_seed,
+            insecure_seed: Some(*insecure_seed),
+        }
+    }
+
+    /// Inserts the default random number generators into the given resource map based on the configured values.
+    pub fn create_default_rngs(&self, world: &mut World) {
+        if !world.contains_resource::<SecureRng>() {
+            trace!("Creating secure RNG with seed: {:x?}", self.secure_seed);
+            world.insert_resource(SecureRng::from_seed(self.secure_seed));
+        }
+        if !world.contains_resource::<InsecureRng>() {
+            // Only use the insecure seed if set.
+            let seed = self.insecure_seed.unwrap_or(self.secure_seed);
+            trace!("Creating insecure RNG with seed: {:x?}", seed);
+            world.insert_resource(InsecureRng::from_seed(seed));
+        }
+    }
+}
diff --git a/crates/bevy_core/src/rng/secure.rs b/crates/bevy_core/src/rng/secure.rs
new file mode 100644
index 0000000000000..0a5a6cc0c49a8
--- /dev/null
+++ b/crates/bevy_core/src/rng/secure.rs
@@ -0,0 +1,53 @@
+pub use rand::{
+    rngs::{SmallRng, StdRng},
+    seq::SliceRandom,
+    CryptoRng, Rng, RngCore, SeedableRng,
+};
+use std::ops::Deref;
+
+/// A seed for seeding a [`SecureRng`].
+pub struct SecureSeed([u8; 32]);
+impl From<[u8; 32]> for SecureSeed {
+    fn from(item: [u8; 32]) -> Self {
+        SecureSeed(item)
+    }
+}
+impl Deref for SecureSeed {
+    type Target = [u8; 32];
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// A random number generator suitable for use in cryptographic operations.
+///
+/// For non-cryptographic operations, use [`InsecureRng`](super::insecure::InsecureRng).
+#[derive(Clone)]
+pub struct SecureRng(StdRng);
+
+impl Deref for SecureRng {
+    type Target = StdRng;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl SecureRng {
+    pub(crate) fn from_seed(seed: [u8; 32]) -> Self {
+        SecureRng(StdRng::from_seed(seed))
+    }
+}
+impl RngCore for SecureRng {
+    fn next_u32(&mut self) -> u32 {
+        self.0.next_u32()
+    }
+    fn next_u64(&mut self) -> u64 {
+        self.0.next_u64()
+    }
+    fn fill_bytes(&mut self, dest: &mut [u8]) {
+        self.0.fill_bytes(dest)
+    }
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
+        self.0.try_fill_bytes(dest)
+    }
+}
diff --git a/examples/app/custom_rng_seeds.rs b/examples/app/custom_rng_seeds.rs
new file mode 100644
index 0000000000000..91d83d2c7d030
--- /dev/null
+++ b/examples/app/custom_rng_seeds.rs
@@ -0,0 +1,16 @@
+use bevy::prelude::*;
+
+/// This example illustrates how to customize the random number generator seeds.
+fn main() {
+    // These are not very good seeds!
+    let seed_with_ones: [u8; 32] = [1; 32];
+    let seed_with_twos: [u8; 32] = [2; 32];
+
+    App::build()
+        .insert_resource(DefaultRngOptions::with_seeds(
+            SecureSeed::from(seed_with_ones),
+            InsecureSeed::from(seed_with_twos),
+        ))
+        .add_plugins(DefaultPlugins)
+        .run();
+}

From dc80f20fe0a0d158474452beecfd8c15f9a96e1d Mon Sep 17 00:00:00 2001
From: Christian Legnitto <christian.legnitto@robinhood.com>
Date: Tue, 6 Jul 2021 18:31:05 -0700
Subject: [PATCH 3/5] Add missing files

---
 Cargo.toml                      |   4 ++
 crates/bevy_core/Cargo.toml     |   6 ++
 crates/bevy_core/src/lib.rs     |  24 +++++---
 crates/bevy_core/src/rng.rs     | 104 --------------------------------
 crates/bevy_internal/Cargo.toml |   3 +
 docs/cargo_features.md          |   1 +
 examples/tools/bevymark.rs      |   4 +-
 7 files changed, 32 insertions(+), 114 deletions(-)
 delete mode 100644 crates/bevy_core/src/rng.rs

diff --git a/Cargo.toml b/Cargo.toml
index 9e8551ffc3daf..0a90b93908712 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -181,6 +181,10 @@ path = "examples/3d/z_sort_debug.rs"
 name = "custom_loop"
 path = "examples/app/custom_loop.rs"
 
+[[example]]
+name = "custom_rng_seeds"
+path = "examples/app/custom_rng_seeds.rs"
+
 [[example]]
 name = "drag_and_drop"
 path = "examples/app/drag_and_drop.rs"
diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 107cead7be36d..8cd3374f04c71 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -12,6 +12,10 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT"
 keywords = ["bevy"]
 
+[features]
+default = ["rng"]
+rng = ["getrandom", "rand"]
+
 
 [dependencies]
 # bevy
@@ -25,3 +29,5 @@ bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
 
 # other
 bytemuck = "1.5"
+getrandom = { version = "0.2", features = ["js"], optional = true }
+rand = { version = "0.8", features = ["getrandom", "small_rng", "std_rng"], optional = true }
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 7b941ae0ccf4e..bbef8cb887797 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -2,6 +2,7 @@ mod bytes;
 mod float_ord;
 mod label;
 mod name;
+#[cfg(feature = "rng")]
 mod rng;
 mod task_pool_options;
 mod time;
@@ -10,16 +11,20 @@ pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
 pub use name::*;
+#[cfg(feature = "rng")]
 pub use rng::*;
 pub use task_pool_options::DefaultTaskPoolOptions;
 pub use time::*;
 
 pub mod prelude {
+    #[cfg(feature = "rng")]
     #[doc(hidden)]
     pub use crate::{
-        CryptoRng, DefaultRngOptions, DefaultTaskPoolOptions, EntityLabels, InsecureRng, Labels,
-        Name, Rng, RngCore, SecureRng, Time, Timer, SliceRandom
+        CryptoRng, DefaultRngOptions, InsecureRng, InsecureSeed, Rng, RngCore, SecureRng,
+        SecureSeed, SliceRandom,
     };
+    #[doc(hidden)]
+    pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Name, Time, Timer};
 }
 
 use bevy_app::prelude::*;
@@ -51,12 +56,15 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(app.world_mut());
 
-        // Setup the default bevy random number generators
-        app.world_mut()
-            .get_resource::<DefaultRngOptions>()
-            .cloned()
-            .unwrap_or_else(DefaultRngOptions::default)
-            .create_default_rngs(app.world_mut());
+        #[cfg(feature = "rng")]
+        {
+            // Setup the default bevy random number generators
+            app.world_mut()
+                .get_resource::<DefaultRngOptions>()
+                .cloned()
+                .unwrap_or_else(DefaultRngOptions::default)
+                .create_default_rngs(app.world_mut());
+        }
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
diff --git a/crates/bevy_core/src/rng.rs b/crates/bevy_core/src/rng.rs
deleted file mode 100644
index 13b2e157acf09..0000000000000
--- a/crates/bevy_core/src/rng.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use bevy_ecs::world::World;
-use bevy_utils::tracing::trace;
-use getrandom::getrandom;
-pub use rand::{
-    rngs::{SmallRng, StdRng},
-    CryptoRng, Rng, RngCore, SeedableRng, seq::SliceRandom,
-};
-
-#[derive(Clone, Debug)]
-pub struct DefaultRngOptions {
-    /// The seed to use for secure / cryptographic operations.
-    pub secure_seed: [u8; 32],
-    /// The seed to use for insecure / non-cryptographic operations.
-    pub insecure_seed: [u8; 32],
-}
-
-impl Default for DefaultRngOptions {
-    fn default() -> Self {
-        let mut seed: [u8; 32] = [0; 32];
-        getrandom(&mut seed).expect("failed to get seed for crypto rng");
-
-        // The default is to use the same secure / cryptographic seed for both Rngs.
-        DefaultRngOptions {
-            secure_seed: seed,
-            insecure_seed: seed,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct SecureRng(StdRng);
-
-impl SecureRng {
-    fn from_seed(seed: [u8; 32]) -> Self {
-        SecureRng(StdRng::from_seed(seed))
-    }
-}
-impl RngCore for SecureRng {
-    fn next_u32(&mut self) -> u32 {
-        self.0.next_u32()
-    }
-    fn next_u64(&mut self) -> u64 {
-        self.0.next_u64()
-    }
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
-        self.0.fill_bytes(dest)
-    }
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
-        self.0.try_fill_bytes(dest)
-    }
-}
-
-#[derive(Clone)]
-pub struct InsecureRng(SmallRng);
-
-impl InsecureRng {
-    fn from_seed(seed: [u8; 32]) -> Self {
-        InsecureRng(SmallRng::from_seed(seed))
-    }
-}
-impl RngCore for InsecureRng {
-    fn next_u32(&mut self) -> u32 {
-        self.0.next_u32()
-    }
-    fn next_u64(&mut self) -> u64 {
-        self.0.next_u64()
-    }
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
-        self.0.fill_bytes(dest)
-    }
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
-        self.0.try_fill_bytes(dest)
-    }
-}
-
-impl DefaultRngOptions {
-    /// Create a configuration that forces using a particular secure seed.
-    pub fn with_secure_seed(seed: [u8; 32]) -> Self {
-        DefaultRngOptions {
-            secure_seed: seed,
-            ..Default::default()
-        }
-    }
-
-    /// Create a configuration that forces using a particular insecure seed.
-    pub fn with_insecure_seed(seed: [u8; 32]) -> Self {
-        DefaultRngOptions {
-            insecure_seed: seed,
-            ..Default::default()
-        }
-    }
-
-    /// Inserts the default Rngs into the given resource map based on the configured values.
-    pub fn create_default_rngs(&self, world: &mut World) {
-        if !world.contains_resource::<SecureRng>() {
-            trace!("Creating secure RNG with seed: {:x?}", self.secure_seed);
-            world.insert_resource(SecureRng::from_seed(self.secure_seed));
-        }
-        if !world.contains_resource::<InsecureRng>() {
-            trace!("Creating insecure RNG with seed: {:x?}", self.insecure_seed);
-            world.insert_resource(InsecureRng::from_seed(self.insecure_seed));
-        }
-    }
-}
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index 9d557aff5d167..3035e1f3d980f 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -18,6 +18,9 @@ wgpu_trace = ["bevy_wgpu/trace"]
 trace = [ "bevy_app/trace", "bevy_ecs/trace" ]
 trace_chrome = [ "bevy_log/tracing-chrome" ]
 
+# Random number generator support (enabled by default)
+rng = ["bevy_core/rng"]
+
 # Image format support for texture loading (PNG and HDR are enabled by default)
 hdr = ["bevy_render/hdr"]
 png = ["bevy_render/png"]
diff --git a/docs/cargo_features.md b/docs/cargo_features.md
index 794c5bc82c352..12d1d95366a0b 100644
--- a/docs/cargo_features.md
+++ b/docs/cargo_features.md
@@ -11,6 +11,7 @@
 |bevy_winit|GUI support.|
 |bevy_wgpu|Make use of GPU via [WebGPU](https://gpuweb.github.io/gpuweb/) support.|
 |render|The render pipeline and all render related plugins.|
+|rng|Support for random number generators.|
 |png|PNG picture format support.|
 |hdr|[HDR](https://en.wikipedia.org/wiki/High_dynamic_range) support.|
 |mp3|MP3 audio format support.|
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 2f1d827809ac2..6702e5e81e174 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -115,10 +115,10 @@ fn mouse_handler(
     mut bird_material: ResMut<BirdMaterial>,
     mut counter: ResMut<BevyCounter>,
     mut materials: ResMut<Assets<ColorMaterial>>,
-    mut rnd: ResMut<InsecureRng>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     if mouse_button_input.just_pressed(MouseButton::Left) {
-        let color = gen_color(&mut rnd);
+        let color = gen_color(&mut rng);
 
         let texture_handle = asset_server.load("branding/icon.png");
 

From 80fb86afd968342d3c66da1d918bd5fa40c3c9da Mon Sep 17 00:00:00 2001
From: Christian Legnitto <christian.legnitto@robinhood.com>
Date: Tue, 6 Jul 2021 18:33:56 -0700
Subject: [PATCH 4/5] Fix typos

---
 crates/bevy_core/Cargo.toml     | 1 -
 crates/bevy_core/src/rng/mod.rs | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_core/Cargo.toml b/crates/bevy_core/Cargo.toml
index 8cd3374f04c71..9fcf386009f48 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -16,7 +16,6 @@ keywords = ["bevy"]
 default = ["rng"]
 rng = ["getrandom", "rand"]
 
-
 [dependencies]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.5.0" }
diff --git a/crates/bevy_core/src/rng/mod.rs b/crates/bevy_core/src/rng/mod.rs
index 2deb40534115a..7a89bbcebc909 100644
--- a/crates/bevy_core/src/rng/mod.rs
+++ b/crates/bevy_core/src/rng/mod.rs
@@ -30,7 +30,8 @@ impl Default for DefaultRngOptions {
         let mut seed: [u8; 32] = [0; 32];
         getrandom(&mut seed).expect("failed to get cryptographic seed for rng");
 
-        // The default is t o use the same secure / cryptographic seed for both Rngs.
+        // The default is to use the same secure / cryptographic seed for both rngs, so 
+        // we do not specify an insecure seed.
         DefaultRngOptions {
             secure_seed: seed,
             insecure_seed: None,

From 42c54eb8a83177796520c0a44c84badbd48fc317 Mon Sep 17 00:00:00 2001
From: Christian Legnitto <christian.legnitto@robinhood.com>
Date: Tue, 6 Jul 2021 18:37:18 -0700
Subject: [PATCH 5/5] Update Changelog

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73f9575c4c263..8b7103327fb4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -92,6 +92,7 @@ current changes on git with [previous release tags][git_tag_comparison].
 - [Added `set_minimized` and `set_position` to `Window`][1292]
 - [Example for 2D Frustum Culling][1503]
 - [Add remove resource to commands][1478]
+- [Random number generation][2355]
 
 ### Changed
 
@@ -246,6 +247,7 @@ current changes on git with [previous release tags][git_tag_comparison].
 [1703]: https://github.com/bevyengine/bevy/pull/1703
 [1728]: https://github.com/bevyengine/bevy/pull/1728
 [1762]: https://github.com/bevyengine/bevy/pull/1762
+[2355]: https://github.com/bevyengine/bevy/pull/2355
 
 ## Version 0.4.0 (2020-12-19)