diff --git a/benches/Cargo.toml b/benches/Cargo.toml
index ce2467b0228b0..d4b032eab0339 100644
--- a/benches/Cargo.toml
+++ b/benches/Cargo.toml
@@ -24,6 +24,9 @@ bevy_reflect = { path = "../crates/bevy_reflect", features = ["functions"] }
 bevy_render = { path = "../crates/bevy_render" }
 bevy_tasks = { path = "../crates/bevy_tasks" }
 bevy_utils = { path = "../crates/bevy_utils" }
+bevy_platform_support = { path = "../crates/bevy_platform_support", default-features = false, features = [
+  "std",
+] }
 
 # Other crates
 glam = "0.29"
diff --git a/benches/benches/bevy_reflect/map.rs b/benches/benches/bevy_reflect/map.rs
index d1d9d836039fc..4525ed8598926 100644
--- a/benches/benches/bevy_reflect/map.rs
+++ b/benches/benches/bevy_reflect/map.rs
@@ -1,8 +1,8 @@
 use core::{fmt::Write, hint::black_box, iter, time::Duration};
 
 use benches::bench;
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{DynamicMap, Map};
-use bevy_utils::HashMap;
 use criterion::{
     criterion_group, measurement::Measurement, AxisScale, BatchSize, BenchmarkGroup, BenchmarkId,
     Criterion, PlotConfiguration, Throughput,
diff --git a/crates/bevy_animation/Cargo.toml b/crates/bevy_animation/Cargo.toml
index 36091c8db3922..de32f86dc3765 100644
--- a/crates/bevy_animation/Cargo.toml
+++ b/crates/bevy_animation/Cargo.toml
@@ -25,6 +25,10 @@ bevy_time = { path = "../bevy_time", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.16.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+  "serialize",
+] }
 
 # other
 petgraph = { version = "0.6", features = ["serde-1"] }
diff --git a/crates/bevy_animation/src/animation_curves.rs b/crates/bevy_animation/src/animation_curves.rs
index f31f54f8da778..4c944cdf6dd7e 100644
--- a/crates/bevy_animation/src/animation_curves.rs
+++ b/crates/bevy_animation/src/animation_curves.rs
@@ -89,21 +89,20 @@ use core::{
     marker::PhantomData,
 };
 
+use crate::{
+    graph::AnimationNodeIndex,
+    prelude::{Animatable, BlendInput},
+    AnimationEntityMut, AnimationEvaluationError,
+};
 use bevy_ecs::component::{Component, Mutable};
 use bevy_math::curve::{
     cores::{UnevenCore, UnevenCoreError},
     iterable::IterableCurve,
     Curve, Interval,
 };
+use bevy_platform_support::hash::Hashed;
 use bevy_reflect::{FromReflect, Reflect, Reflectable, TypeInfo, Typed};
 use bevy_render::mesh::morph::MorphWeights;
-
-use crate::{
-    graph::AnimationNodeIndex,
-    prelude::{Animatable, BlendInput},
-    AnimationEntityMut, AnimationEvaluationError,
-};
-use bevy_utils::Hashed;
 use downcast_rs::{impl_downcast, Downcast};
 
 /// A value on a component that Bevy can animate.
