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)
 
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..9fcf386009f48 100644
--- a/crates/bevy_core/Cargo.toml
+++ b/crates/bevy_core/Cargo.toml
@@ -12,6 +12,9 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT"
 keywords = ["bevy"]
 
+[features]
+default = ["rng"]
+rng = ["getrandom", "rand"]
 
 [dependencies]
 # bevy
@@ -25,3 +28,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 75fd87adb5ebb..bbef8cb887797 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -2,6 +2,8 @@ mod bytes;
 mod float_ord;
 mod label;
 mod name;
+#[cfg(feature = "rng")]
+mod rng;
 mod task_pool_options;
 mod time;
 
@@ -9,10 +11,18 @@ 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, InsecureRng, InsecureSeed, Rng, RngCore, SecureRng,
+        SecureSeed, SliceRandom,
+    };
     #[doc(hidden)]
     pub use crate::{DefaultTaskPoolOptions, EntityLabels, Labels, Name, Time, Timer};
 }
@@ -46,6 +56,16 @@ impl Plugin for CorePlugin {
             .unwrap_or_else(DefaultTaskPoolOptions::default)
             .create_default_pools(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>()
             .init_resource::<FixedTimesteps>()
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..7a89bbcebc909
--- /dev/null
+++ b/crates/bevy_core/src/rng/mod.rs
@@ -0,0 +1,80 @@
+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 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,
+        }
+    }
+}
+
+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/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/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/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();
+}
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..6702e5e81e174 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,10 +115,10 @@ fn mouse_handler(
     mut bird_material: ResMut<BirdMaterial>,
     mut counter: ResMut<BevyCounter>,
     mut materials: ResMut<Assets<ColorMaterial>>,
+    mut rng: ResMut<InsecureRng>,
 ) {
     if mouse_button_input.just_pressed(MouseButton::Left) {
-        let mut rnd = rand::thread_rng();
-        let color = gen_color(&mut rnd);
+        let color = gen_color(&mut rng);
 
         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);