diff --git a/crates/bevy_animation/src/graph.rs b/crates/bevy_animation/src/graph.rs
index 4db8ce47c3084..1729841f02641 100644
--- a/crates/bevy_animation/src/graph.rs
+++ b/crates/bevy_animation/src/graph.rs
@@ -17,8 +17,8 @@ use bevy_ecs::{
     resource::Resource,
     system::{Res, ResMut},
 };
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{prelude::ReflectDefault, Reflect, ReflectSerialize};
-use bevy_utils::HashMap;
 use derive_more::derive::From;
 use petgraph::{
     graph::{DiGraph, NodeIndex},
diff --git a/crates/bevy_animation/src/lib.rs b/crates/bevy_animation/src/lib.rs
index f50fddd711918..2bfd54d847d84 100644
--- a/crates/bevy_animation/src/lib.rs
+++ b/crates/bevy_animation/src/lib.rs
@@ -40,10 +40,11 @@ use bevy_ecs::{
     world::EntityMutExcept,
 };
 use bevy_math::FloatOrd;
+use bevy_platform_support::{collections::HashMap, hash::NoOpHash};
 use bevy_reflect::{prelude::ReflectDefault, Reflect, TypePath};
 use bevy_time::Time;
 use bevy_transform::TransformSystem;
-use bevy_utils::{HashMap, NoOpHash, PreHashMap, PreHashMapExt, TypeIdMap};
+use bevy_utils::{PreHashMap, PreHashMapExt, TypeIdMap};
 use petgraph::graph::NodeIndex;
 use serde::{Deserialize, Serialize};
 use thread_local::ThreadLocal;
@@ -754,10 +755,10 @@ impl AnimationCurveEvaluators {
                 .component_property_curve_evaluators
                 .get_or_insert_with(component_property, func),
             EvaluatorId::Type(type_id) => match self.type_id_curve_evaluators.entry(type_id) {
-                bevy_utils::hashbrown::hash_map::Entry::Occupied(occupied_entry) => {
+                bevy_platform_support::collections::hash_map::Entry::Occupied(occupied_entry) => {
                     &mut **occupied_entry.into_mut()
                 }
-                bevy_utils::hashbrown::hash_map::Entry::Vacant(vacant_entry) => {
+                bevy_platform_support::collections::hash_map::Entry::Vacant(vacant_entry) => {
                     &mut **vacant_entry.insert(func())
                 }
             },
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 799c936ec00b7..11602ff5ad719 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -16,7 +16,7 @@ use bevy_ecs::{
     schedule::{ScheduleBuildSettings, ScheduleLabel},
     system::{IntoObserverSystem, SystemId, SystemInput},
 };
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::{fmt::Debug, num::NonZero, panic::AssertUnwindSafe};
 use log::debug;
 use thiserror::Error;
diff --git a/crates/bevy_app/src/plugin_group.rs b/crates/bevy_app/src/plugin_group.rs
index 6fa7224979669..dca847f77f8ee 100644
--- a/crates/bevy_app/src/plugin_group.rs
+++ b/crates/bevy_app/src/plugin_group.rs
@@ -4,7 +4,8 @@ use alloc::{
     string::{String, ToString},
     vec::Vec,
 };
-use bevy_utils::{hashbrown::hash_map::Entry, TypeIdMap};
+use bevy_platform_support::collections::hash_map::Entry;
+use bevy_utils::TypeIdMap;
 use core::any::TypeId;
 use log::{debug, warn};
 
diff --git a/crates/bevy_app/src/sub_app.rs b/crates/bevy_app/src/sub_app.rs
index b2a783ec3ed10..2e3f48f2ca1e6 100644
--- a/crates/bevy_app/src/sub_app.rs
+++ b/crates/bevy_app/src/sub_app.rs
@@ -6,7 +6,7 @@ use bevy_ecs::{
     schedule::{InternedScheduleLabel, ScheduleBuildSettings, ScheduleLabel},
     system::{SystemId, SystemInput},
 };
-use bevy_utils::{HashMap, HashSet};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use core::fmt::Debug;
 
 #[cfg(feature = "trace")]
diff --git a/crates/bevy_asset/Cargo.toml b/crates/bevy_asset/Cargo.toml
index 77a5dc0471069..f21434c484acf 100644
--- a/crates/bevy_asset/Cargo.toml
+++ b/crates/bevy_asset/Cargo.toml
@@ -27,6 +27,9 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev", features = [
 ] }
 bevy_tasks = { path = "../bevy_tasks", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 stackfuture = "0.3"
 atomicow = "1.0"
diff --git a/crates/bevy_asset/src/asset_changed.rs b/crates/bevy_asset/src/asset_changed.rs
index b165f2606ce7f..04439d9c5ee36 100644
--- a/crates/bevy_asset/src/asset_changed.rs
+++ b/crates/bevy_asset/src/asset_changed.rs
@@ -13,7 +13,7 @@ use bevy_ecs::{
     storage::{Table, TableRow},
     world::unsafe_world_cell::UnsafeWorldCell,
 };
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::marker::PhantomData;
 use disqualified::ShortName;
 use tracing::error;
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index 344cd9bd3c666..e183b228cfa8a 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -9,8 +9,8 @@ use bevy_ecs::{
     resource::Resource,
     system::{Res, ResMut, SystemChangeTick},
 };
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{Reflect, TypePath};
-use bevy_utils::HashMap;
 use core::{any::TypeId, iter::Enumerate, marker::PhantomData, sync::atomic::AtomicU32};
 use crossbeam_channel::{Receiver, Sender};
 use serde::{Deserialize, Serialize};
@@ -595,7 +595,7 @@ impl<A: Asset> Assets<A> {
 pub struct AssetsMutIterator<'a, A: Asset> {
     queued_events: &'a mut Vec<AssetEvent<A>>,
     dense_storage: Enumerate<core::slice::IterMut<'a, Entry<A>>>,
-    hash_map: bevy_utils::hashbrown::hash_map::IterMut<'a, Uuid, A>,
+    hash_map: bevy_platform_support::collections::hash_map::IterMut<'a, Uuid, A>,
 }
 
 impl<'a, A: Asset> Iterator for AssetsMutIterator<'a, A> {
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index fc8a79dbcb4e0..690d5061bd7a7 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -515,8 +515,8 @@ pub enum UntypedAssetConversionError {
 #[cfg(test)]
 mod tests {
     use alloc::boxed::Box;
+    use bevy_platform_support::hash::FixedHasher;
     use bevy_reflect::PartialReflect;
-    use bevy_utils::FixedHasher;
     use core::hash::BuildHasher;
 
     use super::*;
diff --git a/crates/bevy_asset/src/id.rs b/crates/bevy_asset/src/id.rs
index 07a6d3db1209e..a1fe13615ee8b 100644
--- a/crates/bevy_asset/src/id.rs
+++ b/crates/bevy_asset/src/id.rs
@@ -420,7 +420,7 @@ mod tests {
     fn hash<T: Hash>(data: &T) -> u64 {
         use core::hash::BuildHasher;
 
-        bevy_utils::FixedHasher.hash_one(data)
+        bevy_platform_support::hash::FixedHasher.hash_one(data)
     }
 
     /// Typed and Untyped `AssetIds` should be equivalent to each other and themselves
diff --git a/crates/bevy_asset/src/io/embedded/embedded_watcher.rs b/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
index 4621fff436d7e..25dd55ff48c8d 100644
--- a/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
+++ b/crates/bevy_asset/src/io/embedded/embedded_watcher.rs
@@ -4,7 +4,7 @@ use crate::io::{
     AssetSourceEvent, AssetWatcher,
 };
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::time::Duration;
 use notify_debouncer_full::{notify::RecommendedWatcher, Debouncer, RecommendedCache};
 use parking_lot::RwLock;
diff --git a/crates/bevy_asset/src/io/embedded/mod.rs b/crates/bevy_asset/src/io/embedded/mod.rs
index 8ea2e72e0d469..cba775aaa6ddf 100644
--- a/crates/bevy_asset/src/io/embedded/mod.rs
+++ b/crates/bevy_asset/src/io/embedded/mod.rs
@@ -26,7 +26,9 @@ pub const EMBEDDED: &str = "embedded";
 pub struct EmbeddedAssetRegistry {
     dir: Dir,
     #[cfg(feature = "embedded_watcher")]
-    root_paths: alloc::sync::Arc<parking_lot::RwLock<bevy_utils::HashMap<Box<Path>, PathBuf>>>,
+    root_paths: alloc::sync::Arc<
+        parking_lot::RwLock<bevy_platform_support::collections::HashMap<Box<Path>, PathBuf>>,
+    >,
 }
 
 impl EmbeddedAssetRegistry {
diff --git a/crates/bevy_asset/src/io/gated.rs b/crates/bevy_asset/src/io/gated.rs
index 0a7de4c9d36ce..ab3e0998e2c12 100644
--- a/crates/bevy_asset/src/io/gated.rs
+++ b/crates/bevy_asset/src/io/gated.rs
@@ -1,6 +1,6 @@
 use crate::io::{AssetReader, AssetReaderError, PathStream, Reader};
 use alloc::{boxed::Box, sync::Arc};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use crossbeam_channel::{Receiver, Sender};
 use parking_lot::RwLock;
 use std::path::Path;
diff --git a/crates/bevy_asset/src/io/memory.rs b/crates/bevy_asset/src/io/memory.rs
index 864e88e6316fb..5b9e5389c2199 100644
--- a/crates/bevy_asset/src/io/memory.rs
+++ b/crates/bevy_asset/src/io/memory.rs
@@ -1,6 +1,6 @@
 use crate::io::{AssetReader, AssetReaderError, PathStream, Reader};
 use alloc::{borrow::ToOwned, boxed::Box, sync::Arc, vec::Vec};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::{pin::Pin, task::Poll};
 use futures_io::AsyncRead;
 use futures_lite::{ready, Stream};
diff --git a/crates/bevy_asset/src/io/source.rs b/crates/bevy_asset/src/io/source.rs
index 5b6e2df97b238..37bdc306b7cc0 100644
--- a/crates/bevy_asset/src/io/source.rs
+++ b/crates/bevy_asset/src/io/source.rs
@@ -9,7 +9,7 @@ use alloc::{
 };
 use atomicow::CowArc;
 use bevy_ecs::resource::Resource;
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::{fmt::Display, hash::Hash, time::Duration};
 use thiserror::Error;
 use tracing::{error, warn};
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index 286a96e8f81fc..85fe7a87ed132 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -219,8 +219,8 @@ use bevy_ecs::{
     schedule::{IntoSystemConfigs, IntoSystemSetConfigs, SystemSet},
     world::FromWorld,
 };
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::{FromReflect, GetTypeRegistration, Reflect, TypePath};
-use bevy_utils::HashSet;
 use core::any::TypeId;
 use tracing::error;
 
@@ -653,8 +653,8 @@ mod tests {
         schedule::{LogLevel, ScheduleBuildSettings},
     };
     use bevy_log::LogPlugin;
+    use bevy_platform_support::collections::HashMap;
     use bevy_reflect::TypePath;
-    use bevy_utils::HashMap;
     use core::time::Duration;
     use serde::{Deserialize, Serialize};
     use std::path::Path;
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index 6425f302b904d..75192159a857f 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -13,8 +13,8 @@ use alloc::{
 };
 use atomicow::CowArc;
 use bevy_ecs::world::World;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_tasks::{BoxedFuture, ConditionalSendFuture};
-use bevy_utils::{HashMap, HashSet};
 use core::any::{Any, TypeId};
 use downcast_rs::{impl_downcast, Downcast};
 use ron::error::SpannedError;
diff --git a/crates/bevy_asset/src/processor/log.rs b/crates/bevy_asset/src/processor/log.rs
index a5505f6882e0c..533a87d830a04 100644
--- a/crates/bevy_asset/src/processor/log.rs
+++ b/crates/bevy_asset/src/processor/log.rs
@@ -5,7 +5,7 @@ use alloc::{
     vec::Vec,
 };
 use async_fs::File;
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 use futures_lite::{AsyncReadExt, AsyncWriteExt};
 use std::path::PathBuf;
 use thiserror::Error;
diff --git a/crates/bevy_asset/src/processor/mod.rs b/crates/bevy_asset/src/processor/mod.rs
index ba5024e565bd0..bfc9a295d86d3 100644
--- a/crates/bevy_asset/src/processor/mod.rs
+++ b/crates/bevy_asset/src/processor/mod.rs
@@ -58,8 +58,8 @@ use crate::{
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::VecDeque, sync::Arc, vec, vec::Vec};
 use bevy_ecs::prelude::*;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_tasks::IoTaskPool;
-use bevy_utils::{HashMap, HashSet};
 use futures_io::ErrorKind;
 use futures_lite::{AsyncReadExt, AsyncWriteExt, StreamExt};
 use parking_lot::RwLock;
diff --git a/crates/bevy_asset/src/saver.rs b/crates/bevy_asset/src/saver.rs
index 9dd713108afe0..c8b308a544640 100644
--- a/crates/bevy_asset/src/saver.rs
+++ b/crates/bevy_asset/src/saver.rs
@@ -4,8 +4,8 @@ use crate::{
 };
 use alloc::boxed::Box;
 use atomicow::CowArc;
+use bevy_platform_support::collections::HashMap;
 use bevy_tasks::{BoxedFuture, ConditionalSendFuture};
-use bevy_utils::HashMap;
 use core::{borrow::Borrow, hash::Hash, ops::Deref};
 use serde::{Deserialize, Serialize};
 
diff --git a/crates/bevy_asset/src/server/info.rs b/crates/bevy_asset/src/server/info.rs
index 015d04670142d..e519bf86aeebf 100644
--- a/crates/bevy_asset/src/server/info.rs
+++ b/crates/bevy_asset/src/server/info.rs
@@ -11,8 +11,9 @@ use alloc::{
     vec::Vec,
 };
 use bevy_ecs::world::World;
+use bevy_platform_support::collections::{hash_map::Entry, HashMap, HashSet};
 use bevy_tasks::Task;
-use bevy_utils::{Entry, HashMap, HashSet, TypeIdMap};
+use bevy_utils::TypeIdMap;
 use core::{any::TypeId, task::Waker};
 use crossbeam_channel::Sender;
 use either::Either;
diff --git a/crates/bevy_asset/src/server/loaders.rs b/crates/bevy_asset/src/server/loaders.rs
index c407098f7c0c3..e0571c8fd6355 100644
--- a/crates/bevy_asset/src/server/loaders.rs
+++ b/crates/bevy_asset/src/server/loaders.rs
@@ -4,8 +4,9 @@ use crate::{
 };
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
 use async_broadcast::RecvError;
+use bevy_platform_support::collections::HashMap;
 use bevy_tasks::IoTaskPool;
-use bevy_utils::{HashMap, TypeIdMap};
+use bevy_utils::TypeIdMap;
 use core::any::TypeId;
 use thiserror::Error;
 use tracing::warn;
diff --git a/crates/bevy_asset/src/server/mod.rs b/crates/bevy_asset/src/server/mod.rs
index 3d92dc0ced7a0..0a5c59c629a24 100644
--- a/crates/bevy_asset/src/server/mod.rs
+++ b/crates/bevy_asset/src/server/mod.rs
@@ -25,8 +25,8 @@ use alloc::{
 };
 use atomicow::CowArc;
 use bevy_ecs::prelude::*;
+use bevy_platform_support::collections::HashSet;
 use bevy_tasks::IoTaskPool;
-use bevy_utils::HashSet;
 use core::{any::TypeId, future::Future, panic::AssertUnwindSafe, task::Poll};
 use crossbeam_channel::{Receiver, Sender};
 use either::Either;
diff --git a/crates/bevy_asset/src/transformer.rs b/crates/bevy_asset/src/transformer.rs
index 3cab80086bf54..8b2a8d09be84e 100644
--- a/crates/bevy_asset/src/transformer.rs
+++ b/crates/bevy_asset/src/transformer.rs
@@ -1,8 +1,8 @@
 use crate::{meta::Settings, Asset, ErasedLoadedAsset, Handle, LabeledAsset, UntypedHandle};
 use alloc::boxed::Box;
 use atomicow::CowArc;
+use bevy_platform_support::collections::HashMap;
 use bevy_tasks::ConditionalSendFuture;
-use bevy_utils::HashMap;
 use core::{
     borrow::Borrow,
     convert::Infallible,
diff --git a/crates/bevy_core_pipeline/Cargo.toml b/crates/bevy_core_pipeline/Cargo.toml
index 657f308ac0561..643ae1bf18ad1 100644
--- a/crates/bevy_core_pipeline/Cargo.toml
+++ b/crates/bevy_core_pipeline/Cargo.toml
@@ -37,6 +37,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.16.0-dev" }
 bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
   "std",
+  "serialize",
 ] }
 
 serde = { version = "1", features = ["derive"] }
diff --git a/crates/bevy_core_pipeline/src/auto_exposure/buffers.rs b/crates/bevy_core_pipeline/src/auto_exposure/buffers.rs
index 84b4011d2c557..cc16cd4630d6d 100644
--- a/crates/bevy_core_pipeline/src/auto_exposure/buffers.rs
+++ b/crates/bevy_core_pipeline/src/auto_exposure/buffers.rs
@@ -1,11 +1,11 @@
 use bevy_ecs::prelude::*;
+use bevy_platform_support::collections::{hash_map::Entry, HashMap};
 use bevy_render::{
     render_resource::{StorageBuffer, UniformBuffer},
     renderer::{RenderDevice, RenderQueue},
     sync_world::RenderEntity,
     Extract,
 };
-use bevy_utils::{Entry, HashMap};
 
 use super::{pipeline::AutoExposureUniform, AutoExposure};
 
diff --git a/crates/bevy_core_pipeline/src/core_2d/mod.rs b/crates/bevy_core_pipeline/src/core_2d/mod.rs
index ec0fa58d73f60..60b245c417408 100644
--- a/crates/bevy_core_pipeline/src/core_2d/mod.rs
+++ b/crates/bevy_core_pipeline/src/core_2d/mod.rs
@@ -33,12 +33,12 @@ pub mod graph {
 use core::ops::Range;
 
 use bevy_asset::UntypedAssetId;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     batching::gpu_preprocessing::GpuPreprocessingMode,
     render_phase::PhaseItemBatchSetKey,
     view::{ExtractedView, RetainedViewEntity},
 };
-use bevy_utils::{HashMap, HashSet};
 pub use camera_2d::*;
 pub use main_opaque_pass_2d_node::*;
 pub use main_transparent_pass_2d_node::*;
diff --git a/crates/bevy_core_pipeline/src/core_3d/mod.rs b/crates/bevy_core_pipeline/src/core_3d/mod.rs
index 393508047a017..19b691429e4bd 100644
--- a/crates/bevy_core_pipeline/src/core_3d/mod.rs
+++ b/crates/bevy_core_pipeline/src/core_3d/mod.rs
@@ -81,6 +81,7 @@ use bevy_color::LinearRgba;
 use bevy_ecs::prelude::*;
 use bevy_image::BevyDefault;
 use bevy_math::FloatOrd;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     camera::{Camera, ExtractedCamera},
     extract_component::ExtractComponentPlugin,
@@ -101,7 +102,6 @@ use bevy_render::{
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
-use bevy_utils::{HashMap, HashSet};
 use nonmax::NonMaxU32;
 use tracing::warn;
 
diff --git a/crates/bevy_core_pipeline/src/oit/mod.rs b/crates/bevy_core_pipeline/src/oit/mod.rs
index ea2f7dbd48d29..a0ac81646d84d 100644
--- a/crates/bevy_core_pipeline/src/oit/mod.rs
+++ b/crates/bevy_core_pipeline/src/oit/mod.rs
@@ -4,6 +4,7 @@ use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, Handle};
 use bevy_ecs::{component::*, prelude::*};
 use bevy_math::UVec2;
+use bevy_platform_support::collections::HashSet;
 use bevy_platform_support::time::Instant;
 use bevy_reflect::Reflect;
 use bevy_render::{
@@ -17,7 +18,6 @@ use bevy_render::{
     view::Msaa,
     Render, RenderApp, RenderSet,
 };
-use bevy_utils::HashSet;
 use bevy_window::PrimaryWindow;
 use resolve::{
     node::{OitResolveNode, OitResolvePass},
diff --git a/crates/bevy_core_pipeline/src/upscaling/mod.rs b/crates/bevy_core_pipeline/src/upscaling/mod.rs
index 1145e17d185bd..89f3f8d09e44a 100644
--- a/crates/bevy_core_pipeline/src/upscaling/mod.rs
+++ b/crates/bevy_core_pipeline/src/upscaling/mod.rs
@@ -1,13 +1,13 @@
 use crate::blit::{BlitPipeline, BlitPipelineKey};
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
+use bevy_platform_support::collections::HashSet;
 use bevy_render::{
     camera::{CameraOutputMode, ExtractedCamera},
     render_resource::*,
     view::ViewTarget,
     Render, RenderApp, RenderSet,
 };
-use bevy_utils::HashSet;
 
 mod node;
 
diff --git a/crates/bevy_diagnostic/Cargo.toml b/crates/bevy_diagnostic/Cargo.toml
index 6706bb20775d5..a21e09eb9a8ac 100644
--- a/crates/bevy_diagnostic/Cargo.toml
+++ b/crates/bevy_diagnostic/Cargo.toml
@@ -19,6 +19,7 @@ serialize = [
   "bevy_ecs/serialize",
   "bevy_time/serialize",
   "bevy_utils/serde",
+  "bevy_platform_support/serialize",
 ]
 
 ## Disables diagnostics that are unsupported when Bevy is dynamically linked
diff --git a/crates/bevy_diagnostic/src/diagnostic.rs b/crates/bevy_diagnostic/src/diagnostic.rs
index 480dfabd8a7bb..af9a3e71e0432 100644
--- a/crates/bevy_diagnostic/src/diagnostic.rs
+++ b/crates/bevy_diagnostic/src/diagnostic.rs
@@ -7,8 +7,7 @@ use core::{
 use bevy_app::{App, SubApp};
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{Deferred, Res, SystemBuffer, SystemParam};
-use bevy_platform_support::time::Instant;
-use bevy_utils::{HashMap, PassHash};
+use bevy_platform_support::{collections::HashMap, hash::PassHash, time::Instant};
 use const_fnv1a_hash::fnv1a_hash_str_64;
 
 use crate::DEFAULT_MAX_HISTORY_LENGTH;
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 376a61f1e93a9..e0b33a17d9c85 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -20,7 +20,7 @@ default = ["std", "bevy_reflect", "async_executor"]
 multi_threaded = ["bevy_tasks/multi_threaded", "dep:arrayvec"]
 
 ## Adds serialization support through `serde`.
-serialize = ["dep:serde", "bevy_utils/serde"]
+serialize = ["dep:serde", "bevy_utils/serde", "bevy_platform_support/serialize"]
 
 ## Adds runtime reflection support using `bevy_reflect`.
 bevy_reflect = ["dep:bevy_reflect"]
diff --git a/crates/bevy_ecs/src/archetype.rs b/crates/bevy_ecs/src/archetype.rs
index 8d0a6d3e5b7c9..e6ae5e4ae3e75 100644
--- a/crates/bevy_ecs/src/archetype.rs
+++ b/crates/bevy_ecs/src/archetype.rs
@@ -27,7 +27,7 @@ use crate::{
     storage::{ImmutableSparseSet, SparseArray, SparseSet, SparseSetIndex, TableId, TableRow},
 };
 use alloc::{boxed::Box, vec::Vec};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::{
     hash::Hash,
     ops::{Index, IndexMut, RangeFrom},
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index 8b3a5bd909f8f..7919a3232d1b3 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -21,8 +21,9 @@ use crate::{
     world::{unsafe_world_cell::UnsafeWorldCell, ON_ADD, ON_INSERT, ON_REPLACE},
 };
 use alloc::{boxed::Box, vec, vec::Vec};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_ptr::{ConstNonNull, OwningPtr};
-use bevy_utils::{HashMap, HashSet, TypeIdMap};
+use bevy_utils::TypeIdMap;
 #[cfg(feature = "track_location")]
 use core::panic::Location;
 use core::{any::TypeId, ptr::NonNull};
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index ffa270b5f1439..792f85a2457b7 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -16,11 +16,12 @@ use crate::{
 use alloc::boxed::Box;
 use alloc::{borrow::Cow, format, vec::Vec};
 pub use bevy_ecs_macros::Component;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_platform_support::sync::Arc;
 use bevy_ptr::{OwningPtr, UnsafeCellDeref};
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
-use bevy_utils::{HashMap, HashSet, TypeIdMap};
+use bevy_utils::TypeIdMap;
 use core::{
     alloc::Layout,
     any::{Any, TypeId},
@@ -531,7 +532,7 @@ pub struct HookContext {
 ///
 /// ```
 /// use bevy_ecs::prelude::*;
-/// use bevy_utils::HashSet;
+/// use bevy_platform_support::collections::HashSet;
 ///
 /// #[derive(Component)]
 /// struct MyTrackedComponent;
diff --git a/crates/bevy_ecs/src/entity/clone_entities.rs b/crates/bevy_ecs/src/entity/clone_entities.rs
index a57a3e6f6b54f..b337b3c079d33 100644
--- a/crates/bevy_ecs/src/entity/clone_entities.rs
+++ b/crates/bevy_ecs/src/entity/clone_entities.rs
@@ -1,7 +1,7 @@
 use alloc::{borrow::ToOwned, vec::Vec};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_platform_support::sync::Arc;
 use bevy_ptr::{Ptr, PtrMut};
-use bevy_utils::{HashMap, HashSet};
 use bumpalo::Bump;
 use core::{any::TypeId, ptr::NonNull};
 
diff --git a/crates/bevy_ecs/src/entity/hash.rs b/crates/bevy_ecs/src/entity/hash.rs
index b7d4dcae54586..bf957328ef5c2 100644
--- a/crates/bevy_ecs/src/entity/hash.rs
+++ b/crates/bevy_ecs/src/entity/hash.rs
@@ -25,7 +25,7 @@ impl BuildHasher for EntityHash {
 ///
 /// If you have an unusual case -- say all your indices are multiples of 256
 /// or most of the entities are dead generations -- then you might want also to
-/// try [`DefaultHasher`](bevy_utils::DefaultHasher) for a slower hash
+/// try [`DefaultHasher`](bevy_platform_support::hash::DefaultHasher) for a slower hash
 /// computation but fewer lookup conflicts.
 #[derive(Debug, Default)]
 pub struct EntityHasher {
diff --git a/crates/bevy_ecs/src/entity/hash_map.rs b/crates/bevy_ecs/src/entity/hash_map.rs
index d7635401418e9..627f30cbe79ea 100644
--- a/crates/bevy_ecs/src/entity/hash_map.rs
+++ b/crates/bevy_ecs/src/entity/hash_map.rs
@@ -1,6 +1,6 @@
 //! Contains the [`EntityHashMap`] type, a [`HashMap`] pre-configured to use [`EntityHash`] hashing.
 //!
-//! This module is a lightweight wrapper around [`hashbrown`](bevy_utils::hashbrown)'s [`HashMap`] that is more performant for [`Entity`] keys.
+//! This module is a lightweight wrapper around Bevy's [`HashMap`] that is more performant for [`Entity`] keys.
 
 use core::{
     fmt::{self, Debug, Formatter},
@@ -9,9 +9,9 @@ use core::{
     ops::{Deref, DerefMut, Index},
 };
 
+use bevy_platform_support::collections::hash_map::{self, HashMap};
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
-use bevy_utils::hashbrown::hash_map::{self, HashMap};
 
 use super::{Entity, EntityHash, EntitySetIterator, TrustedEntityBorrow};
 
diff --git a/crates/bevy_ecs/src/entity/hash_set.rs b/crates/bevy_ecs/src/entity/hash_set.rs
index d1b917388ea33..2f02578e56d0d 100644
--- a/crates/bevy_ecs/src/entity/hash_set.rs
+++ b/crates/bevy_ecs/src/entity/hash_set.rs
@@ -1,6 +1,6 @@
 //! Contains the [`EntityHashSet`] type, a [`HashSet`] pre-configured to use [`EntityHash`] hashing.
 //!
-//! This module is a lightweight wrapper around [`hashbrown`](bevy_utils::hashbrown)'s [`HashSet`] that is more performant for [`Entity`] keys.
+//! This module is a lightweight wrapper around Bevy's [`HashSet`] that is more performant for [`Entity`] keys.
 
 use core::{
     fmt::{self, Debug, Formatter},
@@ -12,9 +12,9 @@ use core::{
     },
 };
 
+use bevy_platform_support::collections::hash_set::{self, HashSet};
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
-use bevy_utils::hashbrown::hash_set::{self, HashSet};
 
 use super::{Entity, EntityHash, EntitySetIterator};
 
diff --git a/crates/bevy_ecs/src/entity/map_entities.rs b/crates/bevy_ecs/src/entity/map_entities.rs
index 688b523380bf0..05c11781de788 100644
--- a/crates/bevy_ecs/src/entity/map_entities.rs
+++ b/crates/bevy_ecs/src/entity/map_entities.rs
@@ -23,7 +23,7 @@ use super::{hash_map::EntityHashMap, VisitEntitiesMut};
 /// Implementing this trait correctly is required for properly loading components
 /// with entity references from scenes.
 ///
-/// [`HashSet<Entity>`]: bevy_utils::HashSet
+/// [`HashSet<Entity>`]: bevy_platform_support::collections::HashSet
 ///
 /// ## Example
 ///
diff --git a/crates/bevy_ecs/src/entity/visit_entities.rs b/crates/bevy_ecs/src/entity/visit_entities.rs
index 0f957ca265a7a..477216a4bcfef 100644
--- a/crates/bevy_ecs/src/entity/visit_entities.rs
+++ b/crates/bevy_ecs/src/entity/visit_entities.rs
@@ -62,7 +62,7 @@ mod tests {
         world::World,
     };
     use alloc::{string::String, vec, vec::Vec};
-    use bevy_utils::HashSet;
+    use bevy_platform_support::collections::HashSet;
 
     use super::*;
 
diff --git a/crates/bevy_ecs/src/intern.rs b/crates/bevy_ecs/src/intern.rs
index 68b9c1bcfbc52..5639d5fbe33ec 100644
--- a/crates/bevy_ecs/src/intern.rs
+++ b/crates/bevy_ecs/src/intern.rs
@@ -5,11 +5,13 @@
 //! and make comparisons for any type as fast as integers.
 
 use alloc::{borrow::ToOwned, boxed::Box};
+use bevy_platform_support::{
+    collections::HashSet,
+    hash::FixedHasher,
+    sync::{PoisonError, RwLock},
+};
 use core::{fmt::Debug, hash::Hash, ops::Deref};
 
-use bevy_platform_support::sync::{PoisonError, RwLock};
-use bevy_utils::{FixedHasher, HashSet};
-
 /// An interned value. Will stay valid until the end of the program and will not drop.
 ///
 /// For details on interning, see [the module level docs](self).
@@ -168,7 +170,7 @@ impl<T: ?Sized> Default for Interner<T> {
 #[cfg(test)]
 mod tests {
     use alloc::{boxed::Box, string::ToString};
-    use bevy_utils::FixedHasher;
+    use bevy_platform_support::hash::FixedHasher;
     use core::hash::{BuildHasher, Hash, Hasher};
 
     use crate::intern::{Internable, Interned, Interner};
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index b79ac90f468ef..239b24247bff2 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -146,8 +146,8 @@ mod tests {
         vec::Vec,
     };
     use bevy_ecs_macros::{VisitEntities, VisitEntitiesMut};
+    use bevy_platform_support::collections::HashSet;
     use bevy_tasks::{ComputeTaskPool, TaskPool};
-    use bevy_utils::HashSet;
     use core::{
         any::TypeId,
         marker::PhantomData,
diff --git a/crates/bevy_ecs/src/name.rs b/crates/bevy_ecs/src/name.rs
index 05bc0e8c9cd8e..c5557bc409cf8 100644
--- a/crates/bevy_ecs/src/name.rs
+++ b/crates/bevy_ecs/src/name.rs
@@ -6,7 +6,7 @@ use alloc::{
     borrow::{Cow, ToOwned},
     string::String,
 };
-use bevy_utils::FixedHasher;
+use bevy_platform_support::hash::FixedHasher;
 use core::{
     hash::{BuildHasher, Hash, Hasher},
     ops::Deref,
diff --git a/crates/bevy_ecs/src/observer/mod.rs b/crates/bevy_ecs/src/observer/mod.rs
index c97e560d174de..b5d55d8798960 100644
--- a/crates/bevy_ecs/src/observer/mod.rs
+++ b/crates/bevy_ecs/src/observer/mod.rs
@@ -15,8 +15,8 @@ use crate::{
     world::{DeferredWorld, *},
 };
 use alloc::vec::Vec;
+use bevy_platform_support::collections::HashMap;
 use bevy_ptr::Ptr;
-use bevy_utils::HashMap;
 use core::{
     fmt::Debug,
     marker::PhantomData,
@@ -846,8 +846,8 @@ mod tests {
     #[cfg(feature = "track_location")]
     use core::panic::Location;
 
+    use bevy_platform_support::collections::HashMap;
     use bevy_ptr::OwningPtr;
-    use bevy_utils::HashMap;
 
     use crate as bevy_ecs;
     use crate::component::ComponentId;
diff --git a/crates/bevy_ecs/src/schedule/graph/graph_map.rs b/crates/bevy_ecs/src/schedule/graph/graph_map.rs
index 35f3260d3e5a7..b6f233ad78f07 100644
--- a/crates/bevy_ecs/src/schedule/graph/graph_map.rs
+++ b/crates/bevy_ecs/src/schedule/graph/graph_map.rs
@@ -5,7 +5,7 @@
 //! [`petgraph`]: https://docs.rs/petgraph/0.6.5/petgraph/
 
 use alloc::vec::Vec;
-use bevy_utils::{hashbrown::HashSet, FixedHasher};
+use bevy_platform_support::{collections::HashSet, hash::FixedHasher};
 use core::{
     fmt,
     hash::{BuildHasher, Hash},
diff --git a/crates/bevy_ecs/src/schedule/graph/mod.rs b/crates/bevy_ecs/src/schedule/graph/mod.rs
index eb55d7db0d86c..ed94d245734f6 100644
--- a/crates/bevy_ecs/src/schedule/graph/mod.rs
+++ b/crates/bevy_ecs/src/schedule/graph/mod.rs
@@ -2,7 +2,7 @@ use alloc::{vec, vec::Vec};
 use core::fmt::Debug;
 use smallvec::SmallVec;
 
-use bevy_utils::{HashMap, HashSet};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use fixedbitset::FixedBitSet;
 
 use crate::schedule::set::*;
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
index eca575a9491c0..2b30b670c5bab 100644
--- a/crates/bevy_ecs/src/schedule/schedule.rs
+++ b/crates/bevy_ecs/src/schedule/schedule.rs
@@ -10,7 +10,8 @@ use alloc::{
     vec,
     vec::Vec,
 };
-use bevy_utils::{default, HashMap, HashSet};
+use bevy_platform_support::collections::{HashMap, HashSet};
+use bevy_utils::default;
 use core::fmt::{Debug, Write};
 use disqualified::ShortName;
 use fixedbitset::FixedBitSet;
diff --git a/crates/bevy_ecs/src/schedule/stepping.rs b/crates/bevy_ecs/src/schedule/stepping.rs
index 26d04655b4a23..2ba41c60b8cd5 100644
--- a/crates/bevy_ecs/src/schedule/stepping.rs
+++ b/crates/bevy_ecs/src/schedule/stepping.rs
@@ -4,7 +4,8 @@ use crate::{
     system::{IntoSystem, ResMut},
 };
 use alloc::vec::Vec;
-use bevy_utils::{HashMap, TypeIdMap};
+use bevy_platform_support::collections::HashMap;
+use bevy_utils::TypeIdMap;
 use core::any::TypeId;
 use fixedbitset::FixedBitSet;
 use log::{info, warn};
diff --git a/crates/bevy_ecs/src/storage/table/mod.rs b/crates/bevy_ecs/src/storage/table/mod.rs
index 25c343a531bfc..cd823851cc06b 100644
--- a/crates/bevy_ecs/src/storage/table/mod.rs
+++ b/crates/bevy_ecs/src/storage/table/mod.rs
@@ -6,8 +6,8 @@ use crate::{
     storage::{blob_vec::BlobVec, ImmutableSparseSet, SparseSet},
 };
 use alloc::{boxed::Box, vec, vec::Vec};
+use bevy_platform_support::collections::HashMap;
 use bevy_ptr::{OwningPtr, Ptr, UnsafeCellDeref};
-use bevy_utils::HashMap;
 pub use column::*;
 #[cfg(feature = "track_location")]
 use core::panic::Location;
diff --git a/crates/bevy_ecs/src/world/entity_ref.rs b/crates/bevy_ecs/src/world/entity_ref.rs
index bc47197228f38..b8146fa86a313 100644
--- a/crates/bevy_ecs/src/world/entity_ref.rs
+++ b/crates/bevy_ecs/src/world/entity_ref.rs
@@ -19,8 +19,8 @@ use crate::{
     },
 };
 use alloc::vec::Vec;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_ptr::{OwningPtr, Ptr};
-use bevy_utils::{HashMap, HashSet};
 #[cfg(feature = "track_location")]
 use core::panic::Location;
 use core::{
@@ -244,7 +244,7 @@ impl<'w> EntityRef<'w> {
     /// ## [`HashSet`] of [`ComponentId`]s
     ///
     /// ```
-    /// # use bevy_utils::HashSet;
+    /// # use bevy_platform_support::collections::HashSet;
     /// # use bevy_ecs::{prelude::*, component::ComponentId};
     /// #
     /// # #[derive(Component, PartialEq, Debug)]
@@ -787,7 +787,7 @@ impl<'w> EntityMut<'w> {
     /// ## [`HashSet`] of [`ComponentId`]s
     ///
     /// ```
-    /// # use bevy_utils::HashSet;
+    /// # use bevy_platform_support::collections::HashSet;
     /// # use bevy_ecs::{prelude::*, component::ComponentId};
     /// #
     /// # #[derive(Component, PartialEq, Debug)]
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 22520ac71a268..e42801c5579e6 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -3778,7 +3778,7 @@ mod tests {
         vec::Vec,
     };
     use bevy_ecs_macros::Component;
-    use bevy_utils::{HashMap, HashSet};
+    use bevy_platform_support::collections::{HashMap, HashSet};
     use core::{
         any::TypeId,
         panic,
diff --git a/crates/bevy_gilrs/Cargo.toml b/crates/bevy_gilrs/Cargo.toml
index 65e25d5c90837..9b3996c05f387 100644
--- a/crates/bevy_gilrs/Cargo.toml
+++ b/crates/bevy_gilrs/Cargo.toml
@@ -15,6 +15,9 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.16.0-dev" }
 bevy_input = { path = "../bevy_input", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_time = { path = "../bevy_time", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # other
 gilrs = "0.11.0"
diff --git a/crates/bevy_gilrs/src/lib.rs b/crates/bevy_gilrs/src/lib.rs
index 404b6894ac658..b9f1443e5b245 100644
--- a/crates/bevy_gilrs/src/lib.rs
+++ b/crates/bevy_gilrs/src/lib.rs
@@ -18,7 +18,8 @@ use bevy_app::{App, Plugin, PostUpdate, PreStartup, PreUpdate};
 use bevy_ecs::entity::hash_map::EntityHashMap;
 use bevy_ecs::prelude::*;
 use bevy_input::InputSystem;
-use bevy_utils::{synccell::SyncCell, HashMap};
+use bevy_platform_support::collections::HashMap;
+use bevy_utils::synccell::SyncCell;
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
 use rumble::{play_gilrs_rumble, RunningRumbleEffects};
diff --git a/crates/bevy_gilrs/src/rumble.rs b/crates/bevy_gilrs/src/rumble.rs
index e0fdff62d8cf2..53a0c945cedef 100644
--- a/crates/bevy_gilrs/src/rumble.rs
+++ b/crates/bevy_gilrs/src/rumble.rs
@@ -4,8 +4,9 @@ use bevy_ecs::prelude::{EventReader, Res, ResMut, Resource};
 #[cfg(target_arch = "wasm32")]
 use bevy_ecs::system::NonSendMut;
 use bevy_input::gamepad::{GamepadRumbleIntensity, GamepadRumbleRequest};
+use bevy_platform_support::collections::HashMap;
 use bevy_time::{Real, Time};
-use bevy_utils::{synccell::SyncCell, HashMap};
+use bevy_utils::synccell::SyncCell;
 use core::time::Duration;
 use gilrs::{
     ff::{self, BaseEffect, BaseEffectType, Repeat, Replay},
diff --git a/crates/bevy_gltf/Cargo.toml b/crates/bevy_gltf/Cargo.toml
index 023194f8a849a..c979ae47f4a54 100644
--- a/crates/bevy_gltf/Cargo.toml
+++ b/crates/bevy_gltf/Cargo.toml
@@ -37,6 +37,10 @@ bevy_scene = { path = "../bevy_scene", version = "0.16.0-dev", features = [
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+  "serialize",
+] }
 
 # other
 gltf = { version = "1.4.0", default-features = false, features = [
diff --git a/crates/bevy_gltf/src/lib.rs b/crates/bevy_gltf/src/lib.rs
index b96d49c12d60c..74664b3e37571 100644
--- a/crates/bevy_gltf/src/lib.rs
+++ b/crates/bevy_gltf/src/lib.rs
@@ -94,7 +94,7 @@ extern crate alloc;
 
 #[cfg(feature = "bevy_animation")]
 use bevy_animation::AnimationClip;
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 
 mod loader;
 mod vertex_attributes;
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index f809101ab0fbf..0a86fa45efa22 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -24,6 +24,7 @@ use bevy_pbr::{
     DirectionalLight, MeshMaterial3d, PointLight, SpotLight, StandardMaterial, UvChannel,
     MAX_JOINTS,
 };
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     alpha::AlphaMode,
     camera::{Camera, OrthographicProjection, PerspectiveProjection, Projection, ScalingMode},
@@ -41,7 +42,6 @@ use bevy_scene::Scene;
 #[cfg(not(target_arch = "wasm32"))]
 use bevy_tasks::IoTaskPool;
 use bevy_transform::components::Transform;
-use bevy_utils::{HashMap, HashSet};
 use gltf::{
     accessor::Iter,
     image::Source,
diff --git a/crates/bevy_gltf/src/vertex_attributes.rs b/crates/bevy_gltf/src/vertex_attributes.rs
index d42ecbf397771..2a9cb2cfab2a1 100644
--- a/crates/bevy_gltf/src/vertex_attributes.rs
+++ b/crates/bevy_gltf/src/vertex_attributes.rs
@@ -1,9 +1,9 @@
+use bevy_platform_support::collections::HashMap;
 use bevy_render::{
     mesh::{MeshVertexAttribute, VertexAttributeValues as Values},
     prelude::Mesh,
     render_resource::VertexFormat,
 };
-use bevy_utils::HashMap;
 use gltf::{
     accessor::{DataType, Dimensions},
     mesh::util::{ReadColors, ReadJoints, ReadTexCoords, ReadWeights},
diff --git a/crates/bevy_image/Cargo.toml b/crates/bevy_image/Cargo.toml
index 5db0ad91ee055..a702a5caae136 100644
--- a/crates/bevy_image/Cargo.toml
+++ b/crates/bevy_image/Cargo.toml
@@ -30,7 +30,11 @@ qoi = ["image/qoi"]
 tga = ["image/tga"]
 tiff = ["image/tiff"]
 webp = ["image/webp"]
-serialize = ["bevy_reflect"]
+serialize = [
+  "bevy_reflect",
+  "bevy_platform_support/serialize",
+  "bevy_utils/serde",
+]
 
 # For ktx2 supercompression
 zlib = ["flate2"]
@@ -49,6 +53,9 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev", features = [
   "bevy",
 ], optional = true }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # rendering
 image = { version = "0.25.2", default-features = false }
diff --git a/crates/bevy_image/src/texture_atlas.rs b/crates/bevy_image/src/texture_atlas.rs
index 57aa0c379e6ac..36e2acd86456b 100644
--- a/crates/bevy_image/src/texture_atlas.rs
+++ b/crates/bevy_image/src/texture_atlas.rs
@@ -1,11 +1,11 @@
 use bevy_app::prelude::*;
 use bevy_asset::{Asset, AssetApp as _, AssetId, Assets, Handle};
 use bevy_math::{URect, UVec2};
+use bevy_platform_support::collections::HashMap;
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 #[cfg(feature = "serialize")]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
-use bevy_utils::HashMap;
 
 use crate::Image;
 
diff --git a/crates/bevy_image/src/texture_atlas_builder.rs b/crates/bevy_image/src/texture_atlas_builder.rs
index 0b0889d97c993..a207b318f75b0 100644
--- a/crates/bevy_image/src/texture_atlas_builder.rs
+++ b/crates/bevy_image/src/texture_atlas_builder.rs
@@ -1,6 +1,6 @@
 use bevy_asset::{AssetId, RenderAssetUsages};
 use bevy_math::{URect, UVec2};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use rectangle_pack::{
     contains_smallest_box, pack_rects, volume_heuristic, GroupedRectsToPlace, PackedLocation,
     RectToInsert, TargetBin,
diff --git a/crates/bevy_input/Cargo.toml b/crates/bevy_input/Cargo.toml
index eebed09a0a5d4..fbbec96a760ad 100644
--- a/crates/bevy_input/Cargo.toml
+++ b/crates/bevy_input/Cargo.toml
@@ -27,6 +27,7 @@ serialize = [
   "smol_str/serde",
   "bevy_ecs/serialize",
   "bevy_math/serialize",
+  "bevy_platform_support/serialize",
 ]
 
 ## Uses the small-string optimization provided by `smol_str`.
@@ -43,6 +44,7 @@ std = [
   "bevy_math/std",
   "bevy_utils/std",
   "bevy_reflect/std",
+  "bevy_platform_support/std",
 ]
 
 ## `critical-section` provides the building blocks for synchronization primitives
@@ -51,6 +53,7 @@ critical-section = [
   "bevy_app/critical-section",
   "bevy_ecs/critical-section",
   "bevy_reflect?/critical-section",
+  "bevy_platform_support/critical-section",
 ]
 
 ## `portable-atomic` provides additional platform support for atomic types and
@@ -59,6 +62,7 @@ portable-atomic = [
   "bevy_app/portable-atomic",
   "bevy_ecs/portable-atomic",
   "bevy_reflect?/portable-atomic",
+  "bevy_platform_support/portable-atomic",
 ]
 
 ## Uses the `libm` maths library instead of the one provided in `std` and `core`.
@@ -73,6 +77,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev", default-features
 bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev", features = [
   "glam",
 ], default-features = false, optional = true }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false }
 
 # other
 serde = { version = "1", features = [
diff --git a/crates/bevy_input/src/axis.rs b/crates/bevy_input/src/axis.rs
index 99b8315f136fe..acdf0135f0eda 100644
--- a/crates/bevy_input/src/axis.rs
+++ b/crates/bevy_input/src/axis.rs
@@ -1,7 +1,7 @@
 //! The generic axis type.
 
 use bevy_ecs::resource::Resource;
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::hash::Hash;
 
 #[cfg(feature = "bevy_reflect")]
diff --git a/crates/bevy_input/src/button_input.rs b/crates/bevy_input/src/button_input.rs
index a6f0583e36b7a..a1086edf66e78 100644
--- a/crates/bevy_input/src/button_input.rs
+++ b/crates/bevy_input/src/button_input.rs
@@ -1,7 +1,7 @@
 //! The generic input type.
 
 use bevy_ecs::resource::Resource;
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 use core::hash::Hash;
 #[cfg(feature = "bevy_reflect")]
 use {
diff --git a/crates/bevy_input/src/gamepad.rs b/crates/bevy_input/src/gamepad.rs
index d51a087eee1fa..2da9916a7ed7a 100644
--- a/crates/bevy_input/src/gamepad.rs
+++ b/crates/bevy_input/src/gamepad.rs
@@ -17,11 +17,11 @@ use bevy_ecs::{
 };
 use bevy_math::ops;
 use bevy_math::Vec2;
+use bevy_platform_support::collections::HashMap;
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 #[cfg(all(feature = "serialize", feature = "bevy_reflect"))]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
-use bevy_utils::HashMap;
 use derive_more::derive::From;
 use log::{info, warn};
 use thiserror::Error;
diff --git a/crates/bevy_input/src/touch.rs b/crates/bevy_input/src/touch.rs
index a246e204f1e57..e1784c13fdfea 100644
--- a/crates/bevy_input/src/touch.rs
+++ b/crates/bevy_input/src/touch.rs
@@ -7,9 +7,9 @@ use bevy_ecs::{
     system::ResMut,
 };
 use bevy_math::Vec2;
+use bevy_platform_support::collections::HashMap;
 #[cfg(feature = "bevy_reflect")]
 use bevy_reflect::Reflect;
-use bevy_utils::HashMap;
 
 #[cfg(all(feature = "serialize", feature = "bevy_reflect"))]
 use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
diff --git a/crates/bevy_internal/Cargo.toml b/crates/bevy_internal/Cargo.toml
index fe80dbffc5661..ee8214ab3d100 100644
--- a/crates/bevy_internal/Cargo.toml
+++ b/crates/bevy_internal/Cargo.toml
@@ -97,6 +97,7 @@ serialize = [
   "bevy_ui?/serialize",
   "bevy_window?/serialize",
   "bevy_winit?/serialize",
+  "bevy_platform_support/serialize",
 ]
 multi_threaded = [
   "bevy_asset?/multi_threaded",
diff --git a/crates/bevy_mesh/Cargo.toml b/crates/bevy_mesh/Cargo.toml
index d98c3a9b46f34..bb98018ab86f2 100644
--- a/crates/bevy_mesh/Cargo.toml
+++ b/crates/bevy_mesh/Cargo.toml
@@ -21,6 +21,10 @@ bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_mikktspace = { path = "../bevy_mikktspace", version = "0.16.0-dev" }
 bevy_derive = { path = "../bevy_derive", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+  "serialize",
+] }
 
 # other
 bitflags = { version = "2.3", features = ["serde"] }
diff --git a/crates/bevy_mesh/src/primitives/dim2.rs b/crates/bevy_mesh/src/primitives/dim2.rs
index 7087ab44bd144..47761ea355690 100644
--- a/crates/bevy_mesh/src/primitives/dim2.rs
+++ b/crates/bevy_mesh/src/primitives/dim2.rs
@@ -1128,7 +1128,7 @@ impl From<Capsule2d> for Mesh {
 #[cfg(test)]
 mod tests {
     use bevy_math::{prelude::Annulus, primitives::RegularPolygon, FloatOrd};
-    use bevy_utils::HashSet;
+    use bevy_platform_support::collections::HashSet;
 
     use crate::{Mesh, MeshBuilder, Meshable, VertexAttributeValues};
 
diff --git a/crates/bevy_mesh/src/vertex.rs b/crates/bevy_mesh/src/vertex.rs
index 2e85cce1b9f3f..51d44f67bae15 100644
--- a/crates/bevy_mesh/src/vertex.rs
+++ b/crates/bevy_mesh/src/vertex.rs
@@ -2,7 +2,7 @@ use alloc::sync::Arc;
 use bevy_derive::EnumVariantMeta;
 use bevy_ecs::resource::Resource;
 use bevy_math::Vec3;
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 use bytemuck::cast_slice;
 use core::hash::{Hash, Hasher};
 use thiserror::Error;
diff --git a/crates/bevy_pbr/Cargo.toml b/crates/bevy_pbr/Cargo.toml
index f180cdb9fb3ee..cb8a22fb8b1e5 100644
--- a/crates/bevy_pbr/Cargo.toml
+++ b/crates/bevy_pbr/Cargo.toml
@@ -47,6 +47,9 @@ bevy_tasks = { path = "../bevy_tasks", version = "0.16.0-dev", optional = true }
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # other
 bitflags = "2.3"
diff --git a/crates/bevy_pbr/src/cluster/mod.rs b/crates/bevy_pbr/src/cluster/mod.rs
index 68fea8de0990e..b943a6f7a0109 100644
--- a/crates/bevy_pbr/src/cluster/mod.rs
+++ b/crates/bevy_pbr/src/cluster/mod.rs
@@ -13,6 +13,7 @@ use bevy_ecs::{
     world::{FromWorld, World},
 };
 use bevy_math::{uvec4, AspectRatio, UVec2, UVec3, UVec4, Vec3Swizzles as _, Vec4};
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{
     camera::Camera,
@@ -24,7 +25,6 @@ use bevy_render::{
     sync_world::RenderEntity,
     Extract,
 };
-use bevy_utils::HashSet;
 use tracing::warn;
 
 pub(crate) use crate::cluster::assign::assign_objects_to_clusters;
diff --git a/crates/bevy_pbr/src/light_probe/mod.rs b/crates/bevy_pbr/src/light_probe/mod.rs
index ae2c4b05735eb..5cf96965ad989 100644
--- a/crates/bevy_pbr/src/light_probe/mod.rs
+++ b/crates/bevy_pbr/src/light_probe/mod.rs
@@ -15,6 +15,7 @@ use bevy_ecs::{
 };
 use bevy_image::Image;
 use bevy_math::{Affine3A, FloatOrd, Mat4, Vec3A, Vec4};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{
     extract_instances::ExtractInstancesPlugin,
@@ -29,7 +30,6 @@ use bevy_render::{
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_transform::{components::Transform, prelude::GlobalTransform};
-use bevy_utils::HashMap;
 use tracing::error;
 
 use core::{hash::Hash, ops::Deref};
diff --git a/crates/bevy_pbr/src/lightmap/mod.rs b/crates/bevy_pbr/src/lightmap/mod.rs
index ee38a94d3bcc4..3809ea711bc36 100644
--- a/crates/bevy_pbr/src/lightmap/mod.rs
+++ b/crates/bevy_pbr/src/lightmap/mod.rs
@@ -47,6 +47,7 @@ use bevy_ecs::{
 };
 use bevy_image::Image;
 use bevy_math::{uvec2, vec4, Rect, UVec2};
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{
     render_asset::RenderAssets,
@@ -58,7 +59,7 @@ use bevy_render::{
     Extract, ExtractSchedule, RenderApp,
 };
 use bevy_render::{renderer::RenderDevice, sync_world::MainEntityHashMap};
-use bevy_utils::{default, HashSet};
+use bevy_utils::default;
 use fixedbitset::FixedBitSet;
 use nonmax::{NonMaxU16, NonMaxU32};
 use tracing::error;
diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index df7fb2142d34a..96ccdf781e840 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -27,6 +27,7 @@ use bevy_ecs::{
         SystemParamItem,
     },
 };
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::Reflect;
 use bevy_render::{
@@ -44,7 +45,6 @@ use bevy_render::{
 };
 use bevy_render::{mesh::allocator::MeshAllocator, sync_world::MainEntityHashMap};
 use bevy_render::{texture::FallbackImage, view::RenderVisibleEntities};
-use bevy_utils::HashMap;
 use core::{hash::Hash, marker::PhantomData};
 use tracing::error;
 
diff --git a/crates/bevy_pbr/src/material_bind_groups.rs b/crates/bevy_pbr/src/material_bind_groups.rs
index fddd4d7712cba..9066537a72ad8 100644
--- a/crates/bevy_pbr/src/material_bind_groups.rs
+++ b/crates/bevy_pbr/src/material_bind_groups.rs
@@ -10,6 +10,7 @@ use bevy_ecs::{
     resource::Resource,
     world::{FromWorld, World},
 };
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{
     render_resource::{
@@ -21,7 +22,7 @@ use bevy_render::{
     renderer::RenderDevice,
     texture::FallbackImage,
 };
-use bevy_utils::{default, HashMap};
+use bevy_utils::default;
 use core::{any, iter, marker::PhantomData, num::NonZero};
 use tracing::error;
 
diff --git a/crates/bevy_pbr/src/meshlet/from_mesh.rs b/crates/bevy_pbr/src/meshlet/from_mesh.rs
index 8d4f1c7533ba2..7b959eef46887 100644
--- a/crates/bevy_pbr/src/meshlet/from_mesh.rs
+++ b/crates/bevy_pbr/src/meshlet/from_mesh.rs
@@ -3,11 +3,11 @@ use super::asset::{
 };
 use alloc::borrow::Cow;
 use bevy_math::{ops::log2, IVec3, Vec2, Vec3, Vec3Swizzles};
+use bevy_platform_support::collections::HashMap;
 use bevy_render::{
     mesh::{Indices, Mesh},
     render_resource::PrimitiveTopology,
 };
-use bevy_utils::HashMap;
 use bitvec::{order::Lsb0, vec::BitVec, view::BitView};
 use core::{iter, ops::Range};
 use half::f16;
diff --git a/crates/bevy_pbr/src/meshlet/instance_manager.rs b/crates/bevy_pbr/src/meshlet/instance_manager.rs
index 1f62ed64700ad..26f6432a1fdf7 100644
--- a/crates/bevy_pbr/src/meshlet/instance_manager.rs
+++ b/crates/bevy_pbr/src/meshlet/instance_manager.rs
@@ -12,11 +12,11 @@ use bevy_ecs::{
     resource::Resource,
     system::{Local, Query, Res, ResMut, SystemState},
 };
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     render_resource::StorageBuffer, sync_world::MainEntity, view::RenderLayers, MainWorld,
 };
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::{HashMap, HashSet};
 use core::ops::{DerefMut, Range};
 
 /// Manages data for each entity with a [`MeshletMesh`].
diff --git a/crates/bevy_pbr/src/meshlet/material_pipeline_prepare.rs b/crates/bevy_pbr/src/meshlet/material_pipeline_prepare.rs
index 7ce19cc50e259..0e71d5a9d9dcf 100644
--- a/crates/bevy_pbr/src/meshlet/material_pipeline_prepare.rs
+++ b/crates/bevy_pbr/src/meshlet/material_pipeline_prepare.rs
@@ -13,6 +13,7 @@ use bevy_core_pipeline::{
     tonemapping::{DebandDither, Tonemapping},
 };
 use bevy_derive::{Deref, DerefMut};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     camera::TemporalJitter,
     mesh::{Mesh, MeshVertexBufferLayout, MeshVertexBufferLayoutRef, MeshVertexBufferLayouts},
@@ -20,7 +21,6 @@ use bevy_render::{
     render_resource::*,
     view::ExtractedView,
 };
-use bevy_utils::{HashMap, HashSet};
 use core::hash::Hash;
 
 /// A list of `(Material ID, Pipeline, BindGroup)` for a view for use in [`super::MeshletMainOpaquePass3dNode`].
diff --git a/crates/bevy_pbr/src/meshlet/meshlet_mesh_manager.rs b/crates/bevy_pbr/src/meshlet/meshlet_mesh_manager.rs
index fe9064ebc263c..2bc686fe43cc7 100644
--- a/crates/bevy_pbr/src/meshlet/meshlet_mesh_manager.rs
+++ b/crates/bevy_pbr/src/meshlet/meshlet_mesh_manager.rs
@@ -11,11 +11,11 @@ use bevy_ecs::{
     world::{FromWorld, World},
 };
 use bevy_math::Vec2;
+use bevy_platform_support::collections::HashMap;
 use bevy_render::{
     render_resource::BufferAddress,
     renderer::{RenderDevice, RenderQueue},
 };
-use bevy_utils::HashMap;
 use core::ops::Range;
 
 /// Manages uploading [`MeshletMesh`] asset data to the GPU.
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
index 63fca28aed909..ff4c0b0ac8d48 100644
--- a/crates/bevy_pbr/src/render/light.rs
+++ b/crates/bevy_pbr/src/render/light.rs
@@ -11,6 +11,7 @@ use bevy_ecs::{
     system::lifetimeless::Read,
 };
 use bevy_math::{ops, Mat4, UVec4, Vec2, Vec3, Vec3Swizzles, Vec4, Vec4Swizzles};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render::{
     batching::gpu_preprocessing::{GpuPreprocessingMode, GpuPreprocessingSupport},
     camera::SortedCameras,
@@ -35,7 +36,7 @@ use bevy_render::{
     sync_world::{MainEntity, RenderEntity},
 };
 use bevy_transform::{components::GlobalTransform, prelude::Transform};
-use bevy_utils::{default, HashMap, HashSet};
+use bevy_utils::default;
 use core::{hash::Hash, ops::Range};
 #[cfg(feature = "trace")]
 use tracing::info_span;
diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
index 0ce11ec2ff041..431f353ec81cf 100644
--- a/crates/bevy_pbr/src/render/mesh.rs
+++ b/crates/bevy_pbr/src/render/mesh.rs
@@ -17,6 +17,7 @@ use bevy_ecs::{
 };
 use bevy_image::{BevyDefault, ImageSampler, TextureFormatPixelInfo};
 use bevy_math::{Affine3, Rect, UVec2, Vec3, Vec4};
+use bevy_platform_support::collections::{hash_map::Entry, HashMap};
 use bevy_render::{
     batching::{
         gpu_preprocessing::{
@@ -44,7 +45,7 @@ use bevy_render::{
     Extract,
 };
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::{default, hashbrown::hash_map::Entry, HashMap, Parallel};
+use bevy_utils::{default, Parallel};
 use material_bind_groups::MaterialBindingId;
 use render::skin::{self, SkinIndex};
 use tracing::{error, warn};
diff --git a/crates/bevy_picking/src/backend.rs b/crates/bevy_picking/src/backend.rs
index c7715723bf923..597b238620c7f 100644
--- a/crates/bevy_picking/src/backend.rs
+++ b/crates/bevy_picking/src/backend.rs
@@ -129,10 +129,10 @@ pub mod ray {
     use crate::backend::prelude::{PointerId, PointerLocation};
     use bevy_ecs::prelude::*;
     use bevy_math::Ray3d;
+    use bevy_platform_support::collections::{hash_map::Iter, HashMap};
     use bevy_reflect::Reflect;
     use bevy_render::camera::Camera;
     use bevy_transform::prelude::GlobalTransform;
-    use bevy_utils::{hashbrown::hash_map::Iter, HashMap};
     use bevy_window::PrimaryWindow;
 
     /// Identifies a ray constructed from some (pointer, camera) combination. A pointer can be over
diff --git a/crates/bevy_picking/src/events.rs b/crates/bevy_picking/src/events.rs
index e0d8a70c858ea..f5a4b8d67f412 100644
--- a/crates/bevy_picking/src/events.rs
+++ b/crates/bevy_picking/src/events.rs
@@ -41,10 +41,10 @@ use core::{fmt::Debug, time::Duration};
 
 use bevy_ecs::{prelude::*, query::QueryData, system::SystemParam, traversal::Traversal};
 use bevy_math::Vec2;
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::time::Instant;
 use bevy_reflect::prelude::*;
 use bevy_render::camera::NormalizedRenderTarget;
-use bevy_utils::HashMap;
 use bevy_window::Window;
 use tracing::debug;
 
diff --git a/crates/bevy_picking/src/hover.rs b/crates/bevy_picking/src/hover.rs
index e9545afd3a3e2..69edb6d9aa9f8 100644
--- a/crates/bevy_picking/src/hover.rs
+++ b/crates/bevy_picking/src/hover.rs
@@ -16,8 +16,8 @@ use crate::{
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::prelude::*;
 use bevy_math::FloatOrd;
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::prelude::*;
-use bevy_utils::HashMap;
 
 type DepthSortedHits = Vec<(Entity, HitData)>;
 
diff --git a/crates/bevy_picking/src/input.rs b/crates/bevy_picking/src/input.rs
index 25fe80da4056e..a0b4ac0830863 100644
--- a/crates/bevy_picking/src/input.rs
+++ b/crates/bevy_picking/src/input.rs
@@ -19,9 +19,9 @@ use bevy_input::{
     ButtonState,
 };
 use bevy_math::Vec2;
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_reflect::prelude::*;
 use bevy_render::camera::RenderTarget;
-use bevy_utils::{HashMap, HashSet};
 use bevy_window::{PrimaryWindow, WindowEvent, WindowRef};
 use tracing::debug;
 
diff --git a/crates/bevy_picking/src/pointer.rs b/crates/bevy_picking/src/pointer.rs
index 3f82bd1f1a1e0..ae5cf9133b98b 100644
--- a/crates/bevy_picking/src/pointer.rs
+++ b/crates/bevy_picking/src/pointer.rs
@@ -10,9 +10,9 @@
 
 use bevy_ecs::prelude::*;
 use bevy_math::Vec2;
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::prelude::*;
 use bevy_render::camera::{Camera, NormalizedRenderTarget};
-use bevy_utils::HashMap;
 use bevy_window::PrimaryWindow;
 
 use uuid::Uuid;
diff --git a/crates/bevy_platform_support/Cargo.toml b/crates/bevy_platform_support/Cargo.toml
index 7ab97bbc42921..9d83bddf26b3c 100644
--- a/crates/bevy_platform_support/Cargo.toml
+++ b/crates/bevy_platform_support/Cargo.toml
@@ -11,6 +11,11 @@ keywords = ["bevy"]
 [features]
 default = ["std"]
 
+# Functionality
+
+## Adds serialization support through `serde`.
+serialize = ["hashbrown/serde"]
+
 # Platform Compatibility
 
 ## Allows access to the `std` crate. Enabling this feature will prevent compilation
@@ -22,9 +27,10 @@ std = [
   "portable-atomic?/std",
   "portable-atomic-util?/std",
   "spin/std",
+  "foldhash/std",
 ]
 
-alloc = ["portable-atomic-util?/alloc"]
+alloc = ["portable-atomic-util?/alloc", "dep:hashbrown"]
 
 ## `critical-section` provides the building blocks for synchronization primitives
 ## on all platforms, including `no_std`.
@@ -52,6 +58,11 @@ spin = { version = "0.9.8", default-features = false, features = [
   "lazy",
   "barrier",
 ] }
+foldhash = { version = "0.1.3", default-features = false }
+hashbrown = { version = "0.15.1", features = [
+  "equivalent",
+  "raw-entry",
+], optional = true, default-features = false }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 web-time = { version = "1.1", default-features = false }
diff --git a/crates/bevy_platform_support/src/collections.rs b/crates/bevy_platform_support/src/collections.rs
new file mode 100644
index 0000000000000..8a7fef6116038
--- /dev/null
+++ b/crates/bevy_platform_support/src/collections.rs
@@ -0,0 +1,64 @@
+//! Provides [`HashMap`] and [`HashSet`] from [`hashbrown`] with some customized defaults.\
+//!
+//! Also provides the [`HashTable`] type, which is specific to [`hashbrown`].
+
+pub use hash_map::HashMap;
+pub use hash_set::HashSet;
+pub use hash_table::HashTable;
+pub use hashbrown::Equivalent;
+
+pub mod hash_map {
+    //! Provides [`HashMap`]
+
+    use crate::hash::FixedHasher;
+    use hashbrown::hash_map as hb;
+
+    // Re-exports to match `std::collections::hash_map`
+    pub use {
+        crate::hash::{DefaultHasher, RandomState},
+        hb::{
+            Drain, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, OccupiedEntry, VacantEntry,
+            Values, ValuesMut,
+        },
+    };
+
+    // Additional items from `hashbrown`
+    pub use hb::{
+        EntryRef, ExtractIf, OccupiedError, RawEntryBuilder, RawEntryBuilderMut, RawEntryMut,
+        RawOccupiedEntryMut,
+    };
+
+    /// Shortcut for [`HashMap`](hb::HashMap) with [`FixedHasher`] as the default hashing provider.
+    pub type HashMap<K, V, S = FixedHasher> = hb::HashMap<K, V, S>;
+
+    /// Shortcut for [`Entry`](hb::Entry) with [`FixedHasher`] as the default hashing provider.
+    pub type Entry<'a, K, V, S = FixedHasher> = hb::Entry<'a, K, V, S>;
+}
+
+pub mod hash_set {
+    //! Provides [`HashSet`]
+
+    use crate::hash::FixedHasher;
+    use hashbrown::hash_set as hb;
+
+    // Re-exports to match `std::collections::hash_set`
+    pub use hb::{Difference, Drain, Intersection, IntoIter, Iter, SymmetricDifference, Union};
+
+    // Additional items from `hashbrown`
+    pub use hb::{ExtractIf, OccupiedEntry, VacantEntry};
+
+    /// Shortcut for [`HashSet`](hb::HashSet) with [`FixedHasher`] as the default hashing provider.
+    pub type HashSet<T, S = FixedHasher> = hb::HashSet<T, S>;
+
+    /// Shortcut for [`Entry`](hb::Entry) with [`FixedHasher`] as the default hashing provider.
+    pub type Entry<'a, T, S = FixedHasher> = hb::Entry<'a, T, S>;
+}
+
+pub mod hash_table {
+    //! Provides [`HashTable`]
+
+    pub use hashbrown::hash_table::{
+        AbsentEntry, Drain, Entry, ExtractIf, HashTable, IntoIter, Iter, IterHash, IterHashMut,
+        IterMut, OccupiedEntry, VacantEntry,
+    };
+}
diff --git a/crates/bevy_platform_support/src/hash.rs b/crates/bevy_platform_support/src/hash.rs
new file mode 100644
index 0000000000000..3b1a836ecf83d
--- /dev/null
+++ b/crates/bevy_platform_support/src/hash.rs
@@ -0,0 +1,180 @@
+//! Provides replacements for `std::hash` items using [`foldhash`].
+//!
+//! Also provides some additional items beyond the standard library.
+
+use core::{
+    fmt::Debug,
+    hash::{BuildHasher, Hash, Hasher},
+    marker::PhantomData,
+    ops::Deref,
+};
+
+pub use foldhash::fast::{FixedState, FoldHasher as DefaultHasher, RandomState};
+
+/// For when you want a deterministic hasher.
+///
+/// Seed was randomly generated with a fair dice roll. Guaranteed to be random:
+/// <https://github.com/bevyengine/bevy/pull/1268/files#r560918426>
+const FIXED_HASHER: FixedState =
+    FixedState::with_seed(0b1001010111101110000001001100010000000011001001101011001001111000);
+
+/// Deterministic hasher based upon a random but fixed state.
+#[derive(Copy, Clone, Default, Debug)]
+pub struct FixedHasher;
+impl BuildHasher for FixedHasher {
+    type Hasher = DefaultHasher;
+
+    #[inline]
+    fn build_hasher(&self) -> Self::Hasher {
+        FIXED_HASHER.build_hasher()
+    }
+}
+
+/// A pre-hashed value of a specific type. Pre-hashing enables memoization of hashes that are expensive to compute.
+///
+/// It also enables faster [`PartialEq`] comparisons by short circuiting on hash equality.
+/// See [`PassHash`] and [`PassHasher`] for a "pass through" [`BuildHasher`] and [`Hasher`] implementation
+/// designed to work with [`Hashed`]
+/// See `PreHashMap` for a hashmap pre-configured to use [`Hashed`] keys.
+pub struct Hashed<V, S = FixedHasher> {
+    hash: u64,
+    value: V,
+    marker: PhantomData<S>,
+}
+
+impl<V: Hash, H: BuildHasher + Default> Hashed<V, H> {
+    /// Pre-hashes the given value using the [`BuildHasher`] configured in the [`Hashed`] type.
+    pub fn new(value: V) -> Self {
+        Self {
+            hash: H::default().hash_one(&value),
+            value,
+            marker: PhantomData,
+        }
+    }
+
+    /// The pre-computed hash.
+    #[inline]
+    pub fn hash(&self) -> u64 {
+        self.hash
+    }
+}
+
+impl<V, H> Hash for Hashed<V, H> {
+    #[inline]
+    fn hash<R: Hasher>(&self, state: &mut R) {
+        state.write_u64(self.hash);
+    }
+}
+
+impl<V, H> Deref for Hashed<V, H> {
+    type Target = V;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl<V: PartialEq, H> PartialEq for Hashed<V, H> {
+    /// A fast impl of [`PartialEq`] that first checks that `other`'s pre-computed hash
+    /// matches this value's pre-computed hash.
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.hash == other.hash && self.value.eq(&other.value)
+    }
+}
+
+impl<V: Debug, H> Debug for Hashed<V, H> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Hashed")
+            .field("hash", &self.hash)
+            .field("value", &self.value)
+            .finish()
+    }
+}
+
+impl<V: Clone, H> Clone for Hashed<V, H> {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self {
+            hash: self.hash,
+            value: self.value.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<V: Copy, H> Copy for Hashed<V, H> {}
+
+impl<V: Eq, H> Eq for Hashed<V, H> {}
+
+/// A [`BuildHasher`] that results in a [`PassHasher`].
+#[derive(Default, Clone)]
+pub struct PassHash;
+
+impl BuildHasher for PassHash {
+    type Hasher = PassHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        PassHasher::default()
+    }
+}
+
+/// A no-op hash that only works on `u64`s. Will panic if attempting to
+/// hash a type containing non-u64 fields.
+#[derive(Debug, Default)]
+pub struct PassHasher {
+    hash: u64,
+}
+
+impl Hasher for PassHasher {
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.hash
+    }
+
+    fn write(&mut self, _bytes: &[u8]) {
+        panic!("can only hash u64 using PassHasher");
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.hash = i;
+    }
+}
+
+/// [`BuildHasher`] for types that already contain a high-quality hash.
+#[derive(Clone, Default)]
+pub struct NoOpHash;
+
+impl BuildHasher for NoOpHash {
+    type Hasher = NoOpHasher;
+
+    fn build_hasher(&self) -> Self::Hasher {
+        NoOpHasher(0)
+    }
+}
+
+#[doc(hidden)]
+pub struct NoOpHasher(u64);
+
+// This is for types that already contain a high-quality hash and want to skip
+// re-hashing that hash.
+impl Hasher for NoOpHasher {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        // This should never be called by consumers. Prefer to call `write_u64` instead.
+        // Don't break applications (slower fallback, just check in test):
+        self.0 = bytes.iter().fold(self.0, |hash, b| {
+            hash.rotate_left(8).wrapping_add(*b as u64)
+        });
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.0 = i;
+    }
+}
diff --git a/crates/bevy_platform_support/src/lib.rs b/crates/bevy_platform_support/src/lib.rs
index ae571e32864a9..eada254595ab4 100644
--- a/crates/bevy_platform_support/src/lib.rs
+++ b/crates/bevy_platform_support/src/lib.rs
@@ -15,9 +15,13 @@ extern crate std;
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
+pub mod hash;
 pub mod sync;
 pub mod time;
 
+#[cfg(feature = "alloc")]
+pub mod collections;
+
 /// Frequently used items which would typically be included in most contexts.
 ///
 /// When adding `no_std` support to a crate for the first time, often there's a substantial refactor
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index 4ad1963488cc1..49251287ed951 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -87,6 +87,7 @@ bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev", default-features
 bevy_ptr = { path = "../bevy_ptr", version = "0.16.0-dev" }
 bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
   "alloc",
+  "serialize",
 ] }
 
 # used by bevy-utils, but it also needs reflect impls
diff --git a/crates/bevy_reflect/src/enums/enum_trait.rs b/crates/bevy_reflect/src/enums/enum_trait.rs
index 7efd408286332..3fe36fc8cfc07 100644
--- a/crates/bevy_reflect/src/enums/enum_trait.rs
+++ b/crates/bevy_reflect/src/enums/enum_trait.rs
@@ -5,8 +5,8 @@ use crate::{
     DynamicEnum, Generics, PartialReflect, Type, TypePath, VariantInfo, VariantType,
 };
 use alloc::{boxed::Box, format, string::String};
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::sync::Arc;
-use bevy_utils::HashMap;
 use core::slice::Iter;
 
 /// A trait used to power [enum-like] operations via [reflection].
diff --git a/crates/bevy_reflect/src/enums/variants.rs b/crates/bevy_reflect/src/enums/variants.rs
index e8c0d51b74082..142f95382081e 100644
--- a/crates/bevy_reflect/src/enums/variants.rs
+++ b/crates/bevy_reflect/src/enums/variants.rs
@@ -3,8 +3,8 @@ use crate::{
     NamedField, UnnamedField,
 };
 use alloc::boxed::Box;
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::sync::Arc;
-use bevy_utils::HashMap;
 use core::slice::Iter;
 use thiserror::Error;
 
diff --git a/crates/bevy_reflect/src/func/dynamic_function.rs b/crates/bevy_reflect/src/func/dynamic_function.rs
index 3ed406fc2a017..173eea742c664 100644
--- a/crates/bevy_reflect/src/func/dynamic_function.rs
+++ b/crates/bevy_reflect/src/func/dynamic_function.rs
@@ -485,7 +485,7 @@ mod tests {
     use crate::func::{FunctionError, IntoReturn, SignatureInfo};
     use crate::Type;
     use alloc::{format, string::String, vec, vec::Vec};
-    use bevy_utils::HashSet;
+    use bevy_platform_support::collections::HashSet;
     use core::ops::Add;
 
     #[test]
diff --git a/crates/bevy_reflect/src/func/dynamic_function_internal.rs b/crates/bevy_reflect/src/func/dynamic_function_internal.rs
index 4f06c5c2d7082..eb855dc5cee6d 100644
--- a/crates/bevy_reflect/src/func/dynamic_function_internal.rs
+++ b/crates/bevy_reflect/src/func/dynamic_function_internal.rs
@@ -2,7 +2,7 @@ use crate::func::args::ArgCount;
 use crate::func::signature::{ArgListSignature, ArgumentSignature};
 use crate::func::{ArgList, FunctionError, FunctionInfo, FunctionOverloadError};
 use alloc::{borrow::Cow, vec, vec::Vec};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::fmt::{Debug, Formatter};
 
 /// An internal structure for storing a function and its corresponding [function information].
diff --git a/crates/bevy_reflect/src/func/error.rs b/crates/bevy_reflect/src/func/error.rs
index 7f0fae4662aef..d4407d9698428 100644
--- a/crates/bevy_reflect/src/func/error.rs
+++ b/crates/bevy_reflect/src/func/error.rs
@@ -4,7 +4,7 @@ use crate::func::{
     Return,
 };
 use alloc::borrow::Cow;
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 use thiserror::Error;
 
 /// An error that occurs when calling a [`DynamicFunction`] or [`DynamicFunctionMut`].
diff --git a/crates/bevy_reflect/src/func/registry.rs b/crates/bevy_reflect/src/func/registry.rs
index 73455be0ed15f..527d4c150669d 100644
--- a/crates/bevy_reflect/src/func/registry.rs
+++ b/crates/bevy_reflect/src/func/registry.rs
@@ -1,6 +1,6 @@
 use alloc::borrow::Cow;
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::sync::Arc;
-use bevy_utils::HashMap;
 use core::fmt::Debug;
 use std::sync::{PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
 
diff --git a/crates/bevy_reflect/src/func/signature.rs b/crates/bevy_reflect/src/func/signature.rs
index 278f18f1f5776..c8862b35d0d90 100644
--- a/crates/bevy_reflect/src/func/signature.rs
+++ b/crates/bevy_reflect/src/func/signature.rs
@@ -15,7 +15,7 @@ use crate::func::args::ArgInfo;
 use crate::func::{ArgList, SignatureInfo};
 use crate::Type;
 use alloc::boxed::Box;
-use bevy_utils::hashbrown::Equivalent;
+use bevy_platform_support::collections::Equivalent;
 use core::borrow::Borrow;
 use core::fmt::{Debug, Formatter};
 use core::hash::{Hash, Hasher};
diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs
index 6155321540ef0..cb7ee7859978a 100644
--- a/crates/bevy_reflect/src/impls/std.rs
+++ b/crates/bevy_reflect/src/impls/std.rs
@@ -864,10 +864,10 @@ crate::func::macros::impl_function_traits!(::std::collections::HashMap<K, V, S>;
     >
 );
 
-impl_reflect_for_hashmap!(bevy_utils::hashbrown::HashMap<K, V, S>);
-impl_type_path!(::bevy_utils::hashbrown::HashMap<K, V, S>);
+impl_reflect_for_hashmap!(bevy_platform_support::collections::HashMap<K, V, S>);
+impl_type_path!(::bevy_platform_support::collections::HashMap<K, V, S>);
 #[cfg(feature = "functions")]
-crate::func::macros::impl_function_traits!(::bevy_utils::hashbrown::HashMap<K, V, S>;
+crate::func::macros::impl_function_traits!(::bevy_platform_support::collections::HashMap<K, V, S>;
     <
         K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash,
         V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
@@ -1078,8 +1078,8 @@ macro_rules! impl_reflect_for_hashset {
     };
 }
 
-impl_type_path!(::bevy_utils::NoOpHash);
-impl_type_path!(::bevy_utils::FixedHasher);
+impl_type_path!(::bevy_platform_support::hash::NoOpHash);
+impl_type_path!(::bevy_platform_support::hash::FixedHasher);
 
 #[cfg(feature = "std")]
 impl_reflect_for_hashset!(::std::collections::HashSet<V,S>);
@@ -1093,10 +1093,10 @@ crate::func::macros::impl_function_traits!(::std::collections::HashSet<V, S>;
     >
 );
 
-impl_reflect_for_hashset!(::bevy_utils::hashbrown::HashSet<V,S>);
-impl_type_path!(::bevy_utils::hashbrown::HashSet<V, S>);
+impl_reflect_for_hashset!(::bevy_platform_support::collections::HashSet<V,S>);
+impl_type_path!(::bevy_platform_support::collections::HashSet<V, S>);
 #[cfg(feature = "functions")]
-crate::func::macros::impl_function_traits!(::bevy_utils::hashbrown::HashSet<V, S>;
+crate::func::macros::impl_function_traits!(::bevy_platform_support::collections::HashSet<V, S>;
     <
         V: Hash + Eq + FromReflect + TypePath + GetTypeRegistration,
         S: TypePath + BuildHasher + Default + Send + Sync
@@ -2445,8 +2445,8 @@ mod tests {
         TypeInfo, TypeRegistry, Typed, VariantInfo, VariantType,
     };
     use alloc::{collections::BTreeMap, string::String, vec};
+    use bevy_platform_support::collections::HashMap;
     use bevy_platform_support::time::Instant;
-    use bevy_utils::HashMap;
     use core::{
         f32::consts::{PI, TAU},
         time::Duration,
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index 5604adeacd6ce..31f0f023bf3fc 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -729,7 +729,7 @@ mod tests {
         vec,
         vec::Vec,
     };
-    use bevy_utils::HashMap;
+    use bevy_platform_support::collections::HashMap;
     use core::{
         any::TypeId,
         fmt::{Debug, Formatter},
diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs
index 74743a0df1cbe..0aa1ac7f83915 100644
--- a/crates/bevy_reflect/src/map.rs
+++ b/crates/bevy_reflect/src/map.rs
@@ -1,7 +1,7 @@
 use core::fmt::{Debug, Formatter};
 
+use bevy_platform_support::collections::HashTable;
 use bevy_reflect_derive::impl_type_path;
-use bevy_utils::hashbrown::HashTable;
 
 use crate::{
     self as bevy_reflect, generics::impl_generic_info_methods, type_info::impl_type_methods,
diff --git a/crates/bevy_reflect/src/serde/de/mod.rs b/crates/bevy_reflect/src/serde/de/mod.rs
index e8b2df862ddb6..562fc6e90ce15 100644
--- a/crates/bevy_reflect/src/serde/de/mod.rs
+++ b/crates/bevy_reflect/src/serde/de/mod.rs
@@ -35,7 +35,7 @@ mod tests {
     use serde::{de::DeserializeSeed, Deserialize};
     use serde::{de::IgnoredAny, Deserializer};
 
-    use bevy_utils::{HashMap, HashSet};
+    use bevy_platform_support::collections::{HashMap, HashSet};
 
     use crate::{
         self as bevy_reflect,
diff --git a/crates/bevy_reflect/src/serde/ser/mod.rs b/crates/bevy_reflect/src/serde/ser/mod.rs
index 77f2b9d0fe5d6..be0ef027e45a3 100644
--- a/crates/bevy_reflect/src/serde/ser/mod.rs
+++ b/crates/bevy_reflect/src/serde/ser/mod.rs
@@ -31,7 +31,7 @@ mod tests {
         vec,
         vec::Vec,
     };
-    use bevy_utils::{HashMap, HashSet};
+    use bevy_platform_support::collections::{HashMap, HashSet};
     use core::{any::TypeId, f32::consts::PI, ops::RangeInclusive};
     use ron::{extensions::Extensions, ser::PrettyConfig};
     use serde::{Serialize, Serializer};
diff --git a/crates/bevy_reflect/src/serde/type_data.rs b/crates/bevy_reflect/src/serde/type_data.rs
index de88f99831fad..8df80c700f100 100644
--- a/crates/bevy_reflect/src/serde/type_data.rs
+++ b/crates/bevy_reflect/src/serde/type_data.rs
@@ -1,6 +1,6 @@
 use crate::Reflect;
 use alloc::boxed::Box;
-use bevy_utils::{hashbrown::hash_map::Iter, HashMap};
+use bevy_platform_support::collections::{hash_map::Iter, HashMap};
 
 /// Contains data relevant to the automatic reflect powered (de)serialization of a type.
 #[derive(Debug, Clone)]
diff --git a/crates/bevy_reflect/src/set.rs b/crates/bevy_reflect/src/set.rs
index 663b99715c0ee..8be3f388c9528 100644
--- a/crates/bevy_reflect/src/set.rs
+++ b/crates/bevy_reflect/src/set.rs
@@ -1,8 +1,10 @@
 use alloc::{boxed::Box, format, vec::Vec};
 use core::fmt::{Debug, Formatter};
 
+use bevy_platform_support::collections::{
+    hash_table::OccupiedEntry as HashTableOccupiedEntry, HashTable,
+};
 use bevy_reflect_derive::impl_type_path;
-use bevy_utils::hashbrown::{hash_table::OccupiedEntry as HashTableOccupiedEntry, HashTable};
 
 use crate::{
     self as bevy_reflect, generics::impl_generic_info_methods, hash_error,
@@ -375,7 +377,7 @@ impl<T: Reflect> FromIterator<T> for DynamicSet {
 
 impl IntoIterator for DynamicSet {
     type Item = Box<dyn PartialReflect>;
-    type IntoIter = bevy_utils::hashbrown::hash_table::IntoIter<Self::Item>;
+    type IntoIter = bevy_platform_support::collections::hash_table::IntoIter<Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.hash_table.into_iter()
@@ -385,7 +387,7 @@ impl IntoIterator for DynamicSet {
 impl<'a> IntoIterator for &'a DynamicSet {
     type Item = &'a dyn PartialReflect;
     type IntoIter = core::iter::Map<
-        bevy_utils::hashbrown::hash_table::Iter<'a, Box<dyn PartialReflect>>,
+        bevy_platform_support::collections::hash_table::Iter<'a, Box<dyn PartialReflect>>,
         fn(&'a Box<dyn PartialReflect>) -> Self::Item,
     >;
 
diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs
index 6fd207fc8f01e..7307b86e6ac83 100644
--- a/crates/bevy_reflect/src/struct_trait.rs
+++ b/crates/bevy_reflect/src/struct_trait.rs
@@ -7,9 +7,9 @@ use crate::{
     ReflectOwned, ReflectRef, Type, TypeInfo, TypePath,
 };
 use alloc::{borrow::Cow, boxed::Box, vec::Vec};
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::sync::Arc;
 use bevy_reflect_derive::impl_type_path;
-use bevy_utils::HashMap;
 use core::{
     fmt::{Debug, Formatter},
     slice::Iter,
diff --git a/crates/bevy_reflect/src/type_registry.rs b/crates/bevy_reflect/src/type_registry.rs
index f8b89ce5516a0..ee7e31f84a925 100644
--- a/crates/bevy_reflect/src/type_registry.rs
+++ b/crates/bevy_reflect/src/type_registry.rs
@@ -1,8 +1,11 @@
 use crate::{serde::Serializable, FromReflect, Reflect, TypeInfo, TypePath, Typed};
 use alloc::{boxed::Box, string::String};
-use bevy_platform_support::sync::{Arc, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use bevy_platform_support::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard},
+};
 use bevy_ptr::{Ptr, PtrMut};
-use bevy_utils::{HashMap, HashSet, TypeIdMap};
+use bevy_utils::TypeIdMap;
 use core::{
     any::TypeId,
     fmt::Debug,
@@ -210,9 +213,11 @@ impl TypeRegistry {
         type_id: TypeId,
         get_registration: impl FnOnce() -> TypeRegistration,
     ) -> bool {
+        use bevy_platform_support::collections::hash_map::Entry;
+
         match self.registrations.entry(type_id) {
-            bevy_utils::Entry::Occupied(_) => false,
-            bevy_utils::Entry::Vacant(entry) => {
+            Entry::Occupied(_) => false,
+            Entry::Vacant(entry) => {
                 let registration = get_registration();
                 Self::update_registration_indices(
                     &registration,
diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs
index 54ccc282bb7b2..aa340c6363aab 100644
--- a/crates/bevy_reflect/src/utility.rs
+++ b/crates/bevy_reflect/src/utility.rs
@@ -2,8 +2,11 @@
 
 use crate::TypeInfo;
 use alloc::boxed::Box;
-use bevy_platform_support::sync::{OnceLock, PoisonError, RwLock};
-use bevy_utils::{DefaultHasher, FixedHasher, NoOpHash, TypeIdMap};
+use bevy_platform_support::{
+    hash::{DefaultHasher, FixedHasher, NoOpHash},
+    sync::{OnceLock, PoisonError, RwLock},
+};
+use bevy_utils::TypeIdMap;
 use core::{
     any::{Any, TypeId},
     hash::BuildHasher,
diff --git a/crates/bevy_remote/Cargo.toml b/crates/bevy_remote/Cargo.toml
index c56be57330d58..9d2f6f25f8d0a 100644
--- a/crates/bevy_remote/Cargo.toml
+++ b/crates/bevy_remote/Cargo.toml
@@ -22,6 +22,10 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.16.0-dev", features = [
 bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev" }
 bevy_tasks = { path = "../bevy_tasks", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+  "serialize",
+] }
 
 # other
 anyhow = "1"
diff --git a/crates/bevy_remote/src/builtin_methods.rs b/crates/bevy_remote/src/builtin_methods.rs
index 5bdae8048f7e2..80dc592d9a525 100644
--- a/crates/bevy_remote/src/builtin_methods.rs
+++ b/crates/bevy_remote/src/builtin_methods.rs
@@ -14,13 +14,13 @@ use bevy_ecs::{
     system::{In, Local},
     world::{EntityRef, EntityWorldMut, FilteredEntityRef, World},
 };
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{
     prelude::ReflectDefault,
     serde::{ReflectSerializer, TypedReflectDeserializer},
     GetPath as _, NamedField, OpaqueInfo, PartialReflect, ReflectDeserialize, ReflectSerialize,
     TypeInfo, TypeRegistration, TypeRegistry, VariantInfo,
 };
-use bevy_utils::HashMap;
 use serde::{de::DeserializeSeed as _, Deserialize, Serialize};
 use serde_json::{json, Map, Value};
 
diff --git a/crates/bevy_remote/src/lib.rs b/crates/bevy_remote/src/lib.rs
index 78ef0bcb3381d..75ba79d58e8da 100644
--- a/crates/bevy_remote/src/lib.rs
+++ b/crates/bevy_remote/src/lib.rs
@@ -328,7 +328,8 @@ use bevy_ecs::{
     system::{Commands, In, IntoSystem, ResMut, System, SystemId},
     world::World,
 };
-use bevy_utils::{prelude::default, HashMap};
+use bevy_platform_support::collections::HashMap;
+use bevy_utils::prelude::default;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use std::sync::RwLock;
diff --git a/crates/bevy_render/Cargo.toml b/crates/bevy_render/Cargo.toml
index c2576c44e7c17..4962125622270 100644
--- a/crates/bevy_render/Cargo.toml
+++ b/crates/bevy_render/Cargo.toml
@@ -58,6 +58,7 @@ bevy_image = { path = "../bevy_image", version = "0.16.0-dev" }
 bevy_mesh = { path = "../bevy_mesh", version = "0.16.0-dev" }
 bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
   "std",
+  "serialize",
 ] }
 
 # rendering
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index c5db6e3ad6e5d..dc977ceb8404f 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -34,10 +34,10 @@ use bevy_ecs::{
 };
 use bevy_image::Image;
 use bevy_math::{ops, vec2, Dir3, FloatOrd, Mat4, Ray3d, Rect, URect, UVec2, UVec4, Vec2, Vec3};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_reflect::prelude::*;
 use bevy_render_macros::ExtractComponent;
 use bevy_transform::components::{GlobalTransform, Transform};
-use bevy_utils::{HashMap, HashSet};
 use bevy_window::{
     NormalizedWindowRef, PrimaryWindow, Window, WindowCreated, WindowRef, WindowResized,
     WindowScaleFactorChanged,
diff --git a/crates/bevy_render/src/camera/camera_driver_node.rs b/crates/bevy_render/src/camera/camera_driver_node.rs
index b5698a0f821c4..7fa221235fc9d 100644
--- a/crates/bevy_render/src/camera/camera_driver_node.rs
+++ b/crates/bevy_render/src/camera/camera_driver_node.rs
@@ -5,7 +5,7 @@ use crate::{
     view::ExtractedWindows,
 };
 use bevy_ecs::{entity::EntityBorrow, prelude::QueryState, world::World};
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 use wgpu::{LoadOp, Operations, RenderPassColorAttachment, RenderPassDescriptor, StoreOp};
 
 pub struct CameraDriverNode {
diff --git a/crates/bevy_render/src/camera/manual_texture_view.rs b/crates/bevy_render/src/camera/manual_texture_view.rs
index 34a37807f82a3..a9c302eaf4455 100644
--- a/crates/bevy_render/src/camera/manual_texture_view.rs
+++ b/crates/bevy_render/src/camera/manual_texture_view.rs
@@ -2,8 +2,8 @@ use crate::{extract_resource::ExtractResource, render_resource::TextureView};
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent, resource::Resource};
 use bevy_image::BevyDefault as _;
 use bevy_math::UVec2;
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::prelude::*;
-use bevy_utils::HashMap;
 use wgpu::TextureFormat;
 
 /// A unique id that corresponds to a specific [`ManualTextureView`] in the [`ManualTextureViews`] collection.
diff --git a/crates/bevy_render/src/diagnostic/internal.rs b/crates/bevy_render/src/diagnostic/internal.rs
index b7c045b7c5994..8445ebe54d250 100644
--- a/crates/bevy_render/src/diagnostic/internal.rs
+++ b/crates/bevy_render/src/diagnostic/internal.rs
@@ -299,7 +299,7 @@ impl FrameData {
             .open_spans
             .iter()
             .filter(|v| v.thread_id == thread_id)
-            .last();
+            .next_back();
 
         let path_range = match &parent {
             Some(parent) if parent.path_range.end == self.path_components.len() => {
@@ -336,7 +336,7 @@ impl FrameData {
         let (index, _) = iter
             .enumerate()
             .filter(|(_, v)| v.thread_id == thread_id)
-            .last()
+            .next_back()
             .unwrap();
 
         let span = self.open_spans.swap_remove(index);
diff --git a/crates/bevy_render/src/gpu_readback.rs b/crates/bevy_render/src/gpu_readback.rs
index 8f54ca6b56e98..b7da4800acb5c 100644
--- a/crates/bevy_render/src/gpu_readback.rs
+++ b/crates/bevy_render/src/gpu_readback.rs
@@ -21,9 +21,9 @@ use bevy_ecs::{
     system::{Query, Res},
 };
 use bevy_image::{Image, TextureFormatPixelInfo};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::Reflect;
 use bevy_render_macros::ExtractComponent;
-use bevy_utils::HashMap;
 use encase::internal::ReadFrom;
 use encase::private::Reader;
 use encase::ShaderType;
diff --git a/crates/bevy_render/src/mesh/allocator.rs b/crates/bevy_render/src/mesh/allocator.rs
index 781e6e195b884..b703792b65cf1 100644
--- a/crates/bevy_render/src/mesh/allocator.rs
+++ b/crates/bevy_render/src/mesh/allocator.rs
@@ -16,7 +16,8 @@ use bevy_ecs::{
     system::{Res, ResMut},
     world::{FromWorld, World},
 };
-use bevy_utils::{default, HashMap, HashSet};
+use bevy_platform_support::collections::{HashMap, HashSet};
+use bevy_utils::default;
 use offset_allocator::{Allocation, Allocator};
 use tracing::error;
 use wgpu::{
diff --git a/crates/bevy_render/src/mesh/components.rs b/crates/bevy_render/src/mesh/components.rs
index 2b887c65d32c5..9bfa05968d733 100644
--- a/crates/bevy_render/src/mesh/components.rs
+++ b/crates/bevy_render/src/mesh/components.rs
@@ -8,9 +8,9 @@ use bevy_ecs::{
     change_detection::DetectChangesMut, component::Component, event::EventReader, prelude::require,
     reflect::ReflectComponent, system::Query,
 };
+use bevy_platform_support::{collections::HashSet, hash::FixedHasher};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_transform::components::Transform;
-use bevy_utils::{FixedHasher, HashSet};
 use derive_more::derive::From;
 
 /// A component for 2D meshes. Requires a [`MeshMaterial2d`] to be rendered, commonly using a [`ColorMaterial`].
diff --git a/crates/bevy_render/src/render_asset.rs b/crates/bevy_render/src/render_asset.rs
index bd115e4e57d32..043b3554a148a 100644
--- a/crates/bevy_render/src/render_asset.rs
+++ b/crates/bevy_render/src/render_asset.rs
@@ -10,8 +10,8 @@ use bevy_ecs::{
     system::{StaticSystemParam, SystemParam, SystemParamItem, SystemState},
     world::{FromWorld, Mut},
 };
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_render_macros::ExtractResource;
-use bevy_utils::{HashMap, HashSet};
 use core::marker::PhantomData;
 use thiserror::Error;
 use tracing::{debug, error};
diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs
index 7793ca0e9ac71..78e6cbf324724 100644
--- a/crates/bevy_render/src/render_graph/graph.rs
+++ b/crates/bevy_render/src/render_graph/graph.rs
@@ -6,7 +6,7 @@ use crate::{
     renderer::RenderContext,
 };
 use bevy_ecs::{define_label, intern::Interned, prelude::World, resource::Resource};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use core::fmt::Debug;
 
 use super::{EdgeExistence, InternedRenderLabel, IntoRenderNodeArray};
@@ -680,7 +680,7 @@ mod tests {
         renderer::RenderContext,
     };
     use bevy_ecs::world::{FromWorld, World};
-    use bevy_utils::HashSet;
+    use bevy_platform_support::collections::HashSet;
 
     #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
     enum TestLabel {
diff --git a/crates/bevy_render/src/render_phase/mod.rs b/crates/bevy_render/src/render_phase/mod.rs
index 2b8d0c9e8a362..61b47b97eed94 100644
--- a/crates/bevy_render/src/render_phase/mod.rs
+++ b/crates/bevy_render/src/render_phase/mod.rs
@@ -30,7 +30,8 @@ mod rangefinder;
 
 use bevy_app::{App, Plugin};
 use bevy_derive::{Deref, DerefMut};
-use bevy_utils::{default, hashbrown::hash_map::Entry, HashMap};
+use bevy_platform_support::collections::{hash_map::Entry, HashMap};
+use bevy_utils::default;
 pub use draw::*;
 pub use draw_state::*;
 use encase::{internal::WriteInto, ShaderSize};
diff --git a/crates/bevy_render/src/render_resource/pipeline_cache.rs b/crates/bevy_render/src/render_resource/pipeline_cache.rs
index 9afae4f70029b..207c401024837 100644
--- a/crates/bevy_render/src/render_resource/pipeline_cache.rs
+++ b/crates/bevy_render/src/render_resource/pipeline_cache.rs
@@ -11,8 +11,9 @@ use bevy_ecs::{
     resource::Resource,
     system::{Res, ResMut},
 };
+use bevy_platform_support::collections::{hash_map::EntryRef, HashMap, HashSet};
 use bevy_tasks::Task;
-use bevy_utils::{default, hashbrown::hash_map::EntryRef, HashMap, HashSet};
+use bevy_utils::default;
 use core::{future::Future, hash::Hash, mem, ops::Deref};
 use naga::valid::Capabilities;
 use std::sync::{Mutex, PoisonError};
diff --git a/crates/bevy_render/src/render_resource/pipeline_specializer.rs b/crates/bevy_render/src/render_resource/pipeline_specializer.rs
index d2656a5e62318..67f737a6a4193 100644
--- a/crates/bevy_render/src/render_resource/pipeline_specializer.rs
+++ b/crates/bevy_render/src/render_resource/pipeline_specializer.rs
@@ -6,11 +6,14 @@ use crate::{
     },
 };
 use bevy_ecs::resource::Resource;
-use bevy_utils::{
-    default,
-    hashbrown::hash_map::{RawEntryMut, VacantEntry},
-    Entry, FixedHasher, HashMap,
+use bevy_platform_support::{
+    collections::{
+        hash_map::{Entry, RawEntryMut, VacantEntry},
+        HashMap,
+    },
+    hash::FixedHasher,
 };
+use bevy_utils::default;
 use core::{fmt::Debug, hash::Hash};
 use thiserror::Error;
 use tracing::error;
diff --git a/crates/bevy_render/src/renderer/graph_runner.rs b/crates/bevy_render/src/renderer/graph_runner.rs
index 6433a39da1c1d..cc03374ea4316 100644
--- a/crates/bevy_render/src/renderer/graph_runner.rs
+++ b/crates/bevy_render/src/renderer/graph_runner.rs
@@ -1,5 +1,5 @@
 use bevy_ecs::{prelude::Entity, world::World};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 #[cfg(feature = "trace")]
 use tracing::info_span;
 
diff --git a/crates/bevy_render/src/sync_world.rs b/crates/bevy_render/src/sync_world.rs
index 31957a1154d94..60f57ba3a63c1 100644
--- a/crates/bevy_render/src/sync_world.rs
+++ b/crates/bevy_render/src/sync_world.rs
@@ -11,8 +11,8 @@ use bevy_ecs::{
     system::{Local, Query, ResMut, SystemState},
     world::{Mut, OnAdd, OnRemove, World},
 };
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_reflect::Reflect;
-use bevy_utils::hashbrown;
 
 /// A plugin that synchronizes entities with [`SyncToRenderWorld`] between the main world and the render world.
 ///
@@ -177,11 +177,11 @@ impl EntityBorrow for MainEntity {
 // SAFETY: RenderEntity is a newtype around Entity that derives its comparison traits.
 unsafe impl TrustedEntityBorrow for MainEntity {}
 
-/// A [`HashMap`](hashbrown::HashMap) pre-configured to use [`EntityHash`] hashing with a [`MainEntity`].
-pub type MainEntityHashMap<V> = hashbrown::HashMap<MainEntity, V, EntityHash>;
+/// A [`HashMap`] pre-configured to use [`EntityHash`] hashing with a [`MainEntity`].
+pub type MainEntityHashMap<V> = HashMap<MainEntity, V, EntityHash>;
 
-/// A [`HashSet`](hashbrown::HashSet) pre-configured to use [`EntityHash`] hashing with a [`MainEntity`]..
-pub type MainEntityHashSet = hashbrown::HashSet<MainEntity, EntityHash>;
+/// A [`HashSet`] pre-configured to use [`EntityHash`] hashing with a [`MainEntity`]..
+pub type MainEntityHashSet = HashSet<MainEntity, EntityHash>;
 
 /// Marker component that indicates that its entity needs to be despawned at the end of the frame.
 #[derive(Component, Copy, Clone, Debug, Default, Reflect)]
diff --git a/crates/bevy_render/src/texture/fallback_image.rs b/crates/bevy_render/src/texture/fallback_image.rs
index 49e8ea21e60f0..38d94ff5d77e1 100644
--- a/crates/bevy_render/src/texture/fallback_image.rs
+++ b/crates/bevy_render/src/texture/fallback_image.rs
@@ -11,7 +11,7 @@ use bevy_ecs::{
     system::SystemParam,
 };
 use bevy_image::{BevyDefault, Image, ImageSampler, TextureFormatPixelInfo};
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 
 /// A [`RenderApp`](crate::RenderApp) resource that contains the default "fallback image",
 /// which can be used in situations where an image was not explicitly defined. The most common
diff --git a/crates/bevy_render/src/texture/texture_cache.rs b/crates/bevy_render/src/texture/texture_cache.rs
index fd0fabbd566a8..8a3fb010109d5 100644
--- a/crates/bevy_render/src/texture/texture_cache.rs
+++ b/crates/bevy_render/src/texture/texture_cache.rs
@@ -3,7 +3,7 @@ use crate::{
     renderer::RenderDevice,
 };
 use bevy_ecs::{prelude::ResMut, resource::Resource};
-use bevy_utils::{Entry, HashMap};
+use bevy_platform_support::collections::{hash_map::Entry, HashMap};
 use wgpu::{TextureDescriptor, TextureViewDescriptor};
 
 /// The internal representation of a [`CachedTexture`] used to track whether it was recently used
diff --git a/crates/bevy_render/src/view/mod.rs b/crates/bevy_render/src/view/mod.rs
index b5ad7a541e297..57d7562c45566 100644
--- a/crates/bevy_render/src/view/mod.rs
+++ b/crates/bevy_render/src/view/mod.rs
@@ -31,10 +31,10 @@ use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::prelude::*;
 use bevy_image::BevyDefault as _;
 use bevy_math::{mat3, vec2, vec3, Mat3, Mat4, UVec4, Vec2, Vec3, Vec4, Vec4Swizzles};
+use bevy_platform_support::collections::{hash_map::Entry, HashMap};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render_macros::ExtractComponent;
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::{hashbrown::hash_map::Entry, HashMap};
 use core::{
     ops::Range,
     sync::atomic::{AtomicUsize, Ordering},
diff --git a/crates/bevy_render/src/view/visibility/range.rs b/crates/bevy_render/src/view/visibility/range.rs
index 5984e3ec88dcb..fe0af5b08afb1 100644
--- a/crates/bevy_render/src/view/visibility/range.rs
+++ b/crates/bevy_render/src/view/visibility/range.rs
@@ -18,9 +18,10 @@ use bevy_ecs::{
     system::{Query, Res, ResMut},
 };
 use bevy_math::{vec4, FloatOrd, Vec4};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::Reflect;
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::{prelude::default, HashMap};
+use bevy_utils::prelude::default;
 use nonmax::NonMaxU16;
 use wgpu::{BufferBindingType, BufferUsages};
 
diff --git a/crates/bevy_render/src/view/window/mod.rs b/crates/bevy_render/src/view/window/mod.rs
index 87d5654e7b1a6..14a984ff3921e 100644
--- a/crates/bevy_render/src/view/window/mod.rs
+++ b/crates/bevy_render/src/view/window/mod.rs
@@ -5,7 +5,8 @@ use crate::{
 };
 use bevy_app::{App, Plugin};
 use bevy_ecs::{entity::hash_map::EntityHashMap, prelude::*};
-use bevy_utils::{default, HashSet};
+use bevy_platform_support::collections::HashSet;
+use bevy_utils::default;
 use bevy_window::{
     CompositeAlphaMode, PresentMode, PrimaryWindow, RawHandleWrapper, Window, WindowClosing,
 };
diff --git a/crates/bevy_render/src/view/window/screenshot.rs b/crates/bevy_render/src/view/window/screenshot.rs
index 5e6acf8fbc104..05994d9cf57b0 100644
--- a/crates/bevy_render/src/view/window/screenshot.rs
+++ b/crates/bevy_render/src/view/window/screenshot.rs
@@ -23,9 +23,10 @@ use bevy_ecs::{
     entity::hash_map::EntityHashMap, event::event_update_system, prelude::*, system::SystemState,
 };
 use bevy_image::{Image, TextureFormatPixelInfo};
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::Reflect;
 use bevy_tasks::AsyncComputeTaskPool;
-use bevy_utils::{default, HashSet};
+use bevy_utils::default;
 use bevy_window::{PrimaryWindow, WindowRef};
 use core::ops::Deref;
 use std::{
diff --git a/crates/bevy_scene/Cargo.toml b/crates/bevy_scene/Cargo.toml
index 60004b2662c89..1f3e5be2de3af 100644
--- a/crates/bevy_scene/Cargo.toml
+++ b/crates/bevy_scene/Cargo.toml
@@ -10,7 +10,12 @@ keywords = ["bevy"]
 
 [features]
 default = ["serialize"]
-serialize = ["dep:serde", "uuid/serde", "bevy_ecs/serialize"]
+serialize = [
+  "dep:serde",
+  "uuid/serde",
+  "bevy_ecs/serialize",
+  "bevy_platform_support/serialize",
+]
 
 [dependencies]
 # bevy
@@ -24,6 +29,9 @@ bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev", features = [
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_render = { path = "../bevy_render", version = "0.16.0-dev", optional = true }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # other
 serde = { version = "1.0", features = ["derive"], optional = true }
diff --git a/crates/bevy_scene/src/scene_filter.rs b/crates/bevy_scene/src/scene_filter.rs
index 062b218165c0c..732a1e5f15490 100644
--- a/crates/bevy_scene/src/scene_filter.rs
+++ b/crates/bevy_scene/src/scene_filter.rs
@@ -1,4 +1,4 @@
-use bevy_utils::{hashbrown::hash_set::IntoIter, HashSet};
+use bevy_platform_support::collections::{hash_set::IntoIter, HashSet};
 use core::any::{Any, TypeId};
 
 /// A filter used to control which types can be added to a [`DynamicScene`].
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
index eacd6b9c6f536..3d4014f123534 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -8,8 +8,8 @@ use bevy_ecs::{
     resource::Resource,
     world::{Mut, World},
 };
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_reflect::Reflect;
-use bevy_utils::{HashMap, HashSet};
 use thiserror::Error;
 use uuid::Uuid;
 
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
index d1fc5a89d3cf2..ede9076ea2325 100644
--- a/crates/bevy_scene/src/serde.rs
+++ b/crates/bevy_scene/src/serde.rs
@@ -2,6 +2,7 @@
 
 use crate::{DynamicEntity, DynamicScene};
 use bevy_ecs::entity::Entity;
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::{
     serde::{
         ReflectDeserializer, TypeRegistrationDeserializer, TypedReflectDeserializer,
@@ -9,7 +10,6 @@ use bevy_reflect::{
     },
     PartialReflect, ReflectFromReflect, TypeRegistry,
 };
-use bevy_utils::HashSet;
 use core::fmt::Formatter;
 use serde::{
     de::{DeserializeSeed, Error, MapAccess, SeqAccess, Visitor},
diff --git a/crates/bevy_sprite/Cargo.toml b/crates/bevy_sprite/Cargo.toml
index fc4316317013d..dc9c10154fe88 100644
--- a/crates/bevy_sprite/Cargo.toml
+++ b/crates/bevy_sprite/Cargo.toml
@@ -31,6 +31,9 @@ bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.16.0-dev", optional = true }
 bevy_derive = { path = "../bevy_derive", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # other
 bytemuck = { version = "1", features = ["derive", "must_cast"] }
diff --git a/crates/bevy_sprite/src/render/mod.rs b/crates/bevy_sprite/src/render/mod.rs
index 585229052e04f..afda36fa4d81c 100644
--- a/crates/bevy_sprite/src/render/mod.rs
+++ b/crates/bevy_sprite/src/render/mod.rs
@@ -17,6 +17,7 @@ use bevy_ecs::{
 };
 use bevy_image::{BevyDefault, Image, ImageSampler, TextureAtlasLayout, TextureFormatPixelInfo};
 use bevy_math::{Affine3A, FloatOrd, Quat, Rect, Vec2, Vec4};
+use bevy_platform_support::collections::HashMap;
 use bevy_render::sync_world::MainEntity;
 use bevy_render::view::RenderVisibleEntities;
 use bevy_render::{
@@ -39,7 +40,6 @@ use bevy_render::{
     Extract,
 };
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::HashMap;
 use bytemuck::{Pod, Zeroable};
 use fixedbitset::FixedBitSet;
 
diff --git a/crates/bevy_sprite/src/texture_slice/computed_slices.rs b/crates/bevy_sprite/src/texture_slice/computed_slices.rs
index 490071a6005ed..6905bf1697d10 100644
--- a/crates/bevy_sprite/src/texture_slice/computed_slices.rs
+++ b/crates/bevy_sprite/src/texture_slice/computed_slices.rs
@@ -5,8 +5,8 @@ use bevy_asset::{AssetEvent, Assets};
 use bevy_ecs::prelude::*;
 use bevy_image::Image;
 use bevy_math::{Rect, Vec2};
+use bevy_platform_support::collections::HashSet;
 use bevy_transform::prelude::*;
-use bevy_utils::HashSet;
 
 /// Component storing texture slices for tiled or sliced sprite entities
 ///
diff --git a/crates/bevy_state/Cargo.toml b/crates/bevy_state/Cargo.toml
index 1b23e5c91380c..e6ef17c192640 100644
--- a/crates/bevy_state/Cargo.toml
+++ b/crates/bevy_state/Cargo.toml
@@ -28,7 +28,13 @@ bevy_app = ["dep:bevy_app"]
 ## Allows access to the `std` crate. Enabling this feature will prevent compilation
 ## on `no_std` targets, but provides access to certain additional features on
 ## supported platforms.
-std = ["bevy_ecs/std", "bevy_utils/std", "bevy_reflect?/std", "bevy_app?/std"]
+std = [
+  "bevy_ecs/std",
+  "bevy_utils/std",
+  "bevy_reflect?/std",
+  "bevy_app?/std",
+  "bevy_platform_support/std",
+]
 
 ## `critical-section` provides the building blocks for synchronization primitives
 ## on all platforms, including `no_std`.
@@ -37,6 +43,7 @@ critical-section = [
   "bevy_utils/critical-section",
   "bevy_app?/critical-section",
   "bevy_reflect?/critical-section",
+  "bevy_platform_support/critical-section",
 ]
 
 ## `portable-atomic` provides additional platform support for atomic types and
@@ -46,6 +53,7 @@ portable-atomic = [
   "bevy_utils/portable-atomic",
   "bevy_app?/portable-atomic",
   "bevy_reflect?/portable-atomic",
+  "bevy_platform_support/portable-atomic",
 ]
 
 [dependencies]
@@ -55,6 +63,7 @@ bevy_state_macros = { path = "macros", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev", default-features = false }
 bevy_reflect = { path = "../bevy_reflect", version = "0.16.0-dev", default-features = false, optional = true }
 bevy_app = { path = "../bevy_app", version = "0.16.0-dev", default-features = false, optional = true }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false }
 variadics_please = "1.1"
 
 # other
diff --git a/crates/bevy_state/src/state_scoped_events.rs b/crates/bevy_state/src/state_scoped_events.rs
index 8ee9fea0c889c..846db41b3f8e0 100644
--- a/crates/bevy_state/src/state_scoped_events.rs
+++ b/crates/bevy_state/src/state_scoped_events.rs
@@ -8,7 +8,7 @@ use bevy_ecs::{
     system::Commands,
     world::World,
 };
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 
 use crate::state::{FreelyMutableState, OnExit, StateTransitionEvent};
 
diff --git a/crates/bevy_text/Cargo.toml b/crates/bevy_text/Cargo.toml
index 3ad3ef955737a..a5e8dea07db51 100644
--- a/crates/bevy_text/Cargo.toml
+++ b/crates/bevy_text/Cargo.toml
@@ -29,6 +29,10 @@ bevy_sprite = { path = "../bevy_sprite", version = "0.16.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+  "serialize",
+] }
 
 # other
 cosmic-text = { version = "0.12", features = ["shape-run-cache"] }
diff --git a/crates/bevy_text/src/font_atlas.rs b/crates/bevy_text/src/font_atlas.rs
index f053bb6ab13fa..793cec0d2fa4a 100644
--- a/crates/bevy_text/src/font_atlas.rs
+++ b/crates/bevy_text/src/font_atlas.rs
@@ -1,11 +1,11 @@
 use bevy_asset::{Assets, Handle};
 use bevy_image::{prelude::*, ImageSampler};
 use bevy_math::{IVec2, UVec2};
+use bevy_platform_support::collections::HashMap;
 use bevy_render::{
     render_asset::RenderAssetUsages,
     render_resource::{Extent3d, TextureDimension, TextureFormat},
 };
-use bevy_utils::HashMap;
 
 use crate::{FontSmoothing, GlyphAtlasLocation, TextError};
 
diff --git a/crates/bevy_text/src/font_atlas_set.rs b/crates/bevy_text/src/font_atlas_set.rs
index 5172f038bd3df..92b71ef535842 100644
--- a/crates/bevy_text/src/font_atlas_set.rs
+++ b/crates/bevy_text/src/font_atlas_set.rs
@@ -2,12 +2,12 @@ use bevy_asset::{Asset, AssetEvent, AssetId, Assets};
 use bevy_ecs::{event::EventReader, resource::Resource, system::ResMut};
 use bevy_image::prelude::*;
 use bevy_math::{IVec2, UVec2};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::TypePath;
 use bevy_render::{
     render_asset::RenderAssetUsages,
     render_resource::{Extent3d, TextureDimension, TextureFormat},
 };
-use bevy_utils::HashMap;
 
 use crate::{error::TextError, Font, FontAtlas, FontSmoothing, GlyphAtlasInfo};
 
diff --git a/crates/bevy_text/src/pipeline.rs b/crates/bevy_text/src/pipeline.rs
index ef1f0e42ba570..e7774569cfb25 100644
--- a/crates/bevy_text/src/pipeline.rs
+++ b/crates/bevy_text/src/pipeline.rs
@@ -10,8 +10,8 @@ use bevy_ecs::{
 use bevy_image::prelude::*;
 use bevy_log::{once, warn};
 use bevy_math::{UVec2, Vec2};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
-use bevy_utils::HashMap;
 
 use cosmic_text::{Attrs, Buffer, Family, Metrics, Shaping, Wrap};
 
diff --git a/crates/bevy_time/Cargo.toml b/crates/bevy_time/Cargo.toml
index b0db99b6588fa..f209e01740db3 100644
--- a/crates/bevy_time/Cargo.toml
+++ b/crates/bevy_time/Cargo.toml
@@ -21,7 +21,11 @@ bevy_reflect = [
 ]
 
 ## Adds serialization support through `serde`.
-serialize = ["dep:serde", "bevy_ecs/serialize"]
+serialize = [
+  "dep:serde",
+  "bevy_ecs/serialize",
+  "bevy_platform_support/serialize",
+]
 
 # Platform Compatibility
 
diff --git a/crates/bevy_ui/Cargo.toml b/crates/bevy_ui/Cargo.toml
index 9ab0dadfdac2a..c287ede55b5a3 100644
--- a/crates/bevy_ui/Cargo.toml
+++ b/crates/bevy_ui/Cargo.toml
@@ -30,6 +30,9 @@ bevy_picking = { path = "../bevy_picking", version = "0.16.0-dev", optional = tr
 bevy_transform = { path = "../bevy_transform", version = "0.16.0-dev" }
 bevy_window = { path = "../bevy_window", version = "0.16.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.16.0-dev" }
+bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false, features = [
+  "std",
+] }
 
 # other
 taffy = { version = "0.7" }
@@ -44,7 +47,12 @@ tracing = { version = "0.1", default-features = false, features = ["std"] }
 
 [features]
 default = []
-serialize = ["serde", "smallvec/serde", "bevy_math/serialize"]
+serialize = [
+  "serde",
+  "smallvec/serde",
+  "bevy_math/serialize",
+  "bevy_platform_support/serialize",
+]
 bevy_ui_picking_backend = ["bevy_picking"]
 bevy_ui_debug = []
 
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index e207182807de3..126f0d48ff35f 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -11,10 +11,10 @@ use bevy_ecs::{
 };
 use bevy_input::{mouse::MouseButton, touch::Touches, ButtonInput};
 use bevy_math::{Rect, Vec2};
+use bevy_platform_support::collections::HashMap;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{camera::NormalizedRenderTarget, prelude::Camera, view::InheritedVisibility};
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::HashMap;
 use bevy_window::{PrimaryWindow, Window};
 
 use smallvec::SmallVec;
diff --git a/crates/bevy_ui/src/layout/debug.rs b/crates/bevy_ui/src/layout/debug.rs
index 5cf5b2a3284cd..5af75d3ffdc32 100644
--- a/crates/bevy_ui/src/layout/debug.rs
+++ b/crates/bevy_ui/src/layout/debug.rs
@@ -3,7 +3,7 @@ use core::fmt::Write;
 use taffy::{NodeId, TraversePartialTree};
 
 use bevy_ecs::prelude::Entity;
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 
 use crate::layout::ui_surface::UiSurface;
 
diff --git a/crates/bevy_ui/src/layout/mod.rs b/crates/bevy_ui/src/layout/mod.rs
index 10308896877b1..4eea61a48a053 100644
--- a/crates/bevy_ui/src/layout/mod.rs
+++ b/crates/bevy_ui/src/layout/mod.rs
@@ -471,12 +471,13 @@ mod tests {
     use bevy_ecs::{prelude::*, system::RunSystemOnce};
     use bevy_image::Image;
     use bevy_math::{Rect, UVec2, Vec2};
+    use bevy_platform_support::collections::HashMap;
     use bevy_render::{camera::ManualTextureViews, prelude::Camera};
     use bevy_transform::{
         prelude::GlobalTransform,
         systems::{propagate_transforms, sync_simple_transforms},
     };
-    use bevy_utils::{prelude::default, HashMap};
+    use bevy_utils::prelude::default;
     use bevy_window::{
         PrimaryWindow, Window, WindowCreated, WindowResized, WindowResolution,
         WindowScaleFactorChanged,
diff --git a/crates/bevy_ui/src/picking_backend.rs b/crates/bevy_ui/src/picking_backend.rs
index 2ca0c110e4256..7f2b973b4e4c1 100644
--- a/crates/bevy_ui/src/picking_backend.rs
+++ b/crates/bevy_ui/src/picking_backend.rs
@@ -25,9 +25,9 @@ use crate::{focus::pick_rounded_rect, prelude::*, UiStack};
 use bevy_app::prelude::*;
 use bevy_ecs::{prelude::*, query::QueryData};
 use bevy_math::{Rect, Vec2};
+use bevy_platform_support::collections::HashMap;
 use bevy_render::prelude::*;
 use bevy_transform::prelude::*;
-use bevy_utils::HashMap;
 use bevy_window::PrimaryWindow;
 
 use bevy_picking::backend::prelude::*;
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index bca1f2397df43..ec5b27d1910a0 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -50,9 +50,9 @@ use bevy_sprite::{BorderRect, SpriteAssetEvents};
 pub use debug_overlay::UiDebugOptions;
 
 use crate::{Display, Node};
+use bevy_platform_support::collections::{HashMap, HashSet};
 use bevy_text::{ComputedTextBlock, PositionedGlyph, TextColor, TextLayoutInfo};
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::{HashMap, HashSet};
 use box_shadow::BoxShadowPlugin;
 use bytemuck::{Pod, Zeroable};
 use core::ops::Range;
diff --git a/crates/bevy_ui/src/render/ui_texture_slice_pipeline.rs b/crates/bevy_ui/src/render/ui_texture_slice_pipeline.rs
index ad4af7642b58d..2cb70ed51c460 100644
--- a/crates/bevy_ui/src/render/ui_texture_slice_pipeline.rs
+++ b/crates/bevy_ui/src/render/ui_texture_slice_pipeline.rs
@@ -13,6 +13,7 @@ use bevy_ecs::{
 };
 use bevy_image::prelude::*;
 use bevy_math::{FloatOrd, Mat4, Rect, Vec2, Vec4Swizzles};
+use bevy_platform_support::collections::HashMap;
 use bevy_render::sync_world::MainEntity;
 use bevy_render::{
     render_asset::RenderAssets,
@@ -26,7 +27,6 @@ use bevy_render::{
 };
 use bevy_sprite::{SliceScaleMode, SpriteAssetEvents, SpriteImageMode, TextureSlicer};
 use bevy_transform::prelude::GlobalTransform;
-use bevy_utils::HashMap;
 use binding_types::{sampler, texture_2d};
 use bytemuck::{Pod, Zeroable};
 use widget::ImageNode;
diff --git a/crates/bevy_ui/src/stack.rs b/crates/bevy_ui/src/stack.rs
index fdfc2fd9c6c7f..c8dfde318d5d2 100644
--- a/crates/bevy_ui/src/stack.rs
+++ b/crates/bevy_ui/src/stack.rs
@@ -1,7 +1,7 @@
 //! This module contains the systems that update the stored UI nodes stack
 
 use bevy_ecs::prelude::*;
-use bevy_utils::HashSet;
+use bevy_platform_support::collections::HashSet;
 
 use crate::{
     experimental::{UiChildren, UiRootNodes},
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 9602a0a9eefaa..390ddc6913b54 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -12,9 +12,9 @@ use bevy_ecs::{
     system::{Commands, Query},
 };
 use bevy_math::Rect;
+use bevy_platform_support::collections::HashSet;
 use bevy_sprite::BorderRect;
 use bevy_transform::components::GlobalTransform;
-use bevy_utils::HashSet;
 
 /// Updates clipping for all nodes
 pub fn update_clipping_system(
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 1f0dcc654157b..16b4c60c3e61a 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -16,6 +16,7 @@ use bevy_ecs::{
 };
 use bevy_image::prelude::*;
 use bevy_math::Vec2;
+use bevy_platform_support::collections::hash_map::Entry;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::camera::Camera;
 use bevy_text::{
@@ -23,7 +24,6 @@ use bevy_text::{
     TextBounds, TextColor, TextError, TextFont, TextLayout, TextLayoutInfo, TextMeasureInfo,
     TextPipeline, TextReader, TextRoot, TextSpanAccess, TextWriter, YAxisOrientation,
 };
-use bevy_utils::Entry;
 use taffy::style::AvailableSpace;
 use tracing::error;
 
diff --git a/crates/bevy_utils/Cargo.toml b/crates/bevy_utils/Cargo.toml
index a031693e3b12e..1b8682f2087c3 100644
--- a/crates/bevy_utils/Cargo.toml
+++ b/crates/bevy_utils/Cargo.toml
@@ -14,17 +14,17 @@ default = ["std", "serde"]
 # Functionality
 
 ## Adds serialization support through `serde`.
-serde = ["hashbrown/serde"]
+serde = ["bevy_platform_support/serialize"]
 
 # Platform Compatibility
 
 ## Allows access to the `std` crate. Enabling this feature will prevent compilation
 ## on `no_std` targets, but provides access to certain additional features on
 ## supported platforms.
-std = ["alloc", "bevy_platform_support/std", "foldhash/std", "dep:thread_local"]
+std = ["alloc", "bevy_platform_support/std", "dep:thread_local"]
 
 ## Allows access to the `alloc` crate.
-alloc = ["bevy_platform_support/alloc", "hashbrown"]
+alloc = ["bevy_platform_support/alloc"]
 
 ## `critical-section` provides the building blocks for synchronization primitives
 ## on all platforms, including `no_std`.
@@ -37,11 +37,6 @@ portable-atomic = ["bevy_platform_support/portable-atomic"]
 [dependencies]
 bevy_platform_support = { path = "../bevy_platform_support", version = "0.16.0-dev", default-features = false }
 
-foldhash = { version = "0.1.3", default-features = false }
-hashbrown = { version = "0.15.1", features = [
-  "equivalent",
-  "raw-entry",
-], optional = true, default-features = false }
 thread_local = { version = "1.0", optional = true }
 
 [dev-dependencies]
diff --git a/crates/bevy_utils/src/lib.rs b/crates/bevy_utils/src/lib.rs
index d4c01e0573b1a..4b7d91a40eee2 100644
--- a/crates/bevy_utils/src/lib.rs
+++ b/crates/bevy_utils/src/lib.rs
@@ -33,215 +33,26 @@ mod parallel_queue;
 #[doc(hidden)]
 pub use once::OnceFlag;
 
-/// For when you want a deterministic hasher.
-///
-/// Seed was randomly generated with a fair dice roll. Guaranteed to be random:
-/// <https://github.com/bevyengine/bevy/pull/1268/files#r560918426>
-const FIXED_HASHER: FixedState =
-    FixedState::with_seed(0b1001010111101110000001001100010000000011001001101011001001111000);
-
-/// Deterministic hasher based upon a random but fixed state.
-#[derive(Copy, Clone, Default, Debug)]
-pub struct FixedHasher;
-impl BuildHasher for FixedHasher {
-    type Hasher = DefaultHasher;
-
-    #[inline]
-    fn build_hasher(&self) -> Self::Hasher {
-        FIXED_HASHER.build_hasher()
-    }
-}
-
 pub use default::default;
-pub use foldhash::fast::{FixedState, FoldHasher as DefaultHasher, RandomState};
-#[cfg(feature = "alloc")]
-pub use hashbrown;
+
 #[cfg(feature = "std")]
 pub use parallel_queue::*;
 
-#[cfg(feature = "alloc")]
-use core::any::TypeId;
-use core::{
-    fmt::Debug,
-    hash::{BuildHasher, Hash, Hasher},
-    marker::PhantomData,
-    mem::ManuallyDrop,
-    ops::Deref,
-};
-
-/// A shortcut alias for [`hashbrown::hash_map::Entry`].
-#[cfg(feature = "alloc")]
-pub type Entry<'a, K, V, S = FixedHasher> = hashbrown::hash_map::Entry<'a, K, V, S>;
-
-/// A [`HashMap`][hashbrown::HashMap] implementing a high
-/// speed keyed hashing algorithm intended for use in in-memory hashmaps.
-///
-/// The hashing algorithm is designed for performance
-/// and is NOT cryptographically secure.
-///
-/// Within the same execution of the program iteration order of different
-/// `HashMap`s only depends on the order of insertions and deletions,
-/// but it will not be stable between multiple executions of the program.
-#[cfg(feature = "alloc")]
-pub type HashMap<K, V, S = FixedHasher> = hashbrown::HashMap<K, V, S>;
-
-/// A stable hash map implementing a high speed keyed hashing algorithm
-/// intended for use in in-memory hashmaps.
-///
-/// Unlike [`HashMap`] the iteration order stability extends between executions
-/// using the same Bevy version on the same device.
-///
-/// The hashing algorithm is designed for performance
-/// and is NOT cryptographically secure.
-#[deprecated(
-    note = "Will be required to use the hash library of your choice. Alias for: hashbrown::HashMap<K, V, FixedHasher>"
-)]
-#[cfg(feature = "alloc")]
-pub type StableHashMap<K, V> = hashbrown::HashMap<K, V, FixedHasher>;
-
-/// A [`HashSet`][hashbrown::HashSet] implementing a high
-/// speed keyed hashing algorithm intended for use in in-memory hashmaps.
-///
-/// The hashing algorithm is designed for performance
-/// and is NOT cryptographically secure.
-///
-/// Within the same execution of the program iteration order of different
-/// `HashSet`s only depends on the order of insertions and deletions,
-/// but it will not be stable between multiple executions of the program.
-#[cfg(feature = "alloc")]
-pub type HashSet<K, S = FixedHasher> = hashbrown::HashSet<K, S>;
+use core::mem::ManuallyDrop;
 
-/// A stable hash set using a high speed keyed hashing algorithm
-/// intended for use in in-memory hashmaps.
-///
-/// Unlike [`HashMap`] the iteration order stability extends between executions
-/// using the same Bevy version on the same device.
-///
-/// The hashing algorithm is designed for performance
-/// and is NOT cryptographically secure.
-#[deprecated(
-    note = "Will be required to use the hash library of your choice. Alias for: hashbrown::HashSet<K, FixedHasher>"
-)]
 #[cfg(feature = "alloc")]
-pub type StableHashSet<K> = hashbrown::HashSet<K, FixedHasher>;
-
-/// A pre-hashed value of a specific type. Pre-hashing enables memoization of hashes that are expensive to compute.
-///
-/// It also enables faster [`PartialEq`] comparisons by short circuiting on hash equality.
-/// See [`PassHash`] and [`PassHasher`] for a "pass through" [`BuildHasher`] and [`Hasher`] implementation
-/// designed to work with [`Hashed`]
-/// See [`PreHashMap`] for a hashmap pre-configured to use [`Hashed`] keys.
-pub struct Hashed<V, S = FixedHasher> {
-    hash: u64,
-    value: V,
-    marker: PhantomData<S>,
-}
-
-impl<V: Hash, H: BuildHasher + Default> Hashed<V, H> {
-    /// Pre-hashes the given value using the [`BuildHasher`] configured in the [`Hashed`] type.
-    pub fn new(value: V) -> Self {
-        Self {
-            hash: H::default().hash_one(&value),
-            value,
-            marker: PhantomData,
-        }
-    }
-
-    /// The pre-computed hash.
-    #[inline]
-    pub fn hash(&self) -> u64 {
-        self.hash
-    }
-}
-
-impl<V, H> Hash for Hashed<V, H> {
-    #[inline]
-    fn hash<R: Hasher>(&self, state: &mut R) {
-        state.write_u64(self.hash);
-    }
-}
-
-impl<V, H> Deref for Hashed<V, H> {
-    type Target = V;
-
-    #[inline]
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<V: PartialEq, H> PartialEq for Hashed<V, H> {
-    /// A fast impl of [`PartialEq`] that first checks that `other`'s pre-computed hash
-    /// matches this value's pre-computed hash.
-    #[inline]
-    fn eq(&self, other: &Self) -> bool {
-        self.hash == other.hash && self.value.eq(&other.value)
-    }
-}
-
-impl<V: Debug, H> Debug for Hashed<V, H> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("Hashed")
-            .field("hash", &self.hash)
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-impl<V: Clone, H> Clone for Hashed<V, H> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self {
-            hash: self.hash,
-            value: self.value.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<V: Copy, H> Copy for Hashed<V, H> {}
-
-impl<V: Eq, H> Eq for Hashed<V, H> {}
-
-/// A [`BuildHasher`] that results in a [`PassHasher`].
-#[derive(Default, Clone)]
-pub struct PassHash;
-
-impl BuildHasher for PassHash {
-    type Hasher = PassHasher;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        PassHasher::default()
-    }
-}
-
-/// A no-op hash that only works on `u64`s. Will panic if attempting to
-/// hash a type containing non-u64 fields.
-#[derive(Debug, Default)]
-pub struct PassHasher {
-    hash: u64,
-}
-
-impl Hasher for PassHasher {
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.hash
-    }
-
-    fn write(&mut self, _bytes: &[u8]) {
-        panic!("can only hash u64 using PassHasher");
-    }
-
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.hash = i;
-    }
-}
+use {
+    bevy_platform_support::{
+        collections::HashMap,
+        hash::{Hashed, NoOpHash, PassHash},
+    },
+    core::{any::TypeId, hash::Hash},
+};
 
 /// A [`HashMap`] pre-configured to use [`Hashed`] keys and [`PassHash`] passthrough hashing.
 /// Iteration order only depends on the order of insertions and deletions.
 #[cfg(feature = "alloc")]
-pub type PreHashMap<K, V> = hashbrown::HashMap<Hashed<K>, V, PassHash>;
+pub type PreHashMap<K, V> = HashMap<Hashed<K>, V, PassHash>;
 
 /// Extension methods intended to add functionality to [`PreHashMap`].
 #[cfg(feature = "alloc")]
@@ -256,7 +67,7 @@ pub trait PreHashMapExt<K, V> {
 impl<K: Hash + Eq + PartialEq + Clone, V> PreHashMapExt<K, V> for PreHashMap<K, V> {
     #[inline]
     fn get_or_insert_with<F: FnOnce() -> V>(&mut self, key: &Hashed<K>, func: F) -> &mut V {
-        use hashbrown::hash_map::RawEntryMut;
+        use bevy_platform_support::collections::hash_map::RawEntryMut;
         let entry = self
             .raw_entry_mut()
             .from_key_hashed_nocheck(key.hash(), key);
@@ -273,43 +84,7 @@ impl<K: Hash + Eq + PartialEq + Clone, V> PreHashMapExt<K, V> for PreHashMap<K,
 /// A specialized hashmap type with Key of [`TypeId`]
 /// Iteration order only depends on the order of insertions and deletions.
 #[cfg(feature = "alloc")]
-pub type TypeIdMap<V> = hashbrown::HashMap<TypeId, V, NoOpHash>;
-
-/// [`BuildHasher`] for types that already contain a high-quality hash.
-#[derive(Clone, Default)]
-pub struct NoOpHash;
-
-impl BuildHasher for NoOpHash {
-    type Hasher = NoOpHasher;
-
-    fn build_hasher(&self) -> Self::Hasher {
-        NoOpHasher(0)
-    }
-}
-
-#[doc(hidden)]
-pub struct NoOpHasher(u64);
-
-// This is for types that already contain a high-quality hash and want to skip
-// re-hashing that hash.
-impl Hasher for NoOpHasher {
-    fn finish(&self) -> u64 {
-        self.0
-    }
-
-    fn write(&mut self, bytes: &[u8]) {
-        // This should never be called by consumers. Prefer to call `write_u64` instead.
-        // Don't break applications (slower fallback, just check in test):
-        self.0 = bytes.iter().fold(self.0, |hash, b| {
-            hash.rotate_left(8).wrapping_add(*b as u64)
-        });
-    }
-
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.0 = i;
-    }
-}
+pub type TypeIdMap<V> = HashMap<TypeId, V, NoOpHash>;
 
 /// A type which calls a function when dropped.
 /// This can be used to ensure that cleanup code is run even in case of a panic.
diff --git a/crates/bevy_winit/Cargo.toml b/crates/bevy_winit/Cargo.toml
index 4caf374200487..3e215d6e6a540 100644
--- a/crates/bevy_winit/Cargo.toml
+++ b/crates/bevy_winit/Cargo.toml
@@ -14,7 +14,12 @@ wayland = ["winit/wayland", "winit/wayland-csd-adwaita"]
 x11 = ["winit/x11"]
 accesskit_unix = ["accesskit_winit/accesskit_unix", "accesskit_winit/async-io"]
 
-serialize = ["serde", "bevy_input/serialize", "bevy_window/serialize"]
+serialize = [
+  "serde",
+  "bevy_input/serialize",
+  "bevy_window/serialize",
+  "bevy_platform_support/serialize",
+]
 android-native-activity = ["winit/android-native-activity"]
 android-game-activity = ["winit/android-game-activity"]
 
diff --git a/crates/bevy_winit/src/cursor.rs b/crates/bevy_winit/src/cursor.rs
index 88f551633c56f..885a78297c67e 100644
--- a/crates/bevy_winit/src/cursor.rs
+++ b/crates/bevy_winit/src/cursor.rs
@@ -30,8 +30,8 @@ use bevy_ecs::{
 };
 #[cfg(feature = "custom_cursor")]
 use bevy_image::{Image, TextureAtlasLayout};
+use bevy_platform_support::collections::HashSet;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
-use bevy_utils::HashSet;
 use bevy_window::{SystemCursorIcon, Window};
 #[cfg(feature = "custom_cursor")]
 use tracing::warn;
diff --git a/crates/bevy_winit/src/state.rs b/crates/bevy_winit/src/state.rs
index 97c376428e7ae..0c1a02e0ce0b4 100644
--- a/crates/bevy_winit/src/state.rs
+++ b/crates/bevy_winit/src/state.rs
@@ -20,11 +20,11 @@ use bevy_log::{error, trace, warn};
 #[cfg(feature = "custom_cursor")]
 use bevy_math::URect;
 use bevy_math::{ivec2, DVec2, Vec2};
+#[cfg(feature = "custom_cursor")]
+use bevy_platform_support::collections::HashMap;
 use bevy_platform_support::time::Instant;
 #[cfg(not(target_arch = "wasm32"))]
 use bevy_tasks::tick_global_task_pools_on_main_thread;
-#[cfg(feature = "custom_cursor")]
-use bevy_utils::HashMap;
 use core::marker::PhantomData;
 #[cfg(target_arch = "wasm32")]
 use winit::platform::web::EventLoopExtWebSys;
diff --git a/crates/bevy_winit/src/winit_windows.rs b/crates/bevy_winit/src/winit_windows.rs
index 9f7896d4c7e4e..cae20f15afc84 100644
--- a/crates/bevy_winit/src/winit_windows.rs
+++ b/crates/bevy_winit/src/winit_windows.rs
@@ -2,7 +2,7 @@ use bevy_a11y::AccessibilityRequested;
 use bevy_ecs::entity::Entity;
 
 use bevy_ecs::entity::hash_map::EntityHashMap;
-use bevy_utils::HashMap;
+use bevy_platform_support::collections::HashMap;
 use bevy_window::{
     CursorGrabMode, MonitorSelection, Window, WindowMode, WindowPosition, WindowResolution,
     WindowWrapper,
diff --git a/examples/3d/tonemapping.rs b/examples/3d/tonemapping.rs
index 875198e7fed3f..8fabb0d464dbd 100644
--- a/examples/3d/tonemapping.rs
+++ b/examples/3d/tonemapping.rs
@@ -3,13 +3,13 @@
 use bevy::{
     core_pipeline::tonemapping::Tonemapping,
     pbr::CascadeShadowConfigBuilder,
+    platform_support::collections::HashMap,
     prelude::*,
     reflect::TypePath,
     render::{
         render_resource::{AsBindGroup, ShaderRef},
         view::{ColorGrading, ColorGradingGlobal, ColorGradingSection},
     },
-    utils::HashMap,
 };
 use std::f32::consts::PI;
 
diff --git a/examples/ecs/immutable_components.rs b/examples/ecs/immutable_components.rs
index bde5cc9d95b58..1fe1dde23ad78 100644
--- a/examples/ecs/immutable_components.rs
+++ b/examples/ecs/immutable_components.rs
@@ -5,9 +5,9 @@ use bevy::{
         component::{ComponentDescriptor, ComponentId, HookContext, StorageType},
         world::DeferredWorld,
     },
+    platform_support::collections::HashMap,
     prelude::*,
     ptr::OwningPtr,
-    utils::HashMap,
 };
 use core::alloc::Layout;
 
diff --git a/examples/ecs/observers.rs b/examples/ecs/observers.rs
index 2ed3c785c0f1b..105d0305d4d53 100644
--- a/examples/ecs/observers.rs
+++ b/examples/ecs/observers.rs
@@ -1,8 +1,8 @@
 //! Demonstrates how to observe life-cycle triggers as well as define custom ones.
 
 use bevy::{
+    platform_support::collections::{HashMap, HashSet},
     prelude::*,
-    utils::{HashMap, HashSet},
 };
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
diff --git a/examples/reflection/reflection_types.rs b/examples/reflection/reflection_types.rs
index 6229392b32b0e..2b492f5d4533b 100644
--- a/examples/reflection/reflection_types.rs
+++ b/examples/reflection/reflection_types.rs
@@ -2,9 +2,9 @@
 //! structs, tuples and vectors.
 
 use bevy::{
+    platform_support::collections::HashMap,
     prelude::*,
     reflect::{DynamicList, PartialReflect, ReflectRef},
-    utils::HashMap,
 };
 use serde::{Deserialize, Serialize};
 
diff --git a/examples/ui/directional_navigation.rs b/examples/ui/directional_navigation.rs
index b228df6dd4889..0512c7498db54 100644
--- a/examples/ui/directional_navigation.rs
+++ b/examples/ui/directional_navigation.rs
@@ -19,9 +19,9 @@ use bevy::{
         backend::HitData,
         pointer::{Location, PointerId},
     },
+    platform_support::collections::{HashMap, HashSet},
     prelude::*,
     render::camera::NormalizedRenderTarget,
-    utils::{HashMap, HashSet},
 };
 
 fn main() {
diff --git a/tests/ecs/ambiguity_detection.rs b/tests/ecs/ambiguity_detection.rs
index b53450ba22bbf..c77c0e5edb8d4 100644
--- a/tests/ecs/ambiguity_detection.rs
+++ b/tests/ecs/ambiguity_detection.rs
@@ -6,9 +6,9 @@
 
 use bevy::{
     ecs::schedule::{InternedScheduleLabel, LogLevel, ScheduleBuildSettings},
+    platform_support::collections::HashMap,
     prelude::*,
     render::pipelined_rendering::RenderExtractApp,
-    utils::HashMap,
 };
 
 fn main() {