diff --git a/crates/rspack/src/builder/mod.rs b/crates/rspack/src/builder/mod.rs
index 77c670af7195..08b24444290c 100644
--- a/crates/rspack/src/builder/mod.rs
+++ b/crates/rspack/src/builder/mod.rs
@@ -1190,7 +1190,7 @@ impl CompilerOptionsBuilder {
       .into_iter()
       .for_each(|(name, desc)| {
         let entry_options = EntryOptions {
-          name: Some(name),
+          name: Some(name.into()),
           runtime: desc.runtime.map(EntryRuntime::String),
           chunk_loading: desc.chunk_loading,
           wasm_loading: desc.wasm_loading,
diff --git a/crates/rspack_binding_api/src/allocator.rs b/crates/rspack_binding_api/src/allocator.rs
index 8879ef4f4075..53c90446277a 100644
--- a/crates/rspack_binding_api/src/allocator.rs
+++ b/crates/rspack_binding_api/src/allocator.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use napi::{Env, bindgen_prelude::ToNapiValue, sys::napi_env};
 use rspack_core::BindingCell;
 
@@ -57,7 +59,7 @@ impl rspack_core::NapiAllocator for NapiAllocatorImpl {
   fn allocate_assets(
     &self,
     env: napi_env,
-    val: &BindingCell<rustc_hash::FxHashMap<String, rspack_core::CompilationAsset>>,
+    val: &BindingCell<rustc_hash::FxHashMap<Arc<str>, rspack_core::CompilationAsset>>,
   ) -> napi::Result<napi::sys::napi_value> {
     let assets = Assets::new(val.downgrade());
     unsafe { ToNapiValue::to_napi_value(env, assets) }
diff --git a/crates/rspack_binding_api/src/asset.rs b/crates/rspack_binding_api/src/asset.rs
index a70dda1d3951..7295f01a18c5 100644
--- a/crates/rspack_binding_api/src/asset.rs
+++ b/crates/rspack_binding_api/src/asset.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use napi::{
   Env, JsValue,
   bindgen_prelude::{
@@ -23,7 +25,7 @@ impl From<AssetInfoRelated> for rspack_core::AssetInfoRelated {
     Self {
       source_map: match i.source_map {
         Some(either) => match either {
-          Either::A(string) => Some(string),
+          Either::A(string) => Some(Arc::from(string)),
           Either::B(_) => None,
         },
         None => None,
@@ -208,7 +210,7 @@ pub struct JsAsset {
 impl From<rspack_core::AssetInfoRelated> for AssetInfoRelated {
   fn from(related: rspack_core::AssetInfoRelated) -> Self {
     Self {
-      source_map: related.source_map.map(Either::A),
+      source_map: related.source_map.map(|s| Either::A(s.to_string())),
     }
   }
 }
diff --git a/crates/rspack_binding_api/src/build_info.rs b/crates/rspack_binding_api/src/build_info.rs
index 00efff8fb6f3..a84797ee9503 100644
--- a/crates/rspack_binding_api/src/build_info.rs
+++ b/crates/rspack_binding_api/src/build_info.rs
@@ -1,4 +1,7 @@
-use std::{cell::RefCell, sync::LazyLock};
+use std::{
+  cell::RefCell,
+  sync::{Arc, LazyLock},
+};
 
 use napi::{
   Env, JsString, JsValue, Property, PropertyAttributes, Unknown,
@@ -24,17 +27,17 @@ define_symbols! {
 // Record<string, Source>
 #[napi]
 pub struct Assets {
-  i: WeakBindingCell<FxHashMap<String, rspack_core::CompilationAsset>>,
+  i: WeakBindingCell<FxHashMap<Arc<str>, rspack_core::CompilationAsset>>,
 }
 
 impl Assets {
-  pub fn new(i: WeakBindingCell<FxHashMap<String, rspack_core::CompilationAsset>>) -> Self {
+  pub fn new(i: WeakBindingCell<FxHashMap<Arc<str>, rspack_core::CompilationAsset>>) -> Self {
     Self { i }
   }
 
   fn with_ref<T>(
     &self,
-    f: impl FnOnce(&FxHashMap<String, rspack_core::CompilationAsset>) -> napi::Result<T>,
+    f: impl FnOnce(&FxHashMap<Arc<str>, rspack_core::CompilationAsset>) -> napi::Result<T>,
   ) -> napi::Result<T> {
     match self.i.upgrade() {
       Some(reference) => f(reference.as_ref()),
diff --git a/crates/rspack_binding_api/src/chunk.rs b/crates/rspack_binding_api/src/chunk.rs
index fdeac7434bdb..74a7621ddf47 100644
--- a/crates/rspack_binding_api/src/chunk.rs
+++ b/crates/rspack_binding_api/src/chunk.rs
@@ -92,9 +92,9 @@ impl Chunk {
   }
 
   #[napi(getter, js_name = "_files")]
-  pub fn files(&self) -> napi::Result<Vec<&String>> {
+  pub fn files(&self) -> napi::Result<Vec<&str>> {
     let (_, chunk) = self.as_ref()?;
-    let mut files = Vec::from_iter(chunk.files());
+    let mut files: Vec<&str> = chunk.files().iter().map(|s| s.as_ref()).collect();
     files.sort_unstable();
     Ok(files)
   }
@@ -156,9 +156,9 @@ impl Chunk {
   }
 
   #[napi(getter, js_name = "_auxiliaryFiles")]
-  pub fn auxiliary_files(&self) -> napi::Result<Vec<&String>> {
+  pub fn auxiliary_files(&self) -> napi::Result<Vec<&str>> {
     let (_, chunk) = self.as_ref()?;
-    Ok(chunk.auxiliary_files().iter().collect::<Vec<_>>())
+    Ok(chunk.auxiliary_files().iter().map(|s| s.as_ref()).collect())
   }
 }
 
diff --git a/crates/rspack_binding_api/src/chunk_group.rs b/crates/rspack_binding_api/src/chunk_group.rs
index d09b7ee83b8f..7bbd77fd7701 100644
--- a/crates/rspack_binding_api/src/chunk_group.rs
+++ b/crates/rspack_binding_api/src/chunk_group.rs
@@ -148,7 +148,7 @@ impl ChunkGroup {
   }
 
   #[napi]
-  pub fn get_files(&self) -> napi::Result<Vec<&String>> {
+  pub fn get_files(&self) -> napi::Result<Vec<&str>> {
     let (compilation, chunk_group) = self.as_ref()?;
     Ok(
       chunk_group
@@ -159,7 +159,7 @@ impl ChunkGroup {
             .build_chunk_graph_artifact
             .chunk_by_ukey
             .get(chunk_ukey)
-            .map(|chunk| chunk.files().iter())
+            .map(|chunk| chunk.files().iter().map(|s| s.as_ref()))
         })
         .flatten()
         .collect::<Vec<_>>(),
diff --git a/crates/rspack_binding_api/src/compilation/entries.rs b/crates/rspack_binding_api/src/compilation/entries.rs
index 42f76a2db772..b4dba2cd6855 100644
--- a/crates/rspack_binding_api/src/compilation/entries.rs
+++ b/crates/rspack_binding_api/src/compilation/entries.rs
@@ -20,14 +20,14 @@ impl EntryOptionsDTO {
 #[napi]
 impl EntryOptionsDTO {
   #[napi(getter)]
-  pub fn name(&self) -> Either<&String, ()> {
-    self.0.name.as_ref().into()
+  pub fn name(&self) -> Either<&str, ()> {
+    self.0.name.as_ref().map(|s| s.as_ref()).into()
   }
 
   #[napi(setter)]
   pub fn set_name(&mut self, name: Either<String, ()>) {
     self.0.name = match name {
-      Either::A(s) => Some(s),
+      Either::A(s) => Some(s.into()),
       Either::B(_) => None,
     };
   }
@@ -252,7 +252,7 @@ impl JsEntries {
 
   #[napi]
   pub fn has(&self, key: String) -> bool {
-    self.compilation.entries.contains_key(&key)
+    self.compilation.entries.contains_key(key.as_str())
   }
 
   #[napi]
@@ -267,18 +267,18 @@ impl JsEntries {
         dto.entry_data.clone()
       }
     };
-    self.compilation.entries.insert(key, entry_data);
+    self.compilation.entries.insert(key.into(), entry_data);
   }
 
   #[napi]
   pub fn delete(&mut self, key: String) -> bool {
-    let r = self.compilation.entries.swap_remove(&key);
+    let r = self.compilation.entries.swap_remove(key.as_str());
     r.is_some()
   }
 
   #[napi]
   pub fn get(&'static mut self, key: String) -> Result<Either<EntryDataDTO, ()>> {
-    Ok(match self.compilation.entries.get(&key) {
+    Ok(match self.compilation.entries.get(key.as_str()) {
       Some(entry_data) => Either::A(EntryDataDTO {
         entry_data: entry_data.clone(),
         compilation: self.compilation,
@@ -288,8 +288,13 @@ impl JsEntries {
   }
 
   #[napi]
-  pub fn keys(&self) -> Vec<&String> {
-    self.compilation.entries.keys().collect()
+  pub fn keys(&self) -> Vec<&str> {
+    self
+      .compilation
+      .entries
+      .keys()
+      .map(|s| s.as_ref())
+      .collect()
   }
 
   #[napi]
diff --git a/crates/rspack_binding_api/src/compilation/mod.rs b/crates/rspack_binding_api/src/compilation/mod.rs
index cff956ab624f..0cf2cf15d25a 100644
--- a/crates/rspack_binding_api/src/compilation/mod.rs
+++ b/crates/rspack_binding_api/src/compilation/mod.rs
@@ -4,7 +4,7 @@ mod dependencies;
 mod diagnostics;
 pub mod entries;
 
-use std::{cell::RefCell, path::Path, ptr::NonNull};
+use std::{cell::RefCell, path::Path, ptr::NonNull, sync::Arc};
 
 use chunks::Chunks;
 pub use code_generation_results::*;
@@ -163,7 +163,7 @@ impl JsCompilation {
     for (filename, asset) in compilation.assets() {
       let info = asset.info.reflector();
       assets.push(JsAsset {
-        name: filename.clone(),
+        name: filename.to_string(),
         info,
       });
     }
@@ -175,7 +175,7 @@ impl JsCompilation {
   pub fn get_asset(&self, name: String) -> Result<Option<JsAsset>> {
     let compilation = self.as_ref()?;
 
-    match compilation.assets().get(&name) {
+    match compilation.assets().get(name.as_str()) {
       Some(asset) => {
         let info = asset.info.reflector();
         Ok(Some(JsAsset { name, info }))
@@ -190,7 +190,7 @@ impl JsCompilation {
 
     compilation
       .assets()
-      .get(&name)
+      .get(name.as_str())
       .and_then(|v| {
         v.source
           .as_ref()
@@ -266,7 +266,7 @@ impl JsCompilation {
         .build_chunk_graph_artifact
         .named_chunks
         .keys()
-        .cloned()
+        .map(|s| s.to_string())
         .collect::<Vec<_>>(),
     )
   }
@@ -279,7 +279,7 @@ impl JsCompilation {
       compilation
         .build_chunk_graph_artifact
         .named_chunks
-        .get(&name)
+        .get(name.as_str())
         .and_then(|c| {
           compilation
             .build_chunk_graph_artifact
@@ -291,7 +291,7 @@ impl JsCompilation {
   }
 
   #[napi]
-  pub fn get_named_chunk_group_keys(&self) -> Result<Vec<String>> {
+  pub fn get_named_chunk_group_keys(&self) -> Result<Vec<&str>> {
     let compilation = self.as_ref()?;
 
     Ok(
@@ -299,7 +299,7 @@ impl JsCompilation {
         .build_chunk_graph_artifact
         .named_chunk_groups
         .keys()
-        .cloned()
+        .map(|s| s.as_ref())
         .collect::<Vec<_>>(),
     )
   }
@@ -311,7 +311,7 @@ impl JsCompilation {
       compilation
         .build_chunk_graph_artifact
         .named_chunk_groups
-        .get(&name)
+        .get(name.as_str())
         .map(|ukey| ChunkGroupWrapper::new(*ukey, compilation)),
     )
   }
@@ -321,7 +321,8 @@ impl JsCompilation {
     let compilation = self.as_mut()?;
 
     let source: BoxSource = source.try_into()?;
-    match compilation.assets_mut().entry(name) {
+    let name_key = Arc::from(name);
+    match compilation.assets_mut().entry(name_key) {
       std::collections::hash_map::Entry::Occupied(mut e) => e.get_mut().set_source(Some(source)),
       std::collections::hash_map::Entry::Vacant(e) => {
         e.insert(rspack_core::CompilationAsset::from(source));
@@ -334,10 +335,9 @@ impl JsCompilation {
   pub fn delete_asset_source(&mut self, name: String) -> Result<()> {
     let compilation = self.as_mut()?;
 
-    compilation
-      .assets_mut()
-      .entry(name)
-      .and_modify(|a| a.set_source(None));
+    if let Some(asset) = compilation.assets_mut().get_mut(name.as_str()) {
+      asset.set_source(None);
+    }
     Ok(())
   }
 
@@ -350,8 +350,7 @@ impl JsCompilation {
         .assets()
         .iter()
         .filter(|(_, asset)| asset.get_source().is_some())
-        .map(|(filename, _)| filename)
-        .cloned()
+        .map(|(filename, _)| filename.to_string())
         .collect(),
     )
   }
@@ -360,7 +359,7 @@ impl JsCompilation {
   pub fn has_asset(&self, name: String) -> Result<bool> {
     let compilation = self.as_ref()?;
 
-    Ok(compilation.assets().contains_key(&name))
+    Ok(compilation.assets().contains_key(name.as_str()))
   }
 
   #[napi(
diff --git a/crates/rspack_binding_api/src/module.rs b/crates/rspack_binding_api/src/module.rs
index 9d63c3755806..ff671dd500da 100644
--- a/crates/rspack_binding_api/src/module.rs
+++ b/crates/rspack_binding_api/src/module.rs
@@ -458,7 +458,7 @@ impl Module {
     };
 
     module.build_info_mut().assets.insert(
-      filename,
+      filename.into(),
       rspack_core::CompilationAsset {
         source: Some(source.try_into()?),
         info: asset_info,
diff --git a/crates/rspack_binding_api/src/options/entry.rs b/crates/rspack_binding_api/src/options/entry.rs
index 7c13cff0f28b..5c9ab61086a0 100644
--- a/crates/rspack_binding_api/src/options/entry.rs
+++ b/crates/rspack_binding_api/src/options/entry.rs
@@ -54,7 +54,7 @@ pub struct JsEntryOptions {
 impl From<JsEntryOptions> for EntryOptions {
   fn from(value: JsEntryOptions) -> Self {
     Self {
-      name: value.name,
+      name: value.name.map(Into::into),
       runtime: value.runtime.map(|r| JsEntryRuntimeWrapper(r).into()),
       chunk_loading: value.chunk_loading.map(Into::into),
       wasm_loading: value.wasm_loading.map(Into::into),
diff --git a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_context_replacement.rs b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_context_replacement.rs
index 831453224ca9..2994ca8cd7da 100644
--- a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_context_replacement.rs
+++ b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_context_replacement.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use napi::bindgen_prelude::Object;
 use napi_derive::napi;
 use rspack_error::{Error, ToStringResultToRspackResultExt};
@@ -36,7 +38,7 @@ impl<'a> TryFrom<RawContextReplacementPluginOptions<'a>> for ContextReplacementP
       for key in keys {
         let value = raw.get::<String>(&key).to_rspack_result()?;
         if let Some(value) = value {
-          map.insert(key, value);
+          map.insert(Arc::from(key), value);
         }
       }
       Some(map)
diff --git a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_copy.rs b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_copy.rs
index 94b4950b6d8f..d11d39712743 100644
--- a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_copy.rs
+++ b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_copy.rs
@@ -236,7 +236,7 @@ impl From<RawInfo> for Info {
       development: value.development,
       hot_module_replacement: value.hot_module_replacement,
       related: value.related.map(|r| Related {
-        source_map: r.source_map,
+        source_map: r.source_map.map(Into::into),
       }),
       version: value.version,
     }
diff --git a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_dll.rs b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_dll.rs
index 36d46b1d4b8c..cde3947c2888 100644
--- a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_dll.rs
+++ b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_dll.rs
@@ -27,7 +27,7 @@ impl From<RawDllEntryPluginOptions> for DllEntryPluginOptions {
     } = value;
 
     Self {
-      name,
+      name: name.into(),
       context: context.into(),
       entries,
     }
diff --git a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
index 98632dabce48..966a82b44bd5 100644
--- a/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
+++ b/crates/rspack_binding_api/src/raw_options/raw_builtins/raw_mf.rs
@@ -42,7 +42,7 @@ impl From<RawContainerPluginOptions> for ContainerPluginOptions {
   fn from(value: RawContainerPluginOptions) -> Self {
     let share_scope = into_share_scope(value.share_scope);
     Self {
-      name: value.name,
+      name: value.name.into(),
       share_scope,
       library: value.library.into(),
       runtime: value.runtime.map(|r| JsEntryRuntimeWrapper(r).into()),
@@ -163,7 +163,7 @@ impl From<RawCollectShareEntryPluginOptions> for CollectSharedEntryPluginOptions
         .into_iter()
         .map(|provide| {
           let (key, consume_options): (String, ConsumeOptions) = provide.into();
-          (key, std::sync::Arc::new(consume_options))
+          (key, Arc::new(consume_options))
         })
         .collect(),
       filename: value.filename,
@@ -184,7 +184,7 @@ pub struct RawSharedContainerPluginOptions {
 impl From<RawSharedContainerPluginOptions> for SharedContainerPluginOptions {
   fn from(value: RawSharedContainerPluginOptions) -> Self {
     SharedContainerPluginOptions {
-      name: value.name,
+      name: value.name.into(),
       request: value.request,
       version: value.version,
       library: value.library.into(),
diff --git a/crates/rspack_binding_api/src/resolver.rs b/crates/rspack_binding_api/src/resolver.rs
index 2cbda9c3bd7d..2a45eb4a05c5 100644
--- a/crates/rspack_binding_api/src/resolver.rs
+++ b/crates/rspack_binding_api/src/resolver.rs
@@ -28,9 +28,9 @@ impl From<rspack_core::Resource> for ResolveRequest {
       value.description_data.map(|data| data.into_parts()).unzip();
     Self {
       path: value.path.to_string(),
-      query: value.query,
-      fragment: value.fragment,
-      description_file_data: description_file_data.map(std::sync::Arc::unwrap_or_clone),
+      query: value.query.to_string(),
+      fragment: value.fragment.to_string(),
+      description_file_data: description_file_data.map(Arc::unwrap_or_clone),
       description_file_path: description_file_path.map(|path| path.to_string_lossy().into_owned()),
       file_dependencies: vec![],
       missing_dependencies: vec![],
diff --git a/crates/rspack_binding_api/src/rsdoctor.rs b/crates/rspack_binding_api/src/rsdoctor.rs
index a7392451108c..0b7fa17572ce 100644
--- a/crates/rspack_binding_api/src/rsdoctor.rs
+++ b/crates/rspack_binding_api/src/rsdoctor.rs
@@ -182,7 +182,7 @@ impl From<RsdoctorEntrypoint> for JsRsdoctorEntrypoint {
   fn from(value: RsdoctorEntrypoint) -> Self {
     JsRsdoctorEntrypoint {
       ukey: value.ukey,
-      name: value.name,
+      name: value.name.to_string(),
       chunks: value.chunks.into_iter().collect::<Vec<_>>(),
     }
   }
diff --git a/crates/rspack_binding_api/src/swc.rs b/crates/rspack_binding_api/src/swc.rs
index d2a5d91494be..286f6ce5a494 100644
--- a/crates/rspack_binding_api/src/swc.rs
+++ b/crates/rspack_binding_api/src/swc.rs
@@ -48,9 +48,9 @@ fn _transform(source: String, options: String) -> napi::Result<TransformOutput>
 
   #[cfg(feature = "plugin")]
   {
-    options.runtime_options = options.runtime_options.plugin_runtime(std::sync::Arc::new(
-      rspack_util::swc::runtime::WasmtimeRuntime,
-    ));
+    options.runtime_options = options
+      .runtime_options
+      .plugin_runtime(Arc::new(rspack_util::swc::runtime::WasmtimeRuntime));
   }
 
   let compiler = JavaScriptCompiler::new();
diff --git a/crates/rspack_core/src/artifacts/build_chunk_graph_artifact.rs b/crates/rspack_core/src/artifacts/build_chunk_graph_artifact.rs
index a0cec8fff58c..6a0f839f7626 100644
--- a/crates/rspack_core/src/artifacts/build_chunk_graph_artifact.rs
+++ b/crates/rspack_core/src/artifacts/build_chunk_graph_artifact.rs
@@ -1,4 +1,4 @@
-use std::mem;
+use std::{mem, sync::Arc};
 
 use futures::Future;
 use rspack_collections::{IdentifierIndexMap, IdentifierMap};
@@ -19,10 +19,10 @@ pub struct BuildChunkGraphArtifact {
   pub chunk_by_ukey: ChunkByUkey,
   pub chunk_graph: ChunkGraph,
   pub chunk_group_by_ukey: ChunkGroupByUkey,
-  pub entrypoints: FxIndexMap<String, ChunkGroupUkey>,
+  pub entrypoints: FxIndexMap<Arc<str>, ChunkGroupUkey>,
   pub async_entrypoints: Vec<ChunkGroupUkey>,
-  pub named_chunk_groups: HashMap<String, ChunkGroupUkey>,
-  pub named_chunks: HashMap<String, ChunkUkey>,
+  pub named_chunk_groups: HashMap<Arc<str>, ChunkGroupUkey>,
+  pub named_chunks: HashMap<Arc<str>, ChunkUkey>,
   pub(crate) code_splitter: CodeSplitter,
   pub module_idx: IdentifierMap<(u32, u32)>,
 }
diff --git a/crates/rspack_core/src/artifacts/code_generation_results.rs b/crates/rspack_core/src/artifacts/code_generation_results.rs
index d1833fafc3c5..72ec2de058c8 100644
--- a/crates/rspack_core/src/artifacts/code_generation_results.rs
+++ b/crates/rspack_core/src/artifacts/code_generation_results.rs
@@ -2,7 +2,7 @@ use std::{
   collections::hash_map::Entry,
   hash::Hash,
   ops::{Deref, DerefMut},
-  sync::atomic::AtomicU32,
+  sync::{Arc, atomic::AtomicU32},
 };
 
 use anymap::CloneAny;
@@ -42,19 +42,19 @@ pub struct URLStaticMode;
 
 #[derive(Clone, Debug)]
 pub struct CodeGenerationDataFilename {
-  filename: String,
+  filename: Arc<str>,
   public_path: String,
 }
 
 impl CodeGenerationDataFilename {
-  pub fn new(filename: String, public_path: String) -> Self {
+  pub fn new(filename: impl Into<Arc<str>>, public_path: String) -> Self {
     Self {
-      filename,
+      filename: filename.into(),
       public_path,
     }
   }
 
-  pub fn filename(&self) -> &str {
+  pub fn filename(&self) -> &Arc<str> {
     &self.filename
   }
 
diff --git a/crates/rspack_core/src/binding/cell.rs b/crates/rspack_core/src/binding/cell.rs
index eff6d3444a8e..eeca360be0d5 100644
--- a/crates/rspack_core/src/binding/cell.rs
+++ b/crates/rspack_core/src/binding/cell.rs
@@ -123,8 +123,8 @@ mod napi_binding {
           }
           HeapVariant::Assets(assets) => {
             let binding_cell = BindingCell {
-              ptr: assets.as_ref() as *const FxHashMap<String, CompilationAsset>
-                as *mut FxHashMap<String, CompilationAsset>,
+              ptr: assets.as_ref() as *const FxHashMap<Arc<str>, CompilationAsset>
+                as *mut FxHashMap<Arc<str>, CompilationAsset>,
               heap: heap.clone(),
             };
             let napi_val = allocator.allocate_assets(raw_env, &binding_cell)?;
@@ -165,7 +165,7 @@ mod napi_binding {
     CodeGenerationResults(Box<CodeGenerationResults>),
     CodeGenerationResult(Box<CodeGenerationResult>),
     Sources(Box<FxHashMap<SourceType, BoxSource>>),
-    Assets(Box<FxHashMap<String, CompilationAsset>>),
+    Assets(Box<FxHashMap<Arc<str>, CompilationAsset>>),
   }
 
   #[derive(Debug)]
@@ -276,11 +276,11 @@ mod napi_binding {
     }
   }
 
-  impl BindingCell<FxHashMap<String, CompilationAsset>> {
-    pub fn new(assets: FxHashMap<String, CompilationAsset>) -> Self {
+  impl BindingCell<FxHashMap<Arc<str>, CompilationAsset>> {
+    pub fn new(assets: FxHashMap<Arc<str>, CompilationAsset>) -> Self {
       let boxed = Box::new(assets);
-      let ptr = boxed.as_ref() as *const FxHashMap<String, CompilationAsset>
-        as *mut FxHashMap<String, CompilationAsset>;
+      let ptr = boxed.as_ref() as *const FxHashMap<Arc<str>, CompilationAsset>
+        as *mut FxHashMap<Arc<str>, CompilationAsset>;
       let heap = Arc::new(Heap {
         variant: HeapVariant::Assets(boxed),
         jsobject: Default::default(),
@@ -289,10 +289,10 @@ mod napi_binding {
     }
   }
 
-  impl From<FxHashMap<String, CompilationAsset>>
-    for BindingCell<FxHashMap<String, CompilationAsset>>
+  impl From<FxHashMap<Arc<str>, CompilationAsset>>
+    for BindingCell<FxHashMap<Arc<str>, CompilationAsset>>
   {
-    fn from(assets: FxHashMap<String, CompilationAsset>) -> Self {
+    fn from(assets: FxHashMap<Arc<str>, CompilationAsset>) -> Self {
       Self::new(assets)
     }
   }
@@ -422,7 +422,12 @@ mod napi_binding {
         CodeGenerationResult
       );
       deserialize_variant!(type_id, boxed, HeapVariant::Sources, FxHashMap<SourceType, BoxSource>);
-      deserialize_variant!(type_id, boxed, HeapVariant::Assets, FxHashMap<String, CompilationAsset>);
+      deserialize_variant!(
+        type_id,
+        boxed,
+        HeapVariant::Assets,
+        FxHashMap<Arc<str>, CompilationAsset>
+      );
 
       unreachable!()
     }
diff --git a/crates/rspack_core/src/binding/napi_allocator.rs b/crates/rspack_core/src/binding/napi_allocator.rs
index 8dece48e8271..c178049f4003 100644
--- a/crates/rspack_core/src/binding/napi_allocator.rs
+++ b/crates/rspack_core/src/binding/napi_allocator.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use napi::sys::{napi_env, napi_value};
 use once_cell::sync::OnceCell;
 use rspack_sources::BoxSource;
@@ -34,7 +36,7 @@ pub trait NapiAllocator {
   fn allocate_assets(
     &self,
     env: napi_env,
-    val: &BindingCell<FxHashMap<String, CompilationAsset>>,
+    val: &BindingCell<FxHashMap<Arc<str>, CompilationAsset>>,
   ) -> napi::Result<napi_value>;
 }
 
diff --git a/crates/rspack_core/src/chunk.rs b/crates/rspack_core/src/chunk.rs
index 69b48a5e7daa..77f8826af5db 100644
--- a/crates/rspack_core/src/chunk.rs
+++ b/crates/rspack_core/src/chunk.rs
@@ -1,4 +1,4 @@
-use std::{cmp::Ordering, fmt::Debug, hash::Hash};
+use std::{cmp::Ordering, fmt::Debug, hash::Hash, sync::Arc};
 
 use itertools::Itertools;
 use rayon::prelude::*;
@@ -57,15 +57,15 @@ pub struct Chunk {
   // - If the chunk is create by entry config, the name is the entry name
   // - The name of chunks create by dynamic import is `None` unless users use
   // magic comment like `import(/* webpackChunkName: "someChunk" * / './someModule.js')` to specify it.
-  name: Option<String>,
-  id_name_hints: HashSet<String>,
+  name: Option<Arc<str>>,
+  id_name_hints: HashSet<Arc<str>>,
   filename_template: Option<Filename>,
   css_filename_template: Option<Filename>,
   prevent_integration: bool,
   groups: HashSet<ChunkGroupUkey>,
   runtime: RuntimeSpec,
-  files: HashSet<String>,
-  auxiliary_files: HashSet<String>,
+  files: HashSet<Arc<str>>,
+  auxiliary_files: HashSet<Arc<str>>,
   chunk_reason: Option<String>,
   rendered: bool,
 }
@@ -83,8 +83,8 @@ impl Chunk {
     self.name.as_deref()
   }
 
-  pub fn set_name(&mut self, name: Option<String>) {
-    self.name = name;
+  pub fn set_name(&mut self, name: Option<impl Into<Arc<str>>>) {
+    self.name = name.map(Into::into);
   }
 
   pub fn filename_template(&self) -> Option<&Filename> {
@@ -127,12 +127,12 @@ impl Chunk {
     self.prevent_integration = prevent_integration;
   }
 
-  pub fn id_name_hints(&self) -> &HashSet<String> {
+  pub fn id_name_hints(&self) -> &HashSet<Arc<str>> {
     &self.id_name_hints
   }
 
-  pub fn add_id_name_hints(&mut self, hint: String) {
-    self.id_name_hints.insert(hint);
+  pub fn add_id_name_hints(&mut self, hint: impl Into<Arc<str>>) {
+    self.id_name_hints.insert(hint.into());
   }
 
   pub fn groups(&self) -> &HashSet<ChunkGroupUkey> {
@@ -167,24 +167,24 @@ impl Chunk {
     self.runtime = runtime;
   }
 
-  pub fn files(&self) -> &HashSet<String> {
+  pub fn files(&self) -> &HashSet<Arc<str>> {
     &self.files
   }
 
-  pub fn add_file(&mut self, file: String) {
-    self.files.insert(file);
+  pub fn add_file(&mut self, file: impl Into<Arc<str>>) {
+    self.files.insert(file.into());
   }
 
   pub fn remove_file(&mut self, file: &str) -> bool {
     self.files.remove(file)
   }
 
-  pub fn auxiliary_files(&self) -> &HashSet<String> {
+  pub fn auxiliary_files(&self) -> &HashSet<Arc<str>> {
     &self.auxiliary_files
   }
 
-  pub fn add_auxiliary_file(&mut self, auxiliary_file: String) {
-    self.auxiliary_files.insert(auxiliary_file);
+  pub fn add_auxiliary_file(&mut self, auxiliary_file: impl Into<Arc<str>>) {
+    self.auxiliary_files.insert(auxiliary_file.into());
   }
 
   pub fn remove_auxiliary_file(&mut self, auxiliary_file: &str) -> bool {
@@ -268,9 +268,9 @@ impl Chunk {
 }
 
 impl Chunk {
-  pub fn new(name: Option<String>, kind: ChunkKind) -> Self {
+  pub fn new(name: Option<impl Into<Arc<str>>>, kind: ChunkKind) -> Self {
     Self {
-      name,
+      name: name.map(Into::into),
       filename_template: None,
       css_filename_template: None,
       ukey: ChunkUkey::new(),
diff --git a/crates/rspack_core/src/chunk_graph/mod.rs b/crates/rspack_core/src/chunk_graph/mod.rs
index bce05339a361..bf253ac2a964 100644
--- a/crates/rspack_core/src/chunk_graph/mod.rs
+++ b/crates/rspack_core/src/chunk_graph/mod.rs
@@ -76,7 +76,7 @@ impl ChunkGraph {
           origins.sort();
           Cow::Owned(origins.join("\n"))
         },
-        Cow::Borrowed,
+        |name| Cow::Borrowed(name.as_ref()),
       );
       let table_header = format!("<tr><td bgcolor=\"#aaa\">{chunk_group_name}</td></tr>");
       let bg_color = if chunk_group.is_initial() {
diff --git a/crates/rspack_core/src/chunk_group.rs b/crates/rspack_core/src/chunk_group.rs
index 9288df9cd6ac..f6c9b04f4620 100644
--- a/crates/rspack_core/src/chunk_group.rs
+++ b/crates/rspack_core/src/chunk_group.rs
@@ -1,6 +1,7 @@
 use std::{
   cmp::Ordering,
   fmt::{self, Display},
+  sync::Arc,
 };
 
 use itertools::Itertools;
@@ -103,7 +104,7 @@ impl ChunkGroup {
       .copied()
   }
 
-  pub fn get_files(&self, chunk_by_ukey: &ChunkByUkey) -> Vec<String> {
+  pub fn get_files(&self, chunk_by_ukey: &ChunkByUkey) -> Vec<Arc<str>> {
     self
       .chunks
       .iter()
@@ -287,10 +288,10 @@ impl ChunkGroup {
       .join("+")
   }
 
-  pub fn name(&self) -> Option<&str> {
+  pub fn name(&self) -> Option<&Arc<str>> {
     match &self.kind {
-      ChunkGroupKind::Entrypoint { options, .. } => options.name.as_deref(),
-      ChunkGroupKind::Normal { options } => options.name.as_deref(),
+      ChunkGroupKind::Entrypoint { options, .. } => options.name.as_ref(),
+      ChunkGroupKind::Normal { options } => options.name.as_ref(),
     }
   }
 
@@ -404,10 +405,10 @@ impl ChunkGroupKind {
     }
   }
 
-  pub fn name(&self) -> Option<&str> {
+  pub fn name(&self) -> Option<&Arc<str>> {
     match self {
-      ChunkGroupKind::Entrypoint { options, .. } => options.name.as_deref(),
-      ChunkGroupKind::Normal { options } => options.name.as_deref(),
+      ChunkGroupKind::Entrypoint { options, .. } => options.name.as_ref(),
+      ChunkGroupKind::Normal { options } => options.name.as_ref(),
     }
   }
 }
@@ -445,7 +446,7 @@ impl EntryRuntime {
 #[cacheable]
 #[derive(Debug, Default, Clone, Hash, PartialEq, Eq)]
 pub struct EntryOptions {
-  pub name: Option<String>,
+  pub name: Option<Arc<str>>,
   pub runtime: Option<EntryRuntime>,
   pub chunk_loading: Option<ChunkLoading>,
   pub wasm_loading: Option<WasmLoading>,
@@ -518,7 +519,7 @@ impl Display for ChunkGroupOrderKey {
 #[cacheable]
 #[derive(Debug, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct ChunkGroupOptions {
-  pub name: Option<String>,
+  pub name: Option<Arc<str>>,
   pub preload_order: Option<i32>,
   pub prefetch_order: Option<i32>,
   pub fetch_priority: Option<DynamicImportFetchPriority>,
@@ -526,7 +527,7 @@ pub struct ChunkGroupOptions {
 
 impl ChunkGroupOptions {
   pub fn new(
-    name: Option<String>,
+    name: Option<Arc<str>>,
     preload_order: Option<i32>,
     prefetch_order: Option<i32>,
     fetch_priority: Option<DynamicImportFetchPriority>,
@@ -538,7 +539,7 @@ impl ChunkGroupOptions {
       fetch_priority,
     }
   }
-  pub fn name_optional(mut self, name: Option<String>) -> Self {
+  pub fn name_optional(mut self, name: Option<Arc<str>>) -> Self {
     self.name = name;
     self
   }
@@ -552,10 +553,10 @@ pub enum GroupOptions {
 }
 
 impl GroupOptions {
-  pub fn name(&self) -> Option<&str> {
+  pub fn name(&self) -> Option<&Arc<str>> {
     match self {
-      Self::Entrypoint(e) => e.name.as_deref(),
-      Self::ChunkGroup(n) => n.name.as_deref(),
+      Self::Entrypoint(e) => e.name.as_ref(),
+      Self::ChunkGroup(n) => n.name.as_ref(),
     }
   }
 
diff --git a/crates/rspack_core/src/compilation/build_chunk_graph/code_splitter.rs b/crates/rspack_core/src/compilation/build_chunk_graph/code_splitter.rs
index 4819900ddc40..d13ad8be3a34 100644
--- a/crates/rspack_core/src/compilation/build_chunk_graph/code_splitter.rs
+++ b/crates/rspack_core/src/compilation/build_chunk_graph/code_splitter.rs
@@ -230,8 +230,8 @@ pub(crate) struct CodeSplitter {
   // 2 direction map
   pub(crate) block_owner: HashMap<AsyncDependenciesBlockIdentifier, HashSet<CgiUkey>>,
 
-  pub(crate) named_chunk_groups: HashMap<String, CgiUkey>,
-  pub(crate) named_async_entrypoints: HashMap<String, CgiUkey>,
+  pub(crate) named_chunk_groups: HashMap<Arc<str>, CgiUkey>,
+  pub(crate) named_async_entrypoints: HashMap<Arc<str>, CgiUkey>,
   pub(crate) block_modules_runtime_map: BlockModulesRuntimeMap,
   pub(crate) ordinal_by_module: IdentifierMap<u64>,
   pub(crate) mask_by_chunk: HashMap<ChunkUkey, BigUint>,
@@ -270,9 +270,7 @@ fn add_chunk_in_group(
   request: Option<String>,
 ) -> ChunkGroup {
   let options = ChunkGroupOptions::new(
-    group_options
-      .and_then(|x| x.name())
-      .map(|name| name.to_string()),
+    group_options.and_then(|x| x.name()).map(Arc::clone),
     group_options
       .and_then(|x| x.normal_options())
       .and_then(|x| x.preload_order),
@@ -354,7 +352,7 @@ impl CodeSplitter {
 
   pub fn prepare_entry_input(
     &mut self,
-    name: &str,
+    name: &Arc<str>,
     compilation: &mut Compilation,
   ) -> Result<(ChunkGroupUkey, Vec<ModuleIdentifier>)> {
     let Some(entry_data) = compilation.entries.get(name) else {
@@ -468,12 +466,12 @@ impl CodeSplitter {
     compilation
       .build_chunk_graph_artifact
       .named_chunk_groups
-      .insert(name.to_string(), entrypoint.ukey);
+      .insert(name.clone(), entrypoint.ukey);
 
     compilation
       .build_chunk_graph_artifact
       .entrypoints
-      .insert(name.to_string(), entrypoint.ukey);
+      .insert(name.clone(), entrypoint.ukey);
 
     let entrypoint = {
       let ukey = entrypoint.ukey;
@@ -527,7 +525,7 @@ impl CodeSplitter {
 
     self.chunk_group_info_map.insert(entrypoint.ukey, cgi);
     if let Some(name) = entrypoint.name() {
-      self.named_chunk_groups.insert(name.to_string(), cgi);
+      self.named_chunk_groups.insert(name.clone(), cgi);
     }
 
     let entrypoint_ukey = entrypoint.ukey;
@@ -604,8 +602,11 @@ Remove the 'runtime' option from the entrypoint."
         let referenced_chunks = entry_point_chunk
           .get_all_referenced_chunks(&compilation.build_chunk_graph_artifact.chunk_group_by_ukey);
 
-        for dep in depend_on {
-          if let Some(dependency_ukey) = compilation.build_chunk_graph_artifact.entrypoints.get(dep)
+        for depend_entry_name in depend_on {
+          if let Some(dependency_ukey) = compilation
+            .build_chunk_graph_artifact
+            .entrypoints
+            .get(depend_entry_name.as_str())
           {
             let dependency_chunk_ukey = compilation
               .build_chunk_graph_artifact
@@ -614,7 +615,7 @@ Remove the 'runtime' option from the entrypoint."
               .get_entrypoint_chunk();
             if referenced_chunks.contains(&dependency_chunk_ukey) {
               let mut diagnostic = Diagnostic::from(error!(
-                "Entrypoints '{name}' and '{dep}' use 'dependOn' to depend on each other in a circular way."
+                "Entrypoints '{name}' and '{depend_entry_name}' use 'dependOn' to depend on each other in a circular way."
               ));
               diagnostic.chunk = Some(entry_point.get_entrypoint_chunk().as_u32());
               runtime_errors.push(diagnostic);
@@ -624,7 +625,7 @@ Remove the 'runtime' option from the entrypoint."
             }
             depend_on_entries.push(dependency_ukey);
           } else {
-            panic!("Entry {name} depends on {dep}, but this entry was not found");
+            panic!("Entry {name} depends on {depend_entry_name}, but this entry was not found");
           }
         }
       }
@@ -670,7 +671,7 @@ Remove the 'runtime' option from the entrypoint."
       let chunk = match compilation
         .build_chunk_graph_artifact
         .named_chunks
-        .get(runtime)
+        .get(runtime.as_str())
       {
         Some(ukey) => {
           if !self.runtime_chunks.contains(ukey) {
diff --git a/crates/rspack_core/src/compilation/build_chunk_graph/incremental.rs b/crates/rspack_core/src/compilation/build_chunk_graph/incremental.rs
index 4f66b5470d67..c859234b2c4c 100644
--- a/crates/rspack_core/src/compilation/build_chunk_graph/incremental.rs
+++ b/crates/rspack_core/src/compilation/build_chunk_graph/incremental.rs
@@ -17,7 +17,7 @@ use crate::{
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum ChunkReCreation {
   Entry {
-    name: String,
+    name: Arc<str>,
     depend_on: Option<Vec<String>>,
   },
   Normal(NormalChunkRecreation),
@@ -121,18 +121,18 @@ impl CodeSplitter {
       .remove(&chunk_group_ukey)
       .expect("when we have cgi, we have chunk group");
 
-    let chunk_group_name = chunk_group.name().map(|s| s.to_string());
-    if let Some(name) = &chunk_group_name {
+    let chunk_group_name = chunk_group.name();
+    if let Some(name) = chunk_group_name {
       compilation
         .build_chunk_graph_artifact
         .named_chunk_groups
-        .remove(name);
+        .remove(name.as_ref());
       compilation
         .build_chunk_graph_artifact
         .entrypoints
-        .swap_remove(name);
-      self.named_chunk_groups.remove(name);
-      self.named_async_entrypoints.remove(name);
+        .swap_remove(name.as_ref());
+      self.named_chunk_groups.remove(name.as_ref());
+      self.named_async_entrypoints.remove(name.as_ref());
     }
 
     // remove child parent relations
@@ -284,7 +284,7 @@ impl CodeSplitter {
       && chunk_group.parents.is_empty()
     {
       edges = vec![ChunkReCreation::Entry {
-        name,
+        name: name.clone(),
         depend_on: None,
       }];
     }
@@ -573,7 +573,7 @@ impl CodeSplitter {
 
     let mut removed_entries = FxHashSet::default();
     for (name, chunk_group) in compilation.entrypoints() {
-      if !compilation.entries.contains_key(name) {
+      if !compilation.entries.contains_key(name.as_ref()) {
         removed_entries.insert(*chunk_group);
       }
     }
@@ -708,10 +708,10 @@ impl CodeSplitter {
 
       let a_depends_on_b = a_depend_on
         .as_deref()
-        .is_some_and(|deps| deps.contains(b_name));
+        .is_some_and(|deps| deps.iter().any(|s| s.as_str() == b_name.as_ref()));
       let b_depends_on_a = b_depend_on
         .as_deref()
-        .is_some_and(|deps| deps.contains(a_name));
+        .is_some_and(|deps| deps.iter().any(|s| s.as_str() == a_name.as_ref()));
 
       // If a depends on b, b must come first (a > b).
       // If b depends on a, a must come first (a < b).
diff --git a/crates/rspack_core/src/compilation/build_module_graph/module_executor/execute.rs b/crates/rspack_core/src/compilation/build_module_graph/module_executor/execute.rs
index 923c9eaf835c..c5b92896c9ae 100644
--- a/crates/rspack_core/src/compilation/build_module_graph/module_executor/execute.rs
+++ b/crates/rspack_core/src/compilation/build_module_graph/module_executor/execute.rs
@@ -231,7 +231,7 @@ impl Task<ExecutorTaskContext> for ExecuteTask {
 
     let mut chunk_graph = ChunkGraph::default();
 
-    let mut chunk = Chunk::new(Some("build time chunk".into()), ChunkKind::Normal);
+    let mut chunk = Chunk::new(Some("build time chunk"), ChunkKind::Normal);
 
     if let Some(name) = chunk.name() {
       let name = name.to_string();
diff --git a/crates/rspack_core/src/compilation/build_module_graph/module_executor/mod.rs b/crates/rspack_core/src/compilation/build_module_graph/module_executor/mod.rs
index 3295e29ab7d4..e40af51c0a4f 100644
--- a/crates/rspack_core/src/compilation/build_module_graph/module_executor/mod.rs
+++ b/crates/rspack_core/src/compilation/build_module_graph/module_executor/mod.rs
@@ -5,6 +5,8 @@ mod execute;
 mod module_tracker;
 mod overwrite;
 
+use std::sync::Arc;
+
 use rspack_collections::{Identifier, IdentifierDashMap, IdentifierDashSet};
 use rspack_error::Result;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
@@ -42,7 +44,7 @@ pub struct ModuleExecutor {
   // temporary data, used by hook_after_finish_modules
   event_sender: Option<UnboundedSender<Event>>,
   stop_receiver: Option<oneshot::Receiver<ExecutorTaskContext>>,
-  module_assets: IdentifierDashMap<HashMap<String, CompilationAsset>>,
+  module_assets: IdentifierDashMap<HashMap<Arc<str>, CompilationAsset>>,
   code_generated_modules: IdentifierDashSet,
   pub executed_runtime_modules: IdentifierDashMap<ExecutedRuntimeModule>,
 }
@@ -208,7 +210,7 @@ impl ModuleExecutor {
         .module_assets
         .entry(origin_module_identifier)
         .or_default()
-        .extend(assets);
+        .extend(assets.into_iter());
     }
 
     for id in code_generated_modules {
diff --git a/crates/rspack_core/src/compilation/create_chunk_assets/mod.rs b/crates/rspack_core/src/compilation/create_chunk_assets/mod.rs
index aa578dcacbc1..1f48ff712d6f 100644
--- a/crates/rspack_core/src/compilation/create_chunk_assets/mod.rs
+++ b/crates/rspack_core/src/compilation/create_chunk_assets/mod.rs
@@ -163,7 +163,7 @@ pub async fn create_chunk_assets(
     compilation.extend_diagnostics(diagnostics);
 
     for file_manifest in manifests {
-      let filename = file_manifest.filename;
+      let filename = &file_manifest.filename;
       let current_chunk = compilation
         .build_chunk_graph_artifact
         .chunk_by_ukey
@@ -181,7 +181,7 @@ pub async fn create_chunk_assets(
         CompilationAsset::new(Some(file_manifest.source), file_manifest.info),
       );
 
-      _ = chunk_asset(compilation, chunk_ukey, &filename, plugin_driver.clone()).await;
+      _ = chunk_asset(compilation, chunk_ukey, filename, plugin_driver.clone()).await;
     }
   }
 
diff --git a/crates/rspack_core/src/compilation/mod.rs b/crates/rspack_core/src/compilation/mod.rs
index 930f321ebaf2..417766b7a5f6 100644
--- a/crates/rspack_core/src/compilation/mod.rs
+++ b/crates/rspack_core/src/compilation/mod.rs
@@ -68,7 +68,7 @@ use crate::{
   CodeGenerationJob, CodeGenerationResult, CodeGenerationResults, CompilationLogger,
   CompilationLogging, CompilerOptions, CompilerPlatform, ConcatenationScope,
   DependenciesDiagnosticsArtifact, DependencyId, DependencyTemplate, DependencyTemplateType,
-  DependencyType, Entry, EntryData, EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId,
+  DependencyType, Entries, EntryData, EntryOptions, EntryRuntime, Entrypoint, ExecuteModuleId,
   ExportsInfoArtifact, ExtendedReferencedExport, Filename, ImportPhase, ImportVarMap,
   ImportedByDeferModulesArtifact, MemoryGCStorage, ModuleFactory, ModuleGraph,
   ModuleGraphCacheArtifact, ModuleIdentifier, ModuleIdsArtifact, ModuleStaticCache, PathData,
@@ -204,7 +204,7 @@ pub struct Compilation {
   pub records: Option<CompilationRecords>,
   pub options: Arc<CompilerOptions>,
   pub platform: Arc<CompilerPlatform>,
-  pub entries: Entry,
+  pub entries: Entries,
   pub global_entry: EntryData,
   pub dependency_factories: HashMap<DependencyType, Arc<dyn ModuleFactory>>,
   pub dependency_templates: HashMap<DependencyTemplateType, Arc<dyn DependencyTemplate>>,
@@ -212,7 +212,7 @@ pub struct Compilation {
   pub runtime_modules_hash: IdentifierMap<RspackHashDigest>,
   pub runtime_modules_code_generation_source: IdentifierMap<BoxSource>,
   assets: CompilationAssets,
-  assets_related_in: HashMap<String, HashSet<String>>,
+  assets_related_in: HashMap<Arc<str>, HashSet<Arc<str>>>,
   pub emitted_assets: DashSet<String, BuildHasherDefault<FxHasher>>,
   diagnostics: Vec<Diagnostic>,
   logging: CompilationLogging,
@@ -609,7 +609,7 @@ impl Compilation {
 
   pub async fn add_entry(&mut self, entry: BoxDependency, options: EntryOptions) -> Result<()> {
     let entry_id = *entry.id();
-    let entry_name: Option<String> = options.name.clone();
+    let entry_name: Option<Arc<str>> = options.name.clone();
     let plugin_driver = self.plugin_driver.clone();
     self
       .build_module_graph_artifact
@@ -731,21 +731,22 @@ impl Compilation {
 
   fn set_asset_info(
     &mut self,
-    name: &str,
+    name: impl Into<Arc<str>>,
     new_info: Option<&AssetInfo>,
     old_info: Option<&AssetInfo>,
   ) {
+    let name = name.into();
     if let Some(old_info) = old_info
       && let Some(source_map) = &old_info.related.source_map
       && let Some(entry) = self.assets_related_in.get_mut(source_map)
     {
-      entry.remove(name);
+      entry.remove(name.as_ref());
     }
     if let Some(new_info) = new_info
       && let Some(source_map) = new_info.related.source_map.clone()
     {
       let entry = self.assets_related_in.entry(source_map).or_default();
-      entry.insert(name.to_string());
+      entry.insert(name);
     }
   }
 
@@ -776,7 +777,7 @@ impl Compilation {
     };
     self.set_asset_info(filename, Some(&new_info), Some(&old_info));
     self.assets.insert(
-      filename.to_owned(),
+      filename.into(),
       CompilationAsset {
         source: Some(new_source),
         info: new_info,
@@ -784,8 +785,10 @@ impl Compilation {
     );
     Ok(())
   }
-  #[instrument("Compilation:emit_asset",skip_all, fields(filename = filename))]
-  pub fn emit_asset(&mut self, filename: String, asset: CompilationAsset) {
+
+  #[instrument("Compilation:emit_asset", skip_all)]
+  pub fn emit_asset(&mut self, filename: impl Into<Arc<str>>, asset: CompilationAsset) {
+    let filename = filename.into();
     if let Some(mut original) = self.assets.remove(&filename)
       && let Some(original_source) = &original.source
       && let Some(asset_source) = asset.get_source()
@@ -806,15 +809,19 @@ impl Compilation {
           )
           .into(),
         );
-        self.set_asset_info(&filename, Some(asset.get_info()), None);
+        self.set_asset_info(filename.clone(), Some(asset.get_info()), None);
         self.assets.insert(filename, asset);
         return;
       }
-      self.set_asset_info(&filename, Some(asset.get_info()), Some(original.get_info()));
+      self.set_asset_info(
+        filename.clone(),
+        Some(asset.get_info()),
+        Some(original.get_info()),
+      );
       original.info = asset.info;
       self.assets.insert(filename, original);
     } else {
-      self.set_asset_info(&filename, Some(asset.get_info()), None);
+      self.set_asset_info(filename.clone(), Some(asset.get_info()), None);
       self.assets.insert(filename, asset);
     }
   }
@@ -837,18 +844,19 @@ impl Compilation {
     }
   }
 
-  pub fn rename_asset(&mut self, filename: &str, new_name: String) {
+  pub fn rename_asset(&mut self, filename: &str, new_name: impl Into<Arc<str>>) {
+    let new_name = new_name.into();
     if let Some(asset) = self.assets.remove(filename) {
       // Update related in all other assets
       if let Some(related_in_info) = self.assets_related_in.get(filename) {
         for name in related_in_info {
-          if let Some(asset) = self.assets.get_mut(name) {
+          if let Some(asset) = self.assets.get_mut(name.as_ref()) {
             asset.get_info_mut().related.source_map = Some(new_name.clone());
           }
         }
       }
-      self.set_asset_info(filename, None, Some(asset.get_info()));
-      self.set_asset_info(&new_name, Some(asset.get_info()), None);
+      self.set_asset_info(new_name.clone(), None, Some(asset.get_info()));
+      self.set_asset_info(new_name.clone(), Some(asset.get_info()), None);
 
       self.assets.insert(new_name.clone(), asset);
 
@@ -857,11 +865,11 @@ impl Compilation {
         .chunk_by_ukey
         .iter_mut()
         .for_each(|(_, chunk)| {
-          if chunk.remove_file(filename) {
+          if chunk.remove_file(filename.as_ref()) {
             chunk.add_file(new_name.clone());
           }
 
-          if chunk.remove_auxiliary_file(filename) {
+          if chunk.remove_auxiliary_file(filename.as_ref()) {
             chunk.add_auxiliary_file(new_name.clone());
           }
         });
@@ -872,7 +880,7 @@ impl Compilation {
   // Multiple calls to rename_asset would cause performance degradation due to
   // repeated full traversals of chunk_by_ukey. This method uses parallel iteration
   // over chunk_by_ukey to reduce traversal frequency and improve performance.
-  pub fn par_rename_assets(&mut self, renames: Vec<(String, String)>) {
+  pub fn par_rename_assets(&mut self, renames: Vec<(Arc<str>, Arc<str>)>) {
     self
       .build_chunk_graph_artifact
       .chunk_by_ukey
@@ -880,30 +888,30 @@ impl Compilation {
       .par_bridge()
       .for_each(|chunk| {
         for (old_name, new_name) in renames.iter() {
-          if chunk.remove_file(old_name) {
+          if chunk.remove_file(old_name.as_ref()) {
             chunk.add_file(new_name.clone());
           }
 
-          if chunk.remove_auxiliary_file(old_name) {
+          if chunk.remove_auxiliary_file(old_name.as_ref()) {
             chunk.add_auxiliary_file(new_name.clone());
           }
         }
       });
 
     for (old_name, new_name) in renames {
-      if let Some(asset) = self.assets.remove(&old_name) {
+      if let Some(asset) = self.assets.remove(old_name.as_ref()) {
         // Update related in all other assets
-        if let Some(related_in_info) = self.assets_related_in.get(&old_name) {
+        if let Some(related_in_info) = self.assets_related_in.get(old_name.as_ref()) {
           for related_in_name in related_in_info {
-            if let Some(asset) = self.assets.get_mut(related_in_name) {
+            if let Some(asset) = self.assets.get_mut(related_in_name.as_ref()) {
               asset.get_info_mut().related.source_map = Some(new_name.clone());
             }
           }
         }
-        self.set_asset_info(&old_name, None, Some(asset.get_info()));
-        self.set_asset_info(&new_name, Some(asset.get_info()), None);
+        self.set_asset_info(old_name.clone(), None, Some(asset.get_info()));
+        self.set_asset_info(new_name.clone(), Some(asset.get_info()), None);
 
-        self.assets.insert(new_name, asset);
+        self.assets.insert(new_name.clone(), asset);
       }
     }
   }
@@ -916,7 +924,7 @@ impl Compilation {
     &mut self.assets
   }
 
-  pub fn entrypoints(&self) -> &FxIndexMap<String, ChunkGroupUkey> {
+  pub fn entrypoints(&self) -> &FxIndexMap<Arc<str>, ChunkGroupUkey> {
     &self.build_chunk_graph_artifact.entrypoints
   }
 
@@ -997,25 +1005,26 @@ impl Compilation {
   }
 
   pub fn add_named_chunk(
-    name: String,
+    name: impl Into<Arc<str>>,
     chunk_by_ukey: &mut ChunkByUkey,
-    named_chunks: &mut HashMap<String, ChunkUkey>,
+    named_chunks: &mut HashMap<Arc<str>, ChunkUkey>,
   ) -> (ChunkUkey, bool) {
-    let existed_chunk_ukey = named_chunks.get(&name);
+    let name_key = name.into();
+    let existed_chunk_ukey = named_chunks.get(name_key.as_ref());
     if let Some(chunk_ukey) = existed_chunk_ukey {
       assert!(chunk_by_ukey.contains(chunk_ukey));
       (*chunk_ukey, false)
     } else {
-      let chunk = Chunk::new(Some(name.clone()), ChunkKind::Normal);
+      let chunk = Chunk::new(Some(name_key.clone()), ChunkKind::Normal);
       let ukey = chunk.ukey();
-      named_chunks.insert(name, ukey);
+      named_chunks.insert(name_key, ukey);
       chunk_by_ukey.entry(ukey).or_insert_with(|| chunk);
       (ukey, true)
     }
   }
 
   pub fn add_chunk(chunk_by_ukey: &mut ChunkByUkey) -> ChunkUkey {
-    let chunk = Chunk::new(None, ChunkKind::Normal);
+    let chunk = Chunk::new(None::<&str>, ChunkKind::Normal);
     let ukey = chunk.ukey();
     chunk_by_ukey.add(chunk);
     ukey
@@ -1243,7 +1252,7 @@ impl Compilation {
   }
 }
 
-pub type CompilationAssets = HashMap<String, CompilationAsset>;
+pub type CompilationAssets = HashMap<Arc<str>, CompilationAsset>;
 
 #[cacheable]
 #[derive(Debug, Clone)]
@@ -1429,7 +1438,7 @@ impl AssetInfo {
 #[cacheable]
 #[derive(Debug, Default, Clone)]
 pub struct AssetInfoRelated {
-  pub source_map: Option<String>,
+  pub source_map: Option<Arc<str>>,
 }
 
 impl AssetInfoRelated {
@@ -1486,7 +1495,7 @@ pub fn set_depth_if_lower(
 #[derive(Debug, Clone)]
 pub struct RenderManifestEntry {
   pub source: BoxSource,
-  pub filename: String,
+  pub filename: Arc<str>,
   pub has_filename: bool, /* webpack only asset has filename, js/css/wasm has filename template */
   pub info: AssetInfo,
   pub auxiliary: bool,
diff --git a/crates/rspack_core/src/compiler/mod.rs b/crates/rspack_core/src/compiler/mod.rs
index a445a67c1831..e2a177de7da0 100644
--- a/crates/rspack_core/src/compiler/mod.rs
+++ b/crates/rspack_core/src/compiler/mod.rs
@@ -96,7 +96,7 @@ pub struct Compiler {
   pub cache: Box<dyn Cache>,
   /// emitted asset versions
   /// the key of HashMap is filename, the value of HashMap is version
-  pub emitted_asset_versions: HashMap<String, String>,
+  pub emitted_asset_versions: HashMap<Arc<str>, String>,
   pub platform: Arc<CompilerPlatform>,
   compiler_context: Arc<CompilerContext>,
 }
@@ -352,7 +352,7 @@ impl Compiler {
       .call(&mut self.compilation)
       .await?;
 
-    let mut new_emitted_asset_versions = HashMap::default();
+    let mut new_emitted_asset_versions: HashMap<Arc<str>, String> = HashMap::default();
     let emit_assets_incremental = self
       .compilation
       .incremental
@@ -370,7 +370,7 @@ impl Compiler {
           }
 
           if emit_assets_incremental
-            && let Some(old_version) = self.emitted_asset_versions.get(filename)
+            && let Some(old_version) = self.emitted_asset_versions.get(filename.as_ref())
             && old_version.as_str() == asset.info.version
             && !old_version.is_empty()
           {
@@ -381,7 +381,7 @@ impl Compiler {
           let s = unsafe { token.used((&self, filename, asset, output_path)) };
 
           s.spawn(|(this, filename, asset, output_path)| {
-            this.emit_asset(output_path, filename, asset)
+            this.emit_asset(output_path, filename.as_ref(), asset)
           });
         })
     })
@@ -517,11 +517,10 @@ impl Compiler {
         .emitted_asset_versions
         .iter()
         .filter_map(|(filename, _version)| {
-          if !assets.contains_key(filename) {
-            let filename = filename.to_owned();
+          if !assets.contains_key(filename.as_ref()) {
             Some(async {
-              if !clean_options.keep(&filename).await {
-                let filename = output_path.join(filename);
+              if !clean_options.keep(filename.as_ref()).await {
+                let filename = output_path.join(filename.as_ref());
                 let _ = self.output_filesystem.remove_file(&filename).await;
               }
             })
diff --git a/crates/rspack_core/src/context_module.rs b/crates/rspack_core/src/context_module.rs
index 41b4f4855bde..9de398cd7f46 100644
--- a/crates/rspack_core/src/context_module.rs
+++ b/crates/rspack_core/src/context_module.rs
@@ -1171,7 +1171,7 @@ impl Module for ContextModule {
             {
               Cow::Owned(format!("{name}{CHUNK_NAME_INDEX_PLACEHOLDER}"))
             } else {
-              Cow::Borrowed(name)
+              Cow::Borrowed(name.as_ref())
             };
 
             let name = name.cow_replace(CHUNK_NAME_INDEX_PLACEHOLDER, &index.to_string());
@@ -1194,7 +1194,7 @@ impl Module for ContextModule {
           Some(self.options.context_options.request.clone()),
         );
         block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-          name,
+          name.map(Arc::from),
           preload_order,
           prefetch_order,
           fetch_priority,
diff --git a/crates/rspack_core/src/context_module_factory.rs b/crates/rspack_core/src/context_module_factory.rs
index 9f2e299b9168..d7fda73f1901 100644
--- a/crates/rspack_core/src/context_module_factory.rs
+++ b/crates/rspack_core/src/context_module_factory.rs
@@ -307,8 +307,8 @@ impl ContextModuleFactory {
         let options = ContextModuleOptions {
           addon: loader_request.clone(),
           resource: resource.path,
-          resource_query: resource.query,
-          resource_fragment: resource.fragment,
+          resource_query: resource.query.to_string(),
+          resource_fragment: resource.fragment.to_string(),
           layer: data.issuer_layer.clone(),
           resolve_options: data.resolve_options.clone(),
           context_options: dependency_options,
@@ -509,7 +509,7 @@ async fn visit_dirs(
 
         dependencies.push(ContextElementDependency {
           id: DependencyId::new(),
-          request,
+          request: Arc::from(request),
           user_request: r.request.clone(),
           category: options.context_options.category,
           context: options.resource.clone().into(),
@@ -529,13 +529,16 @@ async fn visit_dirs(
 
 #[derive(Debug, Clone)]
 pub struct AlternativeRequest {
-  pub context: String,
-  pub request: String,
+  pub context: Arc<str>,
+  pub request: Arc<str>,
 }
 
 impl AlternativeRequest {
-  pub fn new(context: String, request: String) -> Self {
-    Self { context, request }
+  pub fn new(context: impl Into<Arc<str>>, request: impl Into<Arc<str>>) -> Self {
+    Self {
+      context: context.into(),
+      request: request.into(),
+    }
   }
 }
 
diff --git a/crates/rspack_core/src/dependency/context_element_dependency.rs b/crates/rspack_core/src/dependency/context_element_dependency.rs
index 333ae119c9f5..8789b55f4bab 100644
--- a/crates/rspack_core/src/dependency/context_element_dependency.rs
+++ b/crates/rspack_core/src/dependency/context_element_dependency.rs
@@ -1,6 +1,8 @@
+use std::sync::Arc;
+
 use rspack_cacheable::{
   cacheable, cacheable_dyn,
-  with::{AsCacheable, AsOption, AsVec},
+  with::{AsCacheable, AsOption, AsRefStr, AsVec},
 };
 use rspack_util::json_stringify;
 
@@ -19,8 +21,10 @@ pub struct ContextElementDependency {
   pub id: DependencyId,
   // TODO remove this async dependency mark
   pub options: ContextOptions,
-  pub request: String,
-  pub user_request: String,
+  #[cacheable(with = AsRefStr)]
+  pub request: Arc<str>,
+  #[cacheable(with = AsRefStr)]
+  pub user_request: Arc<str>,
   pub category: DependencyCategory,
   pub context: Context,
   pub layer: Option<ModuleLayer>,
diff --git a/crates/rspack_core/src/dependency/entry.rs b/crates/rspack_core/src/dependency/entry.rs
index 595b33274c3b..892effe547a0 100644
--- a/crates/rspack_core/src/dependency/entry.rs
+++ b/crates/rspack_core/src/dependency/entry.rs
@@ -1,4 +1,6 @@
-use rspack_cacheable::{cacheable, cacheable_dyn};
+use std::sync::Arc;
+
+use rspack_cacheable::{cacheable, cacheable_dyn, with::AsRefStr};
 
 use super::{AffectType, FactorizeInfo};
 use crate::{
@@ -10,7 +12,8 @@ use crate::{
 #[derive(Debug, Clone)]
 pub struct EntryDependency {
   id: DependencyId,
-  request: String,
+  #[cacheable(with = AsRefStr)]
+  request: Arc<str>,
   context: Context,
   layer: Option<ModuleLayer>,
   is_global: bool,
@@ -21,7 +24,7 @@ impl PartialEq for EntryDependency {
   fn eq(&self, other: &Self) -> bool {
     self.id == other.id
       && self.context == other.context
-      && self.request == other.request
+      && self.request.as_ref() == other.request.as_ref()
       && self.layer == other.layer
       && self.is_global == other.is_global
   }
@@ -33,7 +36,7 @@ impl std::hash::Hash for EntryDependency {
   fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
     self.id.hash(state);
     self.context.hash(state);
-    self.request.hash(state);
+    self.request.as_ref().hash(state);
     self.layer.hash(state);
     self.is_global.hash(state);
   }
@@ -41,13 +44,13 @@ impl std::hash::Hash for EntryDependency {
 
 impl EntryDependency {
   pub fn new(
-    request: String,
+    request: impl Into<Arc<str>>,
     context: Context,
     layer: Option<ModuleLayer>,
     is_global: bool,
   ) -> Self {
     Self {
-      request,
+      request: request.into(),
       context,
       layer,
       id: DependencyId::new(),
diff --git a/crates/rspack_core/src/module.rs b/crates/rspack_core/src/module.rs
index 67a8da770f93..755ebf0dfdcb 100644
--- a/crates/rspack_core/src/module.rs
+++ b/crates/rspack_core/src/module.rs
@@ -107,7 +107,7 @@ pub struct BuildInfo {
   #[cacheable(with=AsOption<AsVec<AsPreset>>)]
   pub top_level_declarations: Option<HashSet<Atom>>,
   pub module_concatenation_bailout: Option<String>,
-  pub assets: BindingCell<HashMap<String, CompilationAsset>>,
+  pub assets: BindingCell<HashMap<Arc<str>, CompilationAsset>>,
   pub module: bool,
   pub inline_exports: bool,
   pub collected_typescript_info: Option<CollectedTypeScriptInfo>,
diff --git a/crates/rspack_core/src/normal_module.rs b/crates/rspack_core/src/normal_module.rs
index 95c98d812dae..cd2fa5029b6e 100644
--- a/crates/rspack_core/src/normal_module.rs
+++ b/crates/rspack_core/src/normal_module.rs
@@ -10,7 +10,7 @@ use std::{
 use derive_more::Debug;
 use rspack_cacheable::{
   cacheable, cacheable_dyn,
-  with::{As, AsOption, AsPreset},
+  with::{As, AsOption, AsPreset, AsRefStr},
 };
 use rspack_collections::{Identifiable, IdentifierMap, IdentifierSet};
 use rspack_error::{Diagnosable, Diagnostic, Result, error};
@@ -104,11 +104,14 @@ pub struct NormalModule {
   /// Context of this module
   context: Box<Context>,
   /// Request with loaders from config
-  request: String,
+  #[cacheable(with = AsRefStr)]
+  request: Arc<str>,
   /// Request intended by user (without loaders from config)
-  user_request: String,
+  #[cacheable(with = AsRefStr)]
+  user_request: Arc<str>,
   /// Request without resolving
-  raw_request: String,
+  #[cacheable(with = AsRefStr)]
+  raw_request: Arc<str>,
   /// The resolved module type of a module
   module_type: ModuleType,
   /// Layer of the module
@@ -172,9 +175,9 @@ impl NormalModule {
 
   #[allow(clippy::too_many_arguments)]
   pub fn new(
-    request: String,
-    user_request: String,
-    raw_request: String,
+    request: impl Into<Arc<str>>,
+    user_request: impl Into<Arc<str>>,
+    raw_request: impl Into<Arc<str>>,
     module_type: impl Into<ModuleType>,
     layer: Option<ModuleLayer>,
     parser_and_generator: Box<dyn ParserAndGenerator>,
@@ -188,6 +191,9 @@ impl NormalModule {
     extract_source_map: Option<bool>,
   ) -> Self {
     let module_type = module_type.into();
+    let request = request.into();
+    let user_request = user_request.into();
+    let raw_request = raw_request.into();
     let id = Self::create_id(&module_type, layer.as_ref(), &request);
     Self {
       blocks: Vec::new(),
@@ -246,8 +252,8 @@ impl NormalModule {
     &self.user_request
   }
 
-  pub fn user_request_mut(&mut self) -> &mut String {
-    &mut self.user_request
+  pub fn set_user_request(&mut self, s: impl Into<Arc<str>>) {
+    self.user_request = s.into();
   }
 
   pub fn raw_request(&self) -> &str {
@@ -379,7 +385,7 @@ impl Module for NormalModule {
     self.parsed = true;
 
     let no_parse = if let Some(no_parse) = build_context.compiler_options.module.no_parse.as_ref() {
-      no_parse.try_match(self.request.as_str()).await?
+      no_parse.try_match(self.request.as_ref()).await?
     } else {
       false
     };
diff --git a/crates/rspack_core/src/normal_module_factory.rs b/crates/rspack_core/src/normal_module_factory.rs
index b24aa9451095..327748ef762d 100644
--- a/crates/rspack_core/src/normal_module_factory.rs
+++ b/crates/rspack_core/src/normal_module_factory.rs
@@ -585,9 +585,9 @@ module.exports = "data:,";
       module
     } else {
       NormalModule::new(
-        create_data.request.clone(),
-        create_data.user_request.clone(),
-        create_data.raw_request.clone(),
+        create_data.request.as_str(),
+        create_data.user_request.as_str(),
+        create_data.raw_request.as_str(),
         resolved_module_type,
         resolved_module_layer,
         resolved_parser_and_generator,
diff --git a/crates/rspack_core/src/options/entry.rs b/crates/rspack_core/src/options/entry.rs
index 248bb0bd9c7b..220d090e3e57 100644
--- a/crates/rspack_core/src/options/entry.rs
+++ b/crates/rspack_core/src/options/entry.rs
@@ -1,10 +1,12 @@
+use std::sync::Arc;
+
 use rspack_util::fx_hash::FxIndexMap;
 
 use crate::{
   ChunkLoading, DependencyId, EntryOptions, Filename, LibraryOptions, PublicPath, WasmLoading,
 };
 
-pub type Entry = FxIndexMap<String, EntryData>;
+pub type Entries = FxIndexMap<Arc<str>, EntryData>;
 
 pub type EntryItem = Vec<String>;
 
diff --git a/crates/rspack_core/src/resolver/mod.rs b/crates/rspack_core/src/resolver/mod.rs
index 9d536955295c..04fda7b8bd64 100644
--- a/crates/rspack_core/src/resolver/mod.rs
+++ b/crates/rspack_core/src/resolver/mod.rs
@@ -59,8 +59,8 @@ pub enum ResolveResult {
 #[derive(Clone)]
 pub struct Resource {
   pub path: Utf8PathBuf,
-  pub query: String,
-  pub fragment: String,
+  pub query: Arc<str>,
+  pub fragment: Arc<str>,
   pub description_data: Option<DescriptionData>,
 }
 
@@ -81,8 +81,8 @@ impl Resource {
   /// Get the full path with query and fragment attached.
   pub fn full_path(&self) -> String {
     let mut buf = insert_zero_width_space_for_fragment(self.path.as_str()).into_owned();
-    buf.push_str(&insert_zero_width_space_for_fragment(&self.query));
-    buf.push_str(&self.fragment);
+    buf.push_str(&insert_zero_width_space_for_fragment(self.query.as_ref()));
+    buf.push_str(self.fragment.as_ref());
     buf
   }
 }
@@ -92,8 +92,8 @@ impl From<Resource> for ResourceData {
     let mut resource_data = Self::new_with_path(
       resource.full_path(),
       resource.path,
-      Some(resource.query),
-      Some(resource.fragment),
+      Some(resource.query.to_string()),
+      Some(resource.fragment.to_string()),
     );
     resource_data.set_description_optional(resource.description_data);
     resource_data
diff --git a/crates/rspack_core/src/resolver/resolver_impl.rs b/crates/rspack_core/src/resolver/resolver_impl.rs
index a1405b281d52..bc3ceceba4e3 100644
--- a/crates/rspack_core/src/resolver/resolver_impl.rs
+++ b/crates/rspack_core/src/resolver/resolver_impl.rs
@@ -145,8 +145,8 @@ impl Resolver {
     match self.resolver.resolve(path, request).await {
       Ok(r) => Ok(ResolveResult::Resource(Resource {
         path: r.path().to_path_buf().assert_utf8(),
-        query: r.query().unwrap_or_default().to_string(),
-        fragment: r.fragment().unwrap_or_default().to_string(),
+        query: Arc::from(r.query().unwrap_or_default()),
+        fragment: Arc::from(r.fragment().unwrap_or_default()),
         description_data: r
           .package_json()
           .map(|d| DescriptionData::new(d.directory().to_path_buf(), Arc::clone(d.raw_json()))),
@@ -177,8 +177,8 @@ impl Resolver {
     match result {
       Ok(r) => Ok(ResolveResult::Resource(Resource {
         path: r.path().to_path_buf().assert_utf8(),
-        query: r.query().unwrap_or_default().to_string(),
-        fragment: r.fragment().unwrap_or_default().to_string(),
+        query: Arc::from(r.query().unwrap_or_default()),
+        fragment: Arc::from(r.fragment().unwrap_or_default()),
         description_data: r
           .package_json()
           .map(|d| DescriptionData::new(d.directory().to_path_buf(), Arc::clone(d.raw_json()))),
diff --git a/crates/rspack_core/src/runtime.rs b/crates/rspack_core/src/runtime.rs
index 0c7da722136a..597ebc88f27a 100644
--- a/crates/rspack_core/src/runtime.rs
+++ b/crates/rspack_core/src/runtime.rs
@@ -1,4 +1,4 @@
-use std::{cmp::Ordering, collections::hash_map, fmt::Debug, ops::Deref};
+use std::{cmp::Ordering, collections::hash_map, fmt::Debug, ops::Deref, sync::Arc};
 
 use rspack_cacheable::{
   cacheable,
@@ -105,8 +105,8 @@ impl RuntimeSpec {
   }
 
   pub fn from_entry_options(options: &EntryOptions) -> Option<Self> {
-    let r = match &options.runtime {
-      Some(EntryRuntime::String(s)) => Some(s.to_owned()),
+    let r: Option<Arc<str>> = match &options.runtime {
+      Some(EntryRuntime::String(s)) => Some(s.as_str().into()),
       _ => options.name.clone(),
     };
     r.map(|r| Self::from_iter([r.into()]))
diff --git a/crates/rspack_core/src/runtime_template.rs b/crates/rspack_core/src/runtime_template.rs
index de5894a481a6..07cb7720775f 100644
--- a/crates/rspack_core/src/runtime_template.rs
+++ b/crates/rspack_core/src/runtime_template.rs
@@ -722,7 +722,10 @@ impl ModuleCodeTemplate {
     let block = mg.block_by_id_expect(block);
     let comment = self.comment(CommentOptions {
       request: None,
-      chunk_name: block.get_group_options().and_then(|o| o.name()),
+      chunk_name: block
+        .get_group_options()
+        .and_then(|o| o.name())
+        .map(|v| v.as_ref()),
       message: Some(message),
     });
     let chunks = chunk_group
diff --git a/crates/rspack_core/src/stats/mod.rs b/crates/rspack_core/src/stats/mod.rs
index d76de9e133fc..8fb0cfacf3b8 100644
--- a/crates/rspack_core/src/stats/mod.rs
+++ b/crates/rspack_core/src/stats/mod.rs
@@ -1,7 +1,10 @@
 use std::{
   borrow::Cow,
   hash::BuildHasherDefault,
-  sync::atomic::{AtomicU8, Ordering},
+  sync::{
+    Arc,
+    atomic::{AtomicU8, Ordering},
+  },
 };
 
 use dashmap::DashSet;
@@ -304,8 +307,8 @@ impl<'compilation> Stats<'compilation> {
 
 impl Stats<'_> {
   pub fn get_assets(&self) -> (Vec<StatsAsset<'_>>, Vec<StatsAssetsByChunkName<'_>>) {
-    let mut compilation_file_to_chunks: HashMap<&String, Vec<&Chunk>> = HashMap::default();
-    let mut compilation_file_to_auxiliary_chunks: HashMap<&String, Vec<&Chunk>> =
+    let mut compilation_file_to_chunks: HashMap<&Arc<str>, Vec<&Chunk>> = HashMap::default();
+    let mut compilation_file_to_auxiliary_chunks: HashMap<&Arc<str>, Vec<&Chunk>> =
       HashMap::default();
     for chunk in self.build_chunk_graph_artifact().chunk_by_ukey.values() {
       for file in chunk.files() {
@@ -321,7 +324,7 @@ impl Stats<'_> {
       }
     }
 
-    let mut assets: HashMap<&String, StatsAsset> = self
+    let mut assets: HashMap<&Arc<str>, StatsAsset> = self
       .assets()
       .par_iter()
       .filter_map(|(name, asset)| {
@@ -330,14 +333,14 @@ impl Stats<'_> {
           if let Some(source_map) = &asset.info.related.source_map {
             related.push(StatsAssetInfoRelated {
               name: "sourceMap",
-              value: vec![source_map.as_str()],
+              value: vec![source_map.as_ref()],
             })
           }
           (
             name,
             StatsAsset {
               r#type: "asset",
-              name: name.as_str(),
+              name: name.as_ref(),
               size: source.size() as f64,
               chunks: Vec::new(),
               chunk_names: Vec::new(),
@@ -351,19 +354,19 @@ impl Stats<'_> {
                   .info
                   .full_hash
                   .iter()
-                  .map(|s| s.as_str())
+                  .map(|s| s.as_ref())
                   .collect_vec(),
                 chunk_hash: asset
                   .info
                   .chunk_hash
                   .iter()
-                  .map(|s| s.as_str())
+                  .map(|s| s.as_ref())
                   .collect_vec(),
                 content_hash: asset
                   .info
                   .content_hash
                   .iter()
-                  .map(|s| s.as_str())
+                  .map(|s| s.as_ref())
                   .collect_vec(),
                 minimized: asset.info.minimized,
                 immutable: asset.info.immutable,
@@ -374,7 +377,7 @@ impl Stats<'_> {
                 copied: asset.info.copied,
                 is_over_size_limit: asset.info.is_over_size_limit,
               },
-              emitted: self.emitted_assets().contains(name),
+              emitted: self.emitted_assets().contains(name.as_ref()),
             },
           )
         })
@@ -403,7 +406,7 @@ impl Stats<'_> {
             chunk
               .id_name_hints()
               .iter()
-              .map(|name_hint| name_hint.as_str())
+              .map(|name_hint| name_hint.as_ref())
               .collect_vec()
           })
           .collect::<Vec<_>>();
@@ -427,7 +430,7 @@ impl Stats<'_> {
             chunk
               .id_name_hints()
               .iter()
-              .map(|name_hint| name_hint.as_str())
+              .map(|name_hint| name_hint.as_ref())
               .collect_vec()
           })
           .collect::<Vec<_>>();
@@ -446,14 +449,10 @@ impl Stats<'_> {
     });
 
     let mut assets_by_chunk_name: HashMap<&str, Vec<&str>> = HashMap::default();
-    for (file, chunks) in compilation_file_to_chunks {
+    for (file, chunks) in &compilation_file_to_chunks {
       for chunk in chunks {
         if let Some(name) = chunk.name() {
-          if let Some(assets) = assets_by_chunk_name.get_mut(name) {
-            assets.push(file);
-          } else {
-            assets_by_chunk_name.insert(name, vec![file]);
-          }
+          assets_by_chunk_name.entry(name).or_default().push(file);
         }
       }
     }
@@ -601,7 +600,7 @@ impl Stats<'_> {
       .par_bridge()
       .map(|c| -> Result<_> {
         let files: Vec<_> = {
-          let mut vec = c.files().iter().map(|s| s.as_str()).collect::<Vec<_>>();
+          let mut vec = c.files().iter().map(|s| s.as_ref()).collect::<Vec<_>>();
           vec.sort_unstable();
           vec
         };
@@ -619,7 +618,7 @@ impl Stats<'_> {
         let mut auxiliary_files = c
           .auxiliary_files()
           .iter()
-          .map(|s| s.as_str())
+          .map(|s| s.as_ref())
           .collect::<Vec<_>>();
         auxiliary_files.sort_unstable();
 
@@ -716,7 +715,7 @@ impl Stats<'_> {
           })
           .collect::<Vec<_>>();
 
-        let mut id_hints = c.id_name_hints().iter().map(|s| s.as_str()).collect_vec();
+        let mut id_hints = c.id_name_hints().iter().map(|s| s.as_ref()).collect_vec();
         id_hints.sort_unstable();
 
         Ok(StatsChunk {
@@ -798,8 +797,8 @@ impl Stats<'_> {
       .map(|c| {
         let chunk = build_chunk_graph_artifact.chunk_by_ukey.expect_get(c);
         chunk.files().par_iter().map(|file| StatsChunkGroupAsset {
-          name: file.as_str(),
-          size: get_asset_size(file, self.assets()),
+          name: file.as_ref(),
+          size: get_asset_size(file.as_ref(), self.assets()),
         })
       })
       .flatten()
@@ -814,8 +813,8 @@ impl Stats<'_> {
             .auxiliary_files()
             .par_iter()
             .map(|file| StatsChunkGroupAsset {
-              name: file.as_str(),
-              size: get_asset_size(file, self.assets()),
+              name: file.as_ref(),
+              size: get_asset_size(file.as_ref(), self.assets()),
             })
         })
         .flatten()
@@ -1326,7 +1325,7 @@ impl Stats<'_> {
           .build_info()
           .assets
           .keys()
-          .map(|s| s.as_str())
+          .map(|s| s.as_ref())
           .collect_vec();
         assets.sort_unstable();
         Some(assets)
diff --git a/crates/rspack_core/src/stats/utils.rs b/crates/rspack_core/src/stats/utils.rs
index 44dbd421bc45..d3ebb7759673 100644
--- a/crates/rspack_core/src/stats/utils.rs
+++ b/crates/rspack_core/src/stats/utils.rs
@@ -68,7 +68,7 @@ pub fn get_chunk_group_ordered_children<'a>(
       let cg = chunk_group_by_ukey.expect_get(ukey);
       stats.get_chunk_group(
         module_graph,
-        cg.name().unwrap_or_default(),
+        cg.name().map_or("", |s| s.as_ref()),
         ukey,
         chunk_group_auxiliary,
         false,
@@ -97,7 +97,7 @@ pub fn get_chunk_group_oreded_child_assets<'a>(
             .expect_get(c)
             .files()
             .iter()
-            .map(|file| file.as_str())
+            .map(|file| file.as_ref())
         })
         .collect::<Vec<_>>()
     })
diff --git a/crates/rspack_core/src/utils/runtime.rs b/crates/rspack_core/src/utils/runtime.rs
index ea28f3a83cbe..5954c332d03d 100644
--- a/crates/rspack_core/src/utils/runtime.rs
+++ b/crates/rspack_core/src/utils/runtime.rs
@@ -1,20 +1,15 @@
 use std::borrow::Cow;
 
 use cow_utils::CowUtils;
-use rspack_util::fx_hash::FxIndexMap;
 use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
 
 use super::extract_hash_pattern;
 use crate::{
-  CHUNK_HASH_PLACEHOLDER, CONTENT_HASH_PLACEHOLDER, EntryData, EntryOptions, FULL_HASH_PLACEHOLDER,
-  Filename, HASH_PLACEHOLDER, RuntimeSpec,
+  CHUNK_HASH_PLACEHOLDER, CONTENT_HASH_PLACEHOLDER, Entries, EntryData, EntryOptions,
+  FULL_HASH_PLACEHOLDER, Filename, HASH_PLACEHOLDER, RuntimeSpec,
 };
 
-pub fn get_entry_runtime(
-  name: &str,
-  options: &EntryOptions,
-  entries: &FxIndexMap<String, EntryData>,
-) -> RuntimeSpec {
+pub fn get_entry_runtime(name: &str, options: &EntryOptions, entries: &Entries) -> RuntimeSpec {
   if let Some(depend_on) = &options.depend_on {
     let mut result: RuntimeSpec = Default::default();
     let mut queue = vec![];
@@ -27,7 +22,7 @@ pub fn get_entry_runtime(
         continue;
       }
       visited.insert(name.clone());
-      let Some(EntryData { options, .. }) = entries.get(&name) else {
+      let Some(EntryData { options, .. }) = entries.get(name.as_str()) else {
         continue;
       };
 
diff --git a/crates/rspack_ids/src/id_helpers.rs b/crates/rspack_ids/src/id_helpers.rs
index 46788c259560..cee95df355e9 100644
--- a/crates/rspack_ids/src/id_helpers.rs
+++ b/crates/rspack_ids/src/id_helpers.rs
@@ -243,7 +243,11 @@ pub fn get_short_chunk_name(
     })
     .collect::<Vec<_>>();
 
-  let mut id_name_hints = Vec::from_iter(chunk.id_name_hints().clone());
+  let mut id_name_hints: Vec<String> = chunk
+    .id_name_hints()
+    .iter()
+    .map(|s| s.to_string())
+    .collect();
   id_name_hints.sort_unstable();
 
   id_name_hints.extend(short_module_names);
@@ -307,7 +311,11 @@ pub fn get_long_chunk_name(
     .iter()
     .map(|m| request_to_id(&get_long_module_name("", m, context)))
     .collect::<Vec<_>>();
-  let mut id_name_hints = chunk.id_name_hints().iter().cloned().collect::<Vec<_>>();
+  let mut id_name_hints: Vec<String> = chunk
+    .id_name_hints()
+    .iter()
+    .map(|s| s.to_string())
+    .collect();
   id_name_hints.sort_unstable();
 
   let chunk_name = {
diff --git a/crates/rspack_loader_swc/src/lib.rs b/crates/rspack_loader_swc/src/lib.rs
index 8cc252c0a33c..07d277ce69d6 100644
--- a/crates/rspack_loader_swc/src/lib.rs
+++ b/crates/rspack_loader_swc/src/lib.rs
@@ -98,12 +98,9 @@ impl SwcLoader {
 
       #[cfg(feature = "plugin")]
       {
-        swc_options.runtime_options =
-          swc_options
-            .runtime_options
-            .plugin_runtime(std::sync::Arc::new(
-              rspack_util::swc::runtime::WasmtimeRuntime,
-            ));
+        swc_options.runtime_options = swc_options
+          .runtime_options
+          .plugin_runtime(Arc::new(rspack_util::swc::runtime::WasmtimeRuntime));
       }
 
       swc_options
diff --git a/crates/rspack_plugin_asset/src/lib.rs b/crates/rspack_plugin_asset/src/lib.rs
index 9e49dd2a017c..b88b8a9a3501 100644
--- a/crates/rspack_plugin_asset/src/lib.rs
+++ b/crates/rspack_plugin_asset/src/lib.rs
@@ -870,7 +870,7 @@ async fn render_manifest(
           .with_asset_type(ManifestAssetType::Asset);
         RenderManifestEntry {
           source: source.clone(),
-          filename: asset_filename.to_owned(),
+          filename: asset_filename.clone(),
           has_filename: true,
           info: asset_info,
           auxiliary: true,
diff --git a/crates/rspack_plugin_banner/src/lib.rs b/crates/rspack_plugin_banner/src/lib.rs
index 35bf1719243e..f5fc7ecfe033 100644
--- a/crates/rspack_plugin_banner/src/lib.rs
+++ b/crates/rspack_plugin_banner/src/lib.rs
@@ -197,7 +197,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
   }
 
   for (file, comment) in updates {
-    let _res = compilation.update_asset(file.as_str(), |old, info| {
+    let _res = compilation.update_asset(file.as_ref(), |old, info| {
       let new = self.update_source(comment, old, self.config.footer);
       Ok((new, info))
     });
diff --git a/crates/rspack_plugin_circular_dependencies/src/lib.rs b/crates/rspack_plugin_circular_dependencies/src/lib.rs
index ae0bf8326690..cf8c6e809061 100644
--- a/crates/rspack_plugin_circular_dependencies/src/lib.rs
+++ b/crates/rspack_plugin_circular_dependencies/src/lib.rs
@@ -392,11 +392,11 @@ async fn optimize_modules(
       for cycle in detector.find_cycles_from(module_id) {
         if self.is_cycle_ignored(&module_map, &cycle, compilation) {
           self
-            .handle_cycle_ignored(entrypoint_name.clone(), cycle, diagnostics)
+            .handle_cycle_ignored(entrypoint_name.to_string(), cycle, diagnostics)
             .await?
         } else {
           self
-            .handle_cycle_detected(entrypoint_name.clone(), cycle, compilation, diagnostics)
+            .handle_cycle_detected(entrypoint_name.to_string(), cycle, compilation, diagnostics)
             .await?
         }
       }
diff --git a/crates/rspack_plugin_copy/src/lib.rs b/crates/rspack_plugin_copy/src/lib.rs
index 964b09b644ba..b3bcc7f9d736 100644
--- a/crates/rspack_plugin_copy/src/lib.rs
+++ b/crates/rspack_plugin_copy/src/lib.rs
@@ -42,7 +42,7 @@ pub struct Info {
 
 #[derive(Debug, Clone)]
 pub struct Related {
-  pub source_map: Option<String>,
+  pub source_map: Option<Arc<str>>,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -637,7 +637,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     let source_path = result.absolute_filename.clone();
     let dest_path = compilation.options.output.path.join(&result.filename);
 
-    if let Some(exist_asset) = compilation.assets_mut().get_mut(&result.filename) {
+    if let Some(exist_asset) = compilation.assets_mut().get_mut(result.filename.as_str()) {
       if !result.force {
         return;
       }
diff --git a/crates/rspack_plugin_css/src/plugin/impl_plugin_for_css_plugin.rs b/crates/rspack_plugin_css/src/plugin/impl_plugin_for_css_plugin.rs
index 3b95dc839f55..f5dcce147d0d 100644
--- a/crates/rspack_plugin_css/src/plugin/impl_plugin_for_css_plugin.rs
+++ b/crates/rspack_plugin_css/src/plugin/impl_plugin_for_css_plugin.rs
@@ -488,7 +488,7 @@ async fn render_manifest(
   diagnostics.extend(more_diagnostics);
   manifest.push(RenderManifestEntry {
     source: source.boxed(),
-    filename: output_path,
+    filename: Arc::from(output_path),
     has_filename: false,
     info: asset_info,
     auxiliary: false,
diff --git a/crates/rspack_plugin_devtool/src/mapped_assets_cache.rs b/crates/rspack_plugin_devtool/src/mapped_assets_cache.rs
index c7cda5a8b9d6..126c685c6e96 100644
--- a/crates/rspack_plugin_devtool/src/mapped_assets_cache.rs
+++ b/crates/rspack_plugin_devtool/src/mapped_assets_cache.rs
@@ -21,7 +21,7 @@ impl MappedAssetsCache {
     map_assets: Handle,
   ) -> Result<Vec<MappedAsset>>
   where
-    Assets: Iterator<Item = (&'a String, &'a CompilationAsset)>,
+    Assets: Iterator<Item = (&'a Arc<str>, &'a CompilationAsset)>,
     Handle: FnOnce(Vec<(String, &'a CompilationAsset)>) -> Return,
     Return: Future<Output = Result<Vec<MappedAsset>, Error>> + Send + 'a,
   {
@@ -30,14 +30,14 @@ impl MappedAssetsCache {
     let mut mapped_asstes: Vec<MappedAsset> = Vec::with_capacity(capacity);
     let mut vanilla_assets = Vec::with_capacity(capacity);
     for (filename, vanilla_asset) in assets {
-      if let Some((_, mapped_asset)) = self.0.remove(filename.as_str())
+      if let Some((_, mapped_asset)) = self.0.remove(filename.as_ref())
         && !vanilla_asset.info.version.is_empty()
         && vanilla_asset.info.version == mapped_asset.asset.1.info.version
       {
         mapped_asstes.push(mapped_asset);
         continue;
       }
-      vanilla_assets.push((filename.to_owned(), vanilla_asset));
+      vanilla_assets.push((filename.to_string(), vanilla_asset));
     }
 
     mapped_asstes.extend(map_assets(vanilla_assets).await?);
diff --git a/crates/rspack_plugin_devtool/src/source_map_dev_tool_plugin.rs b/crates/rspack_plugin_devtool/src/source_map_dev_tool_plugin.rs
index aa2770d6c527..b989bf0458f2 100644
--- a/crates/rspack_plugin_devtool/src/source_map_dev_tool_plugin.rs
+++ b/crates/rspack_plugin_devtool/src/source_map_dev_tool_plugin.rs
@@ -145,7 +145,7 @@ struct SourceMapTask {
 #[derive(Debug, Clone)]
 pub(crate) struct MappedAsset {
   pub(crate) asset: (Arc<str>, CompilationAsset),
-  pub(crate) source_map: Option<(String, CompilationAsset)>,
+  pub(crate) source_map: Option<(Arc<str>, CompilationAsset)>,
 }
 
 type TaskAndSourceNames = (
@@ -779,9 +779,10 @@ impl SourceMapDevToolPlugin {
           .content_hash_optional(content_hash_digest.as_ref().map(|digest| digest.encoded())),
         None => data,
       };
-      let source_map_filename = compilation
+      let source_map_filename: Arc<str> = compilation
         .get_asset_path(source_map_filename_config, data)
-        .await?;
+        .await?
+        .into();
 
       if let Some(current_source_mapping_url_comment) = current_source_mapping_url_comment {
         let source_map_url = if let Some(public_path) = &plugin.public_path {
@@ -793,7 +794,7 @@ impl SourceMapDevToolPlugin {
 
           let mut source_map_path = PathBuf::new();
           source_map_path.push(Component::RootDir);
-          source_map_path.extend(Path::new(&source_map_filename).components());
+          source_map_path.extend(Path::new(source_map_filename.as_ref()).components());
 
           source_map_path
             .relative(
@@ -890,7 +891,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
   // use to read
   let mut file_to_chunk: HashMap<&str, &Chunk> = HashMap::default();
   // use to write
-  let mut file_to_chunk_ukey: HashMap<String, ChunkUkey> = HashMap::default();
+  let mut file_to_chunk_ukey: HashMap<Arc<str>, ChunkUkey> = HashMap::default();
   for chunk in compilation
     .build_chunk_graph_artifact
     .chunk_by_ukey
@@ -944,7 +945,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     }
 
     let chunk_ukey = file_to_chunk_ukey.get(source_filename.as_ref());
-    compilation.emit_asset(source_filename.to_string(), source_asset);
+    compilation.emit_asset(source_filename.clone(), source_asset);
     if let Some((source_map_filename, source_map_asset)) = source_map {
       compilation.emit_asset(source_map_filename.clone(), source_map_asset);
 
diff --git a/crates/rspack_plugin_dll/src/dll_entry/dll_entry_dependency.rs b/crates/rspack_plugin_dll/src/dll_entry/dll_entry_dependency.rs
index e950c2057d77..2cd76c9d36c7 100644
--- a/crates/rspack_plugin_dll/src/dll_entry/dll_entry_dependency.rs
+++ b/crates/rspack_plugin_dll/src/dll_entry/dll_entry_dependency.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AffectType, AsContextDependency, AsDependencyCodeGeneration, Context, Dependency, DependencyId,
@@ -14,7 +16,7 @@ pub struct DllEntryDependency {
   pub entries: Vec<String>,
 
   // TODO: The fields `name` for serialize & deserialize.
-  pub name: String,
+  pub name: Arc<str>,
 
   id: DependencyId,
 
diff --git a/crates/rspack_plugin_dll/src/dll_entry/dll_entry_plugin.rs b/crates/rspack_plugin_dll/src/dll_entry/dll_entry_plugin.rs
index a7eec5071b73..50de26259f50 100644
--- a/crates/rspack_plugin_dll/src/dll_entry/dll_entry_plugin.rs
+++ b/crates/rspack_plugin_dll/src/dll_entry/dll_entry_plugin.rs
@@ -11,7 +11,7 @@ use super::{dll_entry_dependency::DllEntryDependency, dll_module_factory};
 
 #[derive(Debug, Clone, Default)]
 pub struct DllEntryPluginOptions {
-  pub name: String,
+  pub name: Arc<str>,
 
   pub context: Context,
 
diff --git a/crates/rspack_plugin_dll/src/dll_entry/dll_module.rs b/crates/rspack_plugin_dll/src/dll_entry/dll_module.rs
index 6fb81b254028..6664a129ad31 100644
--- a/crates/rspack_plugin_dll/src/dll_entry/dll_module.rs
+++ b/crates/rspack_plugin_dll/src/dll_entry/dll_module.rs
@@ -21,7 +21,7 @@ use super::dll_entry_dependency::DllEntryDependency;
 #[derive(Debug, Default)]
 pub struct DllModule {
   // TODO: it should be set to EntryDependency.loc
-  name: String,
+  name: Arc<str>,
 
   factory_meta: Option<FactoryMeta>,
 
diff --git a/crates/rspack_plugin_esm_library/src/optimize_chunks.rs b/crates/rspack_plugin_esm_library/src/optimize_chunks.rs
index a8a99a7a679c..9da310bda139 100644
--- a/crates/rspack_plugin_esm_library/src/optimize_chunks.rs
+++ b/crates/rspack_plugin_esm_library/src/optimize_chunks.rs
@@ -510,7 +510,7 @@ pub(crate) fn assign_dyn_import_chunk_short_names(compilation: &mut Compilation)
   // Collect all existing named chunks
   let mut used_names: FxHashMap<String, usize> = FxHashMap::default();
   for name in compilation.build_chunk_graph_artifact.named_chunks.keys() {
-    used_names.insert(name.clone(), 1);
+    used_names.insert(name.to_string(), 1);
   }
 
   // Collect candidates: (chunk_ukey, root_module_identifier) for unnamed non-initial chunks
@@ -601,14 +601,15 @@ pub(crate) fn assign_dyn_import_chunk_short_names(compilation: &mut Compilation)
 
   // Apply assignments
   for (chunk_ukey, name) in assignments {
+    let name_key: Arc<str> = Arc::from(name);
     let chunk = compilation
       .build_chunk_graph_artifact
       .chunk_by_ukey
       .expect_get_mut(&chunk_ukey);
-    chunk.set_name(Some(name.clone()));
+    chunk.set_name(Some(name_key.as_ref()));
     compilation
       .build_chunk_graph_artifact
       .named_chunks
-      .insert(name, chunk_ukey);
+      .insert(name_key, chunk_ukey);
   }
 }
diff --git a/crates/rspack_plugin_esm_library/src/plugin.rs b/crates/rspack_plugin_esm_library/src/plugin.rs
index 23ecfe9e3a84..570d230c312b 100644
--- a/crates/rspack_plugin_esm_library/src/plugin.rs
+++ b/crates/rspack_plugin_esm_library/src/plugin.rs
@@ -593,7 +593,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
 
       let mut replace_source = ReplaceSource::new(source.clone());
       let output_path = compilation.options.output.path.as_std_path();
-      let mut self_path = output_path.join(asset_name);
+      let mut self_path = output_path.join(asset_name.as_ref());
 
       // only use the path, pop filename
       self_path.pop();
@@ -626,7 +626,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           .iter()
           .filter(|f| {
             // find ref asset info
-            let Some(asset) = compilation.assets().get(*f) else {
+            let Some(asset) = compilation.assets().get(f.as_ref()) else {
               return false;
             };
             asset.get_info().javascript_module.unwrap_or_default()
@@ -644,7 +644,8 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
             chunk_id
           ));
         }
-        let chunk_path = output_path.join(js_files.first().expect("have at least one file"));
+        let chunk_path =
+          output_path.join(js_files.first().expect("have at least one file").as_ref());
         let relative = chunk_path.relative(self_path.as_path());
         let relative = relative
           .to_slash()
diff --git a/crates/rspack_plugin_esm_library/src/preserve_modules.rs b/crates/rspack_plugin_esm_library/src/preserve_modules.rs
index 410844caa35d..be8c73fec9b2 100644
--- a/crates/rspack_plugin_esm_library/src/preserve_modules.rs
+++ b/crates/rspack_plugin_esm_library/src/preserve_modules.rs
@@ -1,4 +1,8 @@
-use std::{borrow::Cow, path::Path, sync::LazyLock};
+use std::{
+  borrow::Cow,
+  path::Path,
+  sync::{Arc, LazyLock},
+};
 
 use regex::Regex;
 use rspack_collections::{IdentifierMap, IdentifierSet};
@@ -18,7 +22,7 @@ pub fn entry_modules(compilation: &Compilation) -> FxHashMap<String, IdentifierS
     .iter()
     .map(|(name, item)| {
       (
-        name.clone(),
+        name.to_string(),
         item
           .all_dependencies()
           .chain(compilation.global_entry.all_dependencies())
@@ -214,16 +218,17 @@ pub async fn preserve_modules(
           .chunk_by_ukey
           .expect_get_mut(&chunk);
         if let Some(name) = old_chunk.name().map(|s| s.to_string()) {
-          old_chunk.set_name(None);
+          old_chunk.set_name(None::<&str>);
           let new_chunk = compilation
             .build_chunk_graph_artifact
             .chunk_by_ukey
             .expect_get_mut(&new_chunk_ukey);
-          new_chunk.set_name(Some(name.clone()));
+          let name_key: Arc<str> = Arc::from(name);
+          new_chunk.set_name(Some(name_key.as_ref()));
           compilation
             .build_chunk_graph_artifact
             .named_chunks
-            .insert(name, new_chunk_ukey);
+            .insert(name_key, new_chunk_ukey);
         }
       }
     }
diff --git a/crates/rspack_plugin_extract_css/src/plugin.rs b/crates/rspack_plugin_extract_css/src/plugin.rs
index 61643d1e32cf..1c1b896533ca 100644
--- a/crates/rspack_plugin_extract_css/src/plugin.rs
+++ b/crates/rspack_plugin_extract_css/src/plugin.rs
@@ -287,7 +287,7 @@ impl PluginCssExtract {
                         .chunk_group_by_ukey
                         .expect_get(cg);
 
-                      chunk_group.name()
+                      chunk_group.name().map(|s| s.as_ref())
                     })
                     .collect::<Vec<_>>()
                     .join(",")
@@ -302,6 +302,7 @@ impl PluginCssExtract {
                         .chunk_group_by_ukey
                         .expect_get(cg)
                         .name()
+                        .map(|s| s.as_ref())
                     })
                     .collect::<Vec<_>>()
                     .join(", ")
@@ -706,7 +707,7 @@ async fn render_manifest(
   diagnostics.extend(more_diagnostics);
   manifest.push(RenderManifestEntry {
     source,
-    filename,
+    filename: Arc::from(filename),
     has_filename: false,
     info: asset_info,
     auxiliary: false,
diff --git a/crates/rspack_plugin_hmr/src/lib.rs b/crates/rspack_plugin_hmr/src/lib.rs
index 8424f0744cf1..4251b9cd6acd 100644
--- a/crates/rspack_plugin_hmr/src/lib.rs
+++ b/crates/rspack_plugin_hmr/src/lib.rs
@@ -1,6 +1,6 @@
 mod hot_module_replacement;
 
-use std::collections::hash_map;
+use std::{collections::hash_map, sync::Arc};
 
 use hot_module_replacement::HotModuleReplacementRuntimeModule;
 use rspack_collections::IdentifierSet;
@@ -84,7 +84,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
   }
 
   let mut updated_runtime_modules: IdentifierSet = Default::default();
-  let mut updated_chunks: HashMap<ChunkUkey, HashSet<String>> = Default::default();
+  let mut updated_chunks: HashMap<ChunkUkey, HashSet<Arc<str>>> = Default::default();
   for (identifier, old_runtime_module_hash) in &old_runtime_modules {
     if let Some(new_runtime_module_hash) = compilation.runtime_modules_hash.get(identifier) {
       // updated
@@ -215,7 +215,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     }
 
     if !new_modules.is_empty() || !new_runtime_modules.is_empty() {
-      let mut hot_update_chunk = Chunk::new(None, ChunkKind::HotUpdate);
+      let mut hot_update_chunk = Chunk::new(None::<&str>, ChunkKind::HotUpdate);
       hot_update_chunk.set_id(chunk_id.clone());
       hot_update_chunk.set_runtime(if let Some(current_chunk) = current_chunk {
         current_chunk.runtime().clone()
@@ -301,7 +301,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       compilation.extend_diagnostics(diagnostics);
 
       for entry in manifest {
-        let filename = if entry.has_filename {
+        let filename: Arc<str> = if entry.has_filename {
           entry.filename.clone()
         } else {
           compilation
@@ -317,6 +317,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
                 ),
             )
             .await?
+            .into()
         };
         let asset = CompilationAsset::new(
           Some(entry.source),
@@ -332,7 +333,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
             .or_default()
             .insert(filename.clone());
         }
-        compilation.emit_asset(filename, asset);
+        compilation.emit_asset(filename.clone(), asset);
       }
 
       new_runtime.iter().for_each(|runtime| {
diff --git a/crates/rspack_plugin_html/src/asset.rs b/crates/rspack_plugin_html/src/asset.rs
index 133ab56fe85d..f4dcc8b394ea 100644
--- a/crates/rspack_plugin_html/src/asset.rs
+++ b/crates/rspack_plugin_html/src/asset.rs
@@ -3,6 +3,7 @@ use std::{
   env,
   hash::Hasher,
   path::{Path, PathBuf},
+  sync::Arc,
 };
 
 use anyhow::{Context, anyhow};
@@ -49,43 +50,53 @@ impl HtmlPluginAssets {
     let mut asset_map = FxHashMap::default();
     assets.public_path = public_path.to_string();
 
-    let sorted_entry_names: Vec<&String> =
+    let sorted_entry_names: Vec<Arc<str>> =
       if matches!(config.chunks_sort_mode, HtmlChunkSortMode::Manual)
         && let Some(chunks) = &config.chunks
       {
         chunks
           .iter()
-          .filter(|&name| {
+          .filter(|name| {
             compilation
               .build_chunk_graph_artifact
               .entrypoints
-              .contains_key(name)
+              .contains_key(name.as_str())
           })
+          .map(|name| Arc::from(name.clone()))
           .collect()
       } else {
         compilation
           .build_chunk_graph_artifact
           .entrypoints
           .keys()
-          .filter(|&entry_name| {
+          .filter(|entry_name| {
             let mut included = true;
             if let Some(included_chunks) = &config.chunks {
-              included = included_chunks.iter().any(|c| c.eq(entry_name));
+              included = included_chunks
+                .iter()
+                .any(|c| c.as_str() == entry_name.as_ref());
             }
             if let Some(exclude_chunks) = &config.exclude_chunks {
-              included = included && !exclude_chunks.iter().any(|c| c.eq(entry_name));
+              included = included
+                && !exclude_chunks
+                  .iter()
+                  .any(|c| c.as_str() == entry_name.as_ref());
             }
             included
           })
+          .cloned()
           .collect()
       };
 
     let included_assets = sorted_entry_names
       .iter()
-      .map(|entry_name| compilation.entrypoint_by_name(entry_name))
+      .map(|entry_name| compilation.entrypoint_by_name(entry_name.as_ref()))
       .flat_map(|entry| entry.get_files(&compilation.build_chunk_graph_artifact.chunk_by_ukey))
       .filter_map(|asset_name| {
-        let asset = compilation.assets().get(&asset_name).expect("TODO:");
+        let asset = compilation
+          .assets()
+          .get(asset_name.as_ref())
+          .expect("TODO:");
         if asset.info.hot_module_replacement.unwrap_or(false)
           || asset.info.development.unwrap_or(false)
         {
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs
index 906a78a095c0..5944543f0437 100644
--- a/crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs
+++ b/crates/rspack_plugin_javascript/src/parser_plugin/import_parser_plugin.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, sync::Arc};
 
 use rspack_core::{
   AsyncDependenciesBlock, ChunkGroupOptions, ContextDependency, ContextNameSpaceObject,
@@ -406,7 +406,7 @@ impl JavascriptParserPlugin for ImportParserPlugin {
           Some(param.string().clone()),
         );
         block.set_group_options(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-          chunk_name,
+          chunk_name.map(Arc::from),
           chunk_preload,
           chunk_prefetch,
           fetch_priority,
@@ -450,7 +450,7 @@ impl JavascriptParserPlugin for ImportParserPlugin {
             ContextNameSpaceObject::Bool(true)
           },
           group_options: Some(GroupOptions::ChunkGroup(ChunkGroupOptions::new(
-            chunk_name,
+            chunk_name.map(Arc::from),
             chunk_preload,
             chunk_prefetch,
             fetch_priority,
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/require_ensure_dependencies_block_parse_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/require_ensure_dependencies_block_parse_plugin.rs
index 6c62c87cefd5..06274f7719a4 100644
--- a/crates/rspack_plugin_javascript/src/parser_plugin/require_ensure_dependencies_block_parse_plugin.rs
+++ b/crates/rspack_plugin_javascript/src/parser_plugin/require_ensure_dependencies_block_parse_plugin.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, sync::Arc};
 
 use either::Either;
 use rspack_core::{
@@ -140,7 +140,7 @@ impl JavascriptParserPlugin for RequireEnsureDependenciesBlockParserPlugin {
     let loc = parser.to_dependency_location(range);
     let mut block = AsyncDependenciesBlock::new(*parser.module_identifier, loc, None, deps, None);
     block.set_group_options(GroupOptions::ChunkGroup(
-      ChunkGroupOptions::default().name_optional(chunk_name),
+      ChunkGroupOptions::default().name_optional(chunk_name.map(Arc::from)),
     ));
     parser.add_block(Box::new(block));
 
diff --git a/crates/rspack_plugin_javascript/src/parser_plugin/worker_plugin.rs b/crates/rspack_plugin_javascript/src/parser_plugin/worker_plugin.rs
index 8bfc27fb4b95..53c2a3c0be48 100644
--- a/crates/rspack_plugin_javascript/src/parser_plugin/worker_plugin.rs
+++ b/crates/rspack_plugin_javascript/src/parser_plugin/worker_plugin.rs
@@ -1,4 +1,4 @@
-use std::hash::Hash;
+use std::{hash::Hash, sync::Arc};
 
 use itertools::Itertools;
 use rspack_core::{
@@ -105,7 +105,7 @@ fn add_dependencies(
   let mut block =
     AsyncDependenciesBlock::new(*parser.module_identifier, loc, None, vec![dep], None);
   block.set_group_options(GroupOptions::Entrypoint(Box::new(EntryOptions {
-    name,
+    name: name.map(Arc::from),
     runtime: Some(runtime.into()),
     chunk_loading: Some(output_options.worker_chunk_loading.clone()),
     wasm_loading: Some(output_options.worker_wasm_loading.clone()),
diff --git a/crates/rspack_plugin_javascript/src/plugin/impl_plugin_for_js_plugin.rs b/crates/rspack_plugin_javascript/src/plugin/impl_plugin_for_js_plugin.rs
index b2ef2ee7c714..dd85096f83a9 100644
--- a/crates/rspack_plugin_javascript/src/plugin/impl_plugin_for_js_plugin.rs
+++ b/crates/rspack_plugin_javascript/src/plugin/impl_plugin_for_js_plugin.rs
@@ -609,7 +609,7 @@ async fn render_manifest(
 
   manifest.push(RenderManifestEntry {
     source,
-    filename: output_path,
+    filename: Arc::from(output_path),
     has_filename: false,
     info: asset_info,
     auxiliary: false,
diff --git a/crates/rspack_plugin_lightning_css_minimizer/src/lib.rs b/crates/rspack_plugin_lightning_css_minimizer/src/lib.rs
index 0d1c46303b55..292d0efa0608 100644
--- a/crates/rspack_plugin_lightning_css_minimizer/src/lib.rs
+++ b/crates/rspack_plugin_lightning_css_minimizer/src/lib.rs
@@ -137,11 +137,11 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     .assets_mut()
     .par_iter_mut()
     .filter(|(filename, original)| {
-      if !CSS_ASSET_REGEXP.is_match(filename) {
+      if !CSS_ASSET_REGEXP.is_match(filename.as_ref()) {
         return false;
       }
 
-      let is_matched = match_object(&condition_object, filename);
+      let is_matched = match_object(&condition_object, filename.as_ref());
 
       if !is_matched || original.get_info().minimized.unwrap_or(false) {
         return false;
@@ -174,7 +174,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           .map(|input_source_map| -> Result<_> {
             let mut sm =
               parcel_sourcemap::SourceMap::new(input_source_map.source_root().unwrap_or("/"));
-            sm.add_source(filename);
+            sm.add_source(filename.as_ref());
             sm.set_source_content(0, &input).to_rspack_result()?;
             Ok(sm)
           })
@@ -184,7 +184,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
           let mut stylesheet = StyleSheet::parse(
             &input,
             ParserOptions {
-              filename: filename.clone(),
+              filename: filename.to_string(),
               css_modules: None,
               source_index: 0,
               error_recovery: minimizer_options.error_recovery,
@@ -261,7 +261,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         let minimized_source = if let Some(mut source_map) = source_map {
           SourceMapSource::new(SourceMapSourceOptions {
             value: result.code,
-            name: filename,
+            name: filename.to_string(),
             source_map: SourceMap::from_json(
               &source_map
                 .to_json(None)
diff --git a/crates/rspack_plugin_mf/src/container/container_entry_dependency.rs b/crates/rspack_plugin_mf/src/container/container_entry_dependency.rs
index 4b29099cbcd1..2ef61f65956e 100644
--- a/crates/rspack_plugin_mf/src/container/container_entry_dependency.rs
+++ b/crates/rspack_plugin_mf/src/container/container_entry_dependency.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use rspack_cacheable::{cacheable, cacheable_dyn};
 use rspack_core::{
   AsContextDependency, AsDependencyCodeGeneration, Dependency, DependencyCategory, DependencyId,
@@ -10,7 +12,7 @@ use crate::{ExposeOptions, ShareScope};
 #[derive(Debug, Clone)]
 pub struct ContainerEntryDependency {
   id: DependencyId,
-  pub name: String,
+  pub name: Arc<str>,
   pub exposes: Vec<(String, ExposeOptions)>,
   pub share_scope: ShareScope,
   pub request: Option<String>,
@@ -23,7 +25,7 @@ pub struct ContainerEntryDependency {
 
 impl ContainerEntryDependency {
   pub fn new(
-    name: String,
+    name: Arc<str>,
     exposes: Vec<(String, ExposeOptions)>,
     share_scope: ShareScope,
     enhanced: bool,
@@ -43,7 +45,7 @@ impl ContainerEntryDependency {
     }
   }
 
-  pub fn new_share_container_entry(name: String, request: String, version: String) -> Self {
+  pub fn new_share_container_entry(name: Arc<str>, request: String, version: String) -> Self {
     let resource_identifier = format!("share-container-entry-{}", &name).into();
     Self {
       id: DependencyId::new(),
diff --git a/crates/rspack_plugin_mf/src/container/container_entry_module.rs b/crates/rspack_plugin_mf/src/container/container_entry_module.rs
index afad80b50fa3..76cb30e3328f 100644
--- a/crates/rspack_plugin_mf/src/container/container_entry_module.rs
+++ b/crates/rspack_plugin_mf/src/container/container_entry_module.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use std::{borrow::Cow, sync::Arc};
 
 use async_trait::async_trait;
 use rspack_cacheable::{cacheable, cacheable_dyn};
@@ -40,12 +40,12 @@ pub struct ContainerEntryModule {
   request: Option<String>,
   version: Option<String>,
   dependency_type: DependencyType,
-  name: String,
+  name: Arc<str>,
 }
 
 impl ContainerEntryModule {
   pub fn new(
-    name: String,
+    name: Arc<str>,
     exposes: Vec<(String, ExposeOptions)>,
     share_scope: ShareScope,
     enhanced: bool,
@@ -81,7 +81,7 @@ impl ContainerEntryModule {
     }
   }
 
-  pub fn new_share_container_entry(name: String, request: String, version: String) -> Self {
+  pub fn new_share_container_entry(name: Arc<str>, request: String, version: String) -> Self {
     let lib_ident = format!("webpack/share/container/{}", &name);
     Self {
       blocks: Vec::new(),
@@ -221,7 +221,7 @@ impl Module for ContainerEntryModule {
           None,
         );
         block.set_group_options(GroupOptions::ChunkGroup(
-          ChunkGroupOptions::default().name_optional(options.name.clone()),
+          ChunkGroupOptions::default().name_optional(options.name.clone().map(Into::into)),
         ));
         blocks.push(Box::new(block));
       }
diff --git a/crates/rspack_plugin_mf/src/container/container_plugin.rs b/crates/rspack_plugin_mf/src/container/container_plugin.rs
index 0c0570ef0ac9..08e222918c18 100644
--- a/crates/rspack_plugin_mf/src/container/container_plugin.rs
+++ b/crates/rspack_plugin_mf/src/container/container_plugin.rs
@@ -19,7 +19,7 @@ use crate::ShareScope;
 
 #[derive(Debug)]
 pub struct ContainerPluginOptions {
-  pub name: String,
+  pub name: Arc<str>,
   pub share_scope: ShareScope,
   pub library: LibraryOptions,
   pub runtime: Option<EntryRuntime>,
@@ -115,7 +115,7 @@ async fn additional_tree_runtime_requirements(
   else {
     return Ok(());
   };
-  if matches!(&entry_options.name, Some(name) if name == &self.options.name)
+  if matches!(&entry_options.name, Some(name) if name.as_ref() == self.options.name.as_ref())
     && compilation
       .build_chunk_graph_artifact
       .chunk_graph
diff --git a/crates/rspack_plugin_mf/src/manifest/asset.rs b/crates/rspack_plugin_mf/src/manifest/asset.rs
index 98e7b1a637d8..3d4f98d25363 100644
--- a/crates/rspack_plugin_mf/src/manifest/asset.rs
+++ b/crates/rspack_plugin_mf/src/manifest/asset.rs
@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
 use rspack_core::{BoxModule, Compilation, ModuleGraph, ModuleIdentifier, NormalModule};
 use rspack_util::fx_hash::FxHashSet as HashSet;
@@ -13,10 +13,10 @@ pub fn collect_assets_from_chunk(
   chunk_key: &rspack_core::ChunkUkey,
   entry_point_names: &HashSet<String>,
 ) -> StatsAssetsGroup {
-  let mut js_sync = HashSet::<String>::default();
-  let mut js_async = HashSet::<String>::default();
-  let mut css_sync = HashSet::<String>::default();
-  let mut css_async = HashSet::<String>::default();
+  let mut js_sync = HashSet::<Arc<str>>::default();
+  let mut js_async = HashSet::<Arc<str>>::default();
+  let mut css_sync = HashSet::<Arc<str>>::default();
+  let mut css_async = HashSet::<Arc<str>>::default();
   let Some(chunk) = compilation
     .build_chunk_graph_artifact
     .chunk_by_ukey
@@ -40,7 +40,7 @@ pub fn collect_assets_from_chunk(
       .expect_get(cg);
     let skip = group
       .name()
-      .is_some_and(|name| entry_point_names.contains(name));
+      .is_some_and(|name| entry_point_names.contains(name.as_ref()));
     if !skip {
       for chunk_ukey in &group.chunks {
         let group_chunk = compilation
@@ -86,7 +86,7 @@ pub fn collect_assets_from_chunk(
         .expect_get(cg);
       let skip = group
         .name()
-        .is_some_and(|name| entry_point_names.contains(name));
+        .is_some_and(|name| entry_point_names.contains(name.as_ref()));
       if !skip {
         for file in group.get_files(&compilation.build_chunk_graph_artifact.chunk_by_ukey) {
           if file.ends_with(".css") {
@@ -176,8 +176,8 @@ pub fn collect_usage_files_for_module(
       continue;
     }
     if let Some(assets) = collect_assets_for_module(compilation, &origin, entry_point_names) {
-      files.extend(assets.js.sync);
-      files.extend(assets.js.r#async);
+      files.extend(assets.js.sync.iter().map(|s| s.as_ref().to_string()));
+      files.extend(assets.js.r#async.iter().map(|s| s.as_ref().to_string()));
     } else if let Some(origin_module) = module_graph.module_by_identifier(&origin) {
       files.insert(origin_module.identifier().to_string());
     }
diff --git a/crates/rspack_plugin_mf/src/manifest/data.rs b/crates/rspack_plugin_mf/src/manifest/data.rs
index 8d60ba3e58ab..4978b440afa5 100644
--- a/crates/rspack_plugin_mf/src/manifest/data.rs
+++ b/crates/rspack_plugin_mf/src/manifest/data.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
@@ -11,9 +13,9 @@ pub struct StatsAssetsGroup {
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct AssetsSplit {
   #[serde(default)]
-  pub sync: Vec<String>,
+  pub sync: Vec<Arc<str>>,
   #[serde(default)]
-  pub r#async: Vec<String>,
+  pub r#async: Vec<Arc<str>>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
diff --git a/crates/rspack_plugin_mf/src/manifest/mod.rs b/crates/rspack_plugin_mf/src/manifest/mod.rs
index 0f3aabd21c8e..2403aa591d47 100644
--- a/crates/rspack_plugin_mf/src/manifest/mod.rs
+++ b/crates/rspack_plugin_mf/src/manifest/mod.rs
@@ -5,7 +5,7 @@ mod data;
 mod options;
 mod utils;
 
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
 use asset::{
   collect_assets_for_module, collect_assets_from_chunk, collect_usage_files_for_module,
@@ -66,7 +66,7 @@ fn get_remote_entry_name(compilation: &Compilation, container_name: &str) -> Opt
       .files()
       .iter()
       .find(|file| !file.ends_with(".css") && !is_hot_file(file))
-      .cloned()
+      .map(|s| s.to_string())
   };
 
   // Prefer the actual entry chunk if it exists.
@@ -103,7 +103,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
     .build_chunk_graph_artifact
     .entrypoints
     .keys()
-    .cloned()
+    .map(|s| s.to_string())
     .collect();
 
   // Build metaData
@@ -437,7 +437,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
               .chunk_group_by_ukey
               .expect_get(group_ukey);
             if let Some(name) = group.name()
-              && !entry_point_names.contains(name)
+              && !entry_point_names.contains(name.as_ref())
             {
               for extra_chunk in group.chunks.iter() {
                 entry.insert(*extra_chunk);
@@ -460,7 +460,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
       }
     }
 
-    let mut shared_asset_files: HashSet<String> = HashSet::default();
+    let mut shared_asset_files: HashSet<Arc<str>> = HashSet::default();
     for (pkg, mut assets) in aggregated_shared_assets {
       normalize_assets_group(&mut assets);
       assets.js.r#async.clear();
@@ -478,7 +478,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         && let Some(chunk_key) = compilation
           .build_chunk_graph_artifact
           .named_chunks
-          .get(chunk_name)
+          .get::<str>(chunk_name.as_ref())
       {
         assets = Some(collect_assets_from_chunk(
           compilation,
@@ -490,7 +490,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
         && let Some(chunk_key) = compilation
           .build_chunk_graph_artifact
           .named_chunks
-          .get(expose_file_key)
+          .get::<str>(expose_file_key.as_str())
       {
         assets = Some(collect_assets_from_chunk(
           compilation,
diff --git a/crates/rspack_plugin_mf/src/manifest/utils.rs b/crates/rspack_plugin_mf/src/manifest/utils.rs
index cbd3b2133729..f4f7cf017207 100644
--- a/crates/rspack_plugin_mf/src/manifest/utils.rs
+++ b/crates/rspack_plugin_mf/src/manifest/utils.rs
@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{path::Path, sync::Arc};
 
 use rspack_core::{Compilation, ModuleGraph, ModuleIdentifier};
 use rspack_util::fx_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
@@ -37,7 +37,7 @@ pub fn ensure_configured_remotes(
 pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> HashSet<String> {
   let mut entry_files = HashSet::default();
   for (name, entrypoint_ukey) in &compilation.build_chunk_graph_artifact.entrypoints {
-    if name == container_name {
+    if name.as_ref() == container_name {
       continue;
     }
     let entrypoint = compilation
@@ -51,7 +51,7 @@ pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> H
         .get(chunk_ukey)
       {
         for file in chunk.files() {
-          entry_files.insert(file.clone());
+          entry_files.insert(file.to_string());
         }
         for async_chunk_ukey in
           chunk.get_all_async_chunks(&compilation.build_chunk_graph_artifact.chunk_group_by_ukey)
@@ -63,13 +63,13 @@ pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> H
           {
             let mut should_filter = false;
             if let Some(chunk_name) = async_chunk.name()
-              && chunk_name.contains(name)
+              && chunk_name.contains(name.as_ref())
             {
               should_filter = true;
             }
             if !should_filter {
               for file in async_chunk.files() {
-                if file.contains(name) {
+                if file.contains(name.as_ref()) {
                   should_filter = true;
                   break;
                 }
@@ -77,7 +77,7 @@ pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> H
             }
             if should_filter {
               for file in async_chunk.files() {
-                entry_files.insert(file.clone());
+                entry_files.insert(file.to_string());
               }
             }
           }
@@ -92,7 +92,7 @@ pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> H
       .get(&runtime_chunk_ukey)
     {
       for file in chunk.files() {
-        entry_files.insert(file.clone());
+        entry_files.insert(file.to_string());
       }
     }
   }
@@ -102,11 +102,11 @@ pub fn collect_entry_files(compilation: &Compilation, container_name: &str) -> H
 pub fn filter_assets(
   assets: &mut StatsAssetsGroup,
   entry_files: &HashSet<String>,
-  shared_asset_files: &HashSet<String>,
+  shared_asset_files: &HashSet<Arc<str>>,
   remove_shared: bool,
 ) {
   let filter_fn =
-    |asset: &String| !entry_files.contains(asset) || shared_asset_files.contains(asset);
+    |asset: &Arc<str>| !entry_files.contains(asset.as_ref()) || shared_asset_files.contains(asset);
 
   assets.js.sync.retain(filter_fn);
   assets.js.r#async.retain(filter_fn);
@@ -114,7 +114,7 @@ pub fn filter_assets(
   assets.css.r#async.retain(filter_fn);
 
   if remove_shared {
-    let filter_shared = |asset: &String| !shared_asset_files.contains(asset);
+    let filter_shared = |asset: &Arc<str>| !shared_asset_files.contains(asset);
     assets.js.sync.retain(filter_shared);
     assets.js.r#async.retain(filter_shared);
     assets.css.sync.retain(filter_shared);
diff --git a/crates/rspack_plugin_mf/src/sharing/shared_container_plugin.rs b/crates/rspack_plugin_mf/src/sharing/shared_container_plugin.rs
index a76ca6bbd8d4..18b7bbc49f90 100644
--- a/crates/rspack_plugin_mf/src/sharing/shared_container_plugin.rs
+++ b/crates/rspack_plugin_mf/src/sharing/shared_container_plugin.rs
@@ -18,7 +18,7 @@ use crate::{
 
 #[derive(Debug)]
 pub struct SharedContainerPluginOptions {
-  pub name: String,
+  pub name: Arc<str>,
   pub request: String,
   pub version: String,
   pub file_name: Option<Filename>,
@@ -89,7 +89,7 @@ async fn additional_tree_runtime_requirements(
     .chunk_by_ukey
     .expect_get(chunk_ukey);
   if let Some(name) = chunk.name()
-    && name == self.options.name
+    && name == self.options.name.as_ref()
   {
     runtime_modules.push(ShareContainerRuntimeModule::new(&compilation.runtime_template).boxed());
   }
diff --git a/crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_plugin.rs b/crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_plugin.rs
index bb83628f2497..fbe1628328e1 100644
--- a/crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_plugin.rs
+++ b/crates/rspack_plugin_mf/src/sharing/shared_used_exports_optimizer_plugin.rs
@@ -319,7 +319,7 @@ async fn process_assets(&self, compilation: &mut Compilation) -> Result<()> {
   ];
   for file_name in file_names {
     if let Some(file_name) = &file_name
-      && let Some(file) = compilation.assets().get(file_name)
+      && let Some(file) = compilation.assets().get(file_name.as_str())
       && let Some(source) = file.get_source()
       && let SourceValue::String(content) = source.source()
       && let Ok(mut stats_root) = serde_json::from_str::<StatsRoot>(&content)
diff --git a/crates/rspack_plugin_module_replacement/src/context_replacement.rs b/crates/rspack_plugin_module_replacement/src/context_replacement.rs
index 39178d658fce..2ee1d9ccc9da 100644
--- a/crates/rspack_plugin_module_replacement/src/context_replacement.rs
+++ b/crates/rspack_plugin_module_replacement/src/context_replacement.rs
@@ -16,7 +16,7 @@ pub struct ContextReplacementPluginOptions {
   pub new_content_resource: Option<String>,
   pub new_content_recursive: Option<bool>,
   pub new_content_reg_exp: Option<RspackRegex>,
-  pub new_content_create_context_map: Option<HashMap<String, String>>,
+  pub new_content_create_context_map: Option<HashMap<Arc<str>, String>>,
 }
 
 #[plugin]
@@ -26,7 +26,7 @@ pub struct ContextReplacementPlugin {
   new_content_resource: Option<String>,
   new_content_recursive: Option<bool>,
   new_content_reg_exp: Option<RspackRegex>,
-  new_content_create_context_map: Option<HashMap<String, String>>,
+  new_content_create_context_map: Option<HashMap<Arc<str>, String>>,
 }
 
 impl ContextReplacementPlugin {
@@ -97,9 +97,7 @@ async fn cmf_after_resolve(&self, mut result: AfterResolveResult) -> Result<Afte
             .map(|(key, value)| {
               let request = format!(
                 "{}{}{}",
-                value,
-                options.resource_query.clone(),
-                options.resource_fragment.clone(),
+                value, &options.resource_query, &options.resource_fragment,
               );
 
               let resource_identifier = ContextElementDependency::create_resource_identifier(
@@ -109,7 +107,7 @@ async fn cmf_after_resolve(&self, mut result: AfterResolveResult) -> Result<Afte
               );
               ContextElementDependency {
                 id: DependencyId::new(),
-                request,
+                request: Arc::from(request),
                 user_request: key.clone(),
                 category: options.context_options.category,
                 context: options.resource.clone().into(),
diff --git a/crates/rspack_plugin_real_content_hash/src/lib.rs b/crates/rspack_plugin_real_content_hash/src/lib.rs
index 69845697046a..5984d5bc335b 100644
--- a/crates/rspack_plugin_real_content_hash/src/lib.rs
+++ b/crates/rspack_plugin_real_content_hash/src/lib.rs
@@ -110,13 +110,13 @@ async fn inner_impl(compilation: &mut Compilation) -> Result<()> {
   logger.time_end(start);
 
   let start = logger.time("create ordered hashes");
-  let assets_data: HashMap<&str, AssetData> = compilation
+  let assets_data: HashMap<Arc<str>, AssetData> = compilation
     .assets()
     .par_iter()
     .filter_map(|(name, asset)| {
       asset.get_source().map(|source| {
         (
-          name.as_str(),
+          name.clone(),
           AssetData::new(source.clone(), asset.get_info(), &hash_ac),
         )
       })
@@ -164,7 +164,7 @@ async fn inner_impl(compilation: &mut Compilation) -> Result<()> {
         let tasks = assets_names
           .iter()
           .filter_map(|name| {
-            let data = assets_data.get(name)?;
+            let data = assets_data.get(*name)?;
             Some((hash.as_str(), *name, data))
           })
           .collect::<Vec<_>>();
@@ -241,26 +241,27 @@ async fn inner_impl(compilation: &mut Compilation) -> Result<()> {
   logger.time_end(start);
 
   let start = logger.time("collect hash updates");
-  let updates: Vec<_> = assets_data
+  let updates: Vec<(Arc<str>, BoxSource, Option<Arc<str>>)> = assets_data
     .into_par_iter()
     .filter_map(|(name, data)| {
       let new_source = data.compute_new_source(false, &hash_to_new_hash, &hash_ac);
       let mut new_name = String::with_capacity(name.len());
-      hash_ac.replace_all_with(name, &mut new_name, |_, hash, dst| {
+      hash_ac.replace_all_with(name.as_ref(), &mut new_name, |_, hash, dst| {
         let replace_to = hash_to_new_hash
           .get(hash)
           .expect("RealContentHashPlugin: should have new hash");
         dst.push_str(replace_to);
         true
       });
-      let new_name = (name != new_name).then_some(new_name);
-      Some((name.to_owned(), new_source, new_name))
+      let new_name: Option<Arc<str>> =
+        (name.as_ref() != new_name.as_str()).then_some(new_name.into());
+      Some((name.clone(), new_source, new_name))
     })
     .collect();
   logger.time_end(start);
 
   let start = logger.time("update assets");
-  let mut asset_renames = Vec::with_capacity(updates.len());
+  let mut asset_renames: Vec<(Arc<str>, Arc<str>)> = Vec::with_capacity(updates.len());
   for (name, new_source, new_name) in updates {
     compilation.update_asset(&name, |_, old_info| {
       let new_hashes: HashSet<_> = old_info
@@ -280,7 +281,7 @@ async fn inner_impl(compilation: &mut Compilation) -> Result<()> {
       ))
     })?;
     if let Some(new_name) = new_name {
-      asset_renames.push((name, new_name));
+      asset_renames.push((name.clone(), new_name));
     }
   }
 
@@ -380,13 +381,13 @@ impl AssetData {
 
 struct OrderedHashesBuilder<'a> {
   hash_to_asset_names: &'a HashMap<&'a str, Vec<&'a str>>,
-  assets_data: &'a HashMap<&'a str, AssetData>,
+  assets_data: &'a HashMap<Arc<str>, AssetData>,
 }
 
 impl<'a> OrderedHashesBuilder<'a> {
   pub fn new(
     hash_to_asset_names: &'a HashMap<&'a str, Vec<&'a str>>,
-    assets_data: &'a HashMap<&'a str, AssetData>,
+    assets_data: &'a HashMap<Arc<str>, AssetData>,
   ) -> Self {
     Self {
       hash_to_asset_names,
@@ -428,7 +429,7 @@ impl OrderedHashesBuilder<'_> {
       .expect("RealContentHashPlugin: should have asset_names");
     let mut hashes = HashSet::default();
     for name in asset_names {
-      if let Some(asset_hash) = self.assets_data.get(name) {
+      if let Some(asset_hash) = self.assets_data.get(*name) {
         if !asset_hash.own_hashes.contains(hash) {
           for hash in &asset_hash.own_hashes {
             hashes.insert(hash.as_str());
diff --git a/crates/rspack_plugin_remove_duplicate_modules/src/lib.rs b/crates/rspack_plugin_remove_duplicate_modules/src/lib.rs
index 03dbc0375ac1..d24e17fd72cd 100644
--- a/crates/rspack_plugin_remove_duplicate_modules/src/lib.rs
+++ b/crates/rspack_plugin_remove_duplicate_modules/src/lib.rs
@@ -110,7 +110,7 @@ async fn optimize_chunks(&self, compilation: &mut Compilation) -> Result<Option<
         .build_chunk_graph_artifact
         .chunk_by_ukey
         .expect_get_mut(&new_chunk_ukey);
-      *new_chunk.chunk_reason_mut() = Some("modules are shared across multiple chunks".into());
+      *new_chunk.chunk_reason_mut() = Some("modules are shared across multiple chunks".to_string());
       compilation
         .build_chunk_graph_artifact
         .chunk_graph
diff --git a/crates/rspack_plugin_rsc/src/client_plugin.rs b/crates/rspack_plugin_rsc/src/client_plugin.rs
index 54a883f13768..d99fce8902e6 100644
--- a/crates/rspack_plugin_rsc/src/client_plugin.rs
+++ b/crates/rspack_plugin_rsc/src/client_plugin.rs
@@ -54,7 +54,7 @@ fn extend_required_chunks(
       continue;
     };
     for file in chunk.files().iter().filter(|f| f.ends_with(".js")) {
-      if let Some(asset) = compilation.assets().get(file) {
+      if let Some(asset) = compilation.assets().get(file.as_ref()) {
         let asset_info = asset.get_info();
         if asset_info.hot_module_replacement.unwrap_or(false)
           || asset_info.development.unwrap_or(false)
@@ -247,7 +247,7 @@ async fn collect_entry_js_files(
   plugin_state: &mut PluginState,
 ) -> Result<()> {
   for (entry_name, chunk_group_ukey) in &compilation.build_chunk_graph_artifact.entrypoints {
-    let Some(entry_state) = plugin_state.entries.get_mut(entry_name.as_str()) else {
+    let Some(entry_state) = plugin_state.entries.get_mut(entry_name.as_ref()) else {
       continue;
     };
 
@@ -270,7 +270,7 @@ async fn collect_entry_js_files(
       .into_iter()
       .filter(|chunk_file| chunk_file.ends_with(".js"))
       .filter(|chunk_file| {
-        let Some(asset) = compilation.assets().get(chunk_file) else {
+        let Some(asset) = compilation.assets().get(chunk_file.as_ref()) else {
           return true;
         };
         // Prevent hot-module files from being included
@@ -444,7 +444,7 @@ impl RscClientPlugin {
         .module_loading
         .as_ref()
         .expect("module_loading should be initialized before recording modules");
-      let Some(entry_state) = plugin_state.entries.get_mut(entry_name.as_str()) else {
+      let Some(entry_state) = plugin_state.entries.get_mut(entry_name.as_ref()) else {
         continue;
       };
 
diff --git a/crates/rspack_plugin_rsc/src/hot_reloader.rs b/crates/rspack_plugin_rsc/src/hot_reloader.rs
index 2e467e49413d..01307be4aeda 100644
--- a/crates/rspack_plugin_rsc/src/hot_reloader.rs
+++ b/crates/rspack_plugin_rsc/src/hot_reloader.rs
@@ -21,7 +21,6 @@ pub fn track_server_component_changes(
   let mut cur_server_component_hashes = Default::default();
 
   for (entry_name, entry_data) in &compilation.entries {
-    let entry_name: Arc<str> = Arc::from(entry_name.clone());
     visited_modules.clear();
 
     let changed_server_components = changed_server_components_per_entry
diff --git a/crates/rspack_plugin_rsc/src/manifest_runtime_module.rs b/crates/rspack_plugin_rsc/src/manifest_runtime_module.rs
index d7d43f70147f..2f61aa9cb964 100644
--- a/crates/rspack_plugin_rsc/src/manifest_runtime_module.rs
+++ b/crates/rspack_plugin_rsc/src/manifest_runtime_module.rs
@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use indoc::formatdoc;
 use rspack_core::{
   RuntimeGlobals, RuntimeModule, RuntimeModuleGenerateContext, RuntimeModuleStage, RuntimeTemplate,
@@ -47,7 +45,7 @@ impl RuntimeModule for RscManifestRuntimeModule {
       .and_then(|chunk| {
         chunk.get_entry_options(&compilation.build_chunk_graph_artifact.chunk_group_by_ukey)
       })
-      .and_then(|entry_options| entry_options.name.clone().map(Arc::from))
+      .and_then(|entry_options| entry_options.name.clone())
     else {
       return Ok(String::new());
     };
diff --git a/crates/rspack_plugin_rsc/src/server_plugin.rs b/crates/rspack_plugin_rsc/src/server_plugin.rs
index 87e64ce2cf6f..60fe55d3e49e 100644
--- a/crates/rspack_plugin_rsc/src/server_plugin.rs
+++ b/crates/rspack_plugin_rsc/src/server_plugin.rs
@@ -235,7 +235,6 @@ impl RscServerPlugin {
     let mut runtime_per_entry: FxHashMap<Arc<str>, RuntimeSpec> = Default::default();
 
     for (entry_name, entry_data) in &compilation.entries {
-      let entry_name: Arc<str> = Arc::from(entry_name.clone());
       let runtime = get_entry_runtime(
         entry_name.as_ref(),
         &entry_data.options,
@@ -507,7 +506,7 @@ impl RscServerPlugin {
       add_entry: (
         Box::new(ssr_entry_dependency),
         EntryOptions {
-          name: Some(entry_name.to_string()),
+          name: Some(entry_name),
           layer: Some(LAYERS_NAMES.server_side_rendering.to_string()),
           ..Default::default()
         },
@@ -563,7 +562,7 @@ impl RscServerPlugin {
       add_entry: (
         Box::new(action_entry_dep),
         EntryOptions {
-          name: Some(entry_name.to_string()),
+          name: Some(entry_name),
           layer: Some(layer),
           ..Default::default()
         },
diff --git a/crates/rspack_plugin_rsdoctor/src/chunk_graph.rs b/crates/rspack_plugin_rsdoctor/src/chunk_graph.rs
index 04eb0e1fd6b2..db333012cb10 100644
--- a/crates/rspack_plugin_rsdoctor/src/chunk_graph.rs
+++ b/crates/rspack_plugin_rsdoctor/src/chunk_graph.rs
@@ -3,7 +3,7 @@ use std::sync::{Arc, atomic::AtomicI32};
 use rayon::iter::{IntoParallelRefIterator, ParallelBridge, ParallelIterator};
 use rspack_collections::IdentifierMap;
 use rspack_core::{
-  Chunk, ChunkByUkey, ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkUkey, CompilationAsset,
+  Chunk, ChunkByUkey, ChunkGraph, ChunkGroupByUkey, ChunkGroupUkey, ChunkUkey, CompilationAssets,
   ModuleGraph,
 };
 use rspack_util::fx_hash::{FxHashMap, FxIndexMap};
@@ -107,7 +107,7 @@ pub fn collect_chunk_dependencies(
 }
 
 pub fn collect_entrypoints(
-  entrypoints: &FxIndexMap<String, ChunkGroupUkey>,
+  entrypoints: &FxIndexMap<Arc<str>, ChunkGroupUkey>,
   rsd_chunks: &FxHashMap<ChunkUkey, RsdoctorChunk>,
   chunk_group_by_ukey: &ChunkGroupByUkey,
 ) -> FxHashMap<ChunkGroupUkey, RsdoctorEntrypoint> {
@@ -137,14 +137,14 @@ pub fn collect_entrypoints(
 }
 
 pub fn collect_assets(
-  assets: &HashMap<String, CompilationAsset>,
+  assets: &CompilationAssets,
   chunk_by_ukey: &ChunkByUkey,
 ) -> HashMap<String, RsdoctorAsset> {
   let asset_ukey_counter: Arc<AtomicI32> = Arc::new(AtomicI32::new(0));
-  let mut compilation_file_to_chunks: HashMap<&String, Vec<&ChunkUkey>> = HashMap::default();
+  let mut compilation_file_to_chunks: HashMap<Arc<str>, Vec<&ChunkUkey>> = HashMap::default();
   for (chunk_ukey, chunk) in chunk_by_ukey.iter() {
     for file in chunk.files() {
-      let chunks = compilation_file_to_chunks.entry(file).or_default();
+      let chunks = compilation_file_to_chunks.entry(file.clone()).or_default();
       chunks.push(chunk_ukey);
     }
   }
@@ -152,7 +152,7 @@ pub fn collect_assets(
     .par_iter()
     .map(|(path, asset)| {
       let chunks = compilation_file_to_chunks
-        .get(path)
+        .get(path.as_ref())
         .map(|chunks| {
           chunks
             .iter()
@@ -161,10 +161,10 @@ pub fn collect_assets(
         })
         .unwrap_or_default();
       (
-        path.clone(),
+        path.to_string(),
         RsdoctorAsset {
           ukey: asset_ukey_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
-          path: path.clone(),
+          path: path.to_string(),
           chunks,
           size: asset
             .get_source()
@@ -228,14 +228,14 @@ pub fn collect_chunk_assets(
       assets: chunk
         .files()
         .iter()
-        .filter_map(|file| rsd_assets.get(file).map(|asset| asset.ukey))
+        .filter_map(|file| rsd_assets.get(file.as_ref()).map(|asset| asset.ukey))
         .collect::<HashSet<_>>(),
     })
     .collect::<Vec<_>>()
 }
 
 pub fn collect_entrypoint_assets(
-  entrypoints: &FxIndexMap<String, ChunkGroupUkey>,
+  entrypoints: &FxIndexMap<Arc<str>, ChunkGroupUkey>,
   rsd_assets: &FxHashMap<String, RsdoctorAsset>,
   entrypoint_ukey_map: &HashMap<ChunkGroupUkey, RsdoctorEntrypointUkey>,
   chunk_group_by_ukey: &ChunkGroupByUkey,
@@ -255,7 +255,7 @@ pub fn collect_entrypoint_assets(
             chunk_by_ukey.get(c).map(|c| {
               c.files()
                 .iter()
-                .filter_map(|path| rsd_assets.get(path).map(|asset| asset.ukey))
+                .filter_map(|path| rsd_assets.get(path.as_ref()).map(|asset| asset.ukey))
             })
           })
           .flatten()
diff --git a/crates/rspack_plugin_rsdoctor/src/data.rs b/crates/rspack_plugin_rsdoctor/src/data.rs
index c47dd6ce6125..dfe8078398da 100644
--- a/crates/rspack_plugin_rsdoctor/src/data.rs
+++ b/crates/rspack_plugin_rsdoctor/src/data.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use rspack_collections::Identifier;
 use rspack_core::DependencyType;
 use rustc_hash::FxHashSet as HashSet;
@@ -97,7 +99,7 @@ pub struct RsdoctorChunk {
 #[derive(Debug, Default)]
 pub struct RsdoctorEntrypoint {
   pub ukey: EntrypointUkey,
-  pub name: String,
+  pub name: Arc<str>,
   pub chunks: HashSet<ChunkUkey>,
 }
 
diff --git a/crates/rspack_plugin_rstest/src/plugin.rs b/crates/rspack_plugin_rstest/src/plugin.rs
index aafb657799fd..64fbfdebd0fc 100644
--- a/crates/rspack_plugin_rstest/src/plugin.rs
+++ b/crates/rspack_plugin_rstest/src/plugin.rs
@@ -213,7 +213,7 @@ async fn mock_hoist_process_assets(&self, compilation: &mut Compilation) -> Resu
 
   for file in files {
     let mut pos_map: HashMap<String, MockFlagPos> = HashMap::default();
-    let _res = compilation.update_asset(file.as_str(), |old, info| {
+    let _res = compilation.update_asset(file.as_ref(), |old, info| {
       // Only handles JavaScript.
       if info.javascript_module.is_none() {
         return Ok((old, info));
diff --git a/crates/rspack_plugin_size_limits/src/lib.rs b/crates/rspack_plugin_size_limits/src/lib.rs
index 752f36173267..f05495f215ab 100644
--- a/crates/rspack_plugin_size_limits/src/lib.rs
+++ b/crates/rspack_plugin_size_limits/src/lib.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use derive_more::Debug;
 use futures::future::BoxFuture;
 use rspack_core::{
@@ -46,7 +48,7 @@ impl SizeLimitsPlugin {
     let mut size = 0.0;
 
     for filename in entrypoint.get_files(&compilation.build_chunk_graph_artifact.chunk_by_ukey) {
-      let asset = compilation.assets().get(&filename);
+      let asset = compilation.assets().get(filename.as_ref());
 
       if let Some(asset) = asset {
         if !self.asset_filter(&filename, asset).await {
@@ -79,7 +81,7 @@ impl SizeLimitsPlugin {
   }
 
   fn add_assets_over_size_limit_warning(
-    detail: &[(String, f64)],
+    detail: &[(Arc<str>, f64)],
     limit: f64,
     hints: &str,
     diagnostics: &mut Vec<Diagnostic>,
@@ -98,8 +100,9 @@ impl SizeLimitsPlugin {
     Self::add_diagnostic(hints, title, message, diagnostics);
   }
 
+  #[allow(clippy::type_complexity)]
   fn add_entrypoints_over_size_limit_warning(
-    detail: &[(&String, f64, Vec<String>)],
+    detail: &[(&Arc<str>, f64, Vec<Arc<str>>)],
     limit: f64,
     hints: &str,
     diagnostics: &mut Vec<Diagnostic>,
@@ -135,18 +138,18 @@ async fn after_emit(&self, compilation: &mut Compilation) -> Result<()> {
   let hints = &self.options.hints;
   let max_asset_size = self.options.max_asset_size.unwrap_or(250_000.0);
   let max_entrypoint_size = self.options.max_entrypoint_size.unwrap_or(250_000.0);
-  let mut checked_assets: HashMap<String, bool> = HashMap::default();
+  let mut checked_assets: HashMap<Arc<str>, bool> = HashMap::default();
   let mut checked_chunk_groups: HashMap<ChunkGroupUkey, bool> = HashMap::default();
 
   let mut assets_over_size_limit = vec![];
 
-  let asset_sizes = rspack_futures::scope::<_, _>(|token| {
+  let asset_sizes: Vec<Option<(Arc<str>, f64, bool)>> = rspack_futures::scope::<_, _>(|token| {
     compilation.assets().iter().for_each(|(name, asset)| {
       // SAFETY: await immediately and trust caller to poll future entirely
       let s = unsafe { token.used((&self, asset, name, max_asset_size)) };
 
       s.spawn(|(plugin, asset, name, max_asset_size)| async move {
-        if !plugin.asset_filter(name, asset).await {
+        if !plugin.asset_filter(name.as_ref(), asset).await {
           return None;
         }
 
@@ -185,7 +188,7 @@ async fn after_emit(&self, compilation: &mut Compilation) -> Result<()> {
       let mut files = vec![];
 
       for filename in entry.get_files(&compilation.build_chunk_graph_artifact.chunk_by_ukey) {
-        let asset = compilation.assets().get(&filename);
+        let asset = compilation.assets().get(filename.as_ref());
 
         if let Some(asset) = asset
           && self.asset_filter(&filename, asset).await
@@ -242,7 +245,7 @@ async fn after_emit(&self, compilation: &mut Compilation) -> Result<()> {
   }
 
   for (name, asset) in compilation.assets_mut() {
-    if let Some(checked) = checked_assets.get(name) {
+    if let Some(checked) = checked_assets.get(name.as_ref()) {
       asset.info.set_is_over_size_limit(*checked)
     }
   }
diff --git a/crates/rspack_plugin_split_chunks/src/plugin/chunk.rs b/crates/rspack_plugin_split_chunks/src/plugin/chunk.rs
index e494a9172490..222fa3639b90 100644
--- a/crates/rspack_plugin_split_chunks/src/plugin/chunk.rs
+++ b/crates/rspack_plugin_split_chunks/src/plugin/chunk.rs
@@ -10,15 +10,15 @@ fn put_split_chunk_reason(
   is_reuse_existing_chunk_with_all_modules: bool,
 ) {
   let reason = if is_reuse_existing_chunk_with_all_modules {
-    "reused as split chunk".to_string()
+    "reused as split chunk"
   } else {
-    "split chunk".to_string()
+    "split chunk"
   };
   if let Some(chunk_reason) = chunk_reason {
     chunk_reason.push(',');
-    chunk_reason.push_str(&reason);
+    chunk_reason.push_str(reason);
   } else {
-    *chunk_reason = Some(reason);
+    *chunk_reason = Some(reason.to_string());
   }
 }
 
@@ -126,7 +126,7 @@ impl SplitChunksPlugin {
       if let Some(chunk) = compilation
         .build_chunk_graph_artifact
         .named_chunks
-        .get(chunk_name)
+        .get(chunk_name.as_str())
       {
         *is_reuse_existing_chunk = true;
         *chunk
diff --git a/crates/rspack_plugin_sri/src/asset.rs b/crates/rspack_plugin_sri/src/asset.rs
index 97a80ba0a5bc..04b8f7e04a3a 100644
--- a/crates/rspack_plugin_sri/src/asset.rs
+++ b/crates/rspack_plugin_sri/src/asset.rs
@@ -77,11 +77,11 @@ See https://w3c.github.io/webappsec-subresource-integrity/#cross-origin-data-lea
       .map(|(chunk_id, file)| {
         if let Some((source, asset_type)) = compilation
           .assets()
-          .get(file)
+          .get(file.as_ref())
           .and_then(|a| a.get_source().map(|s| (s, a.get_info().asset_type)))
         {
           process_chunk_source(
-            file,
+            file.as_ref(),
             source.clone(),
             asset_type,
             chunk_id,
@@ -91,7 +91,7 @@ See https://w3c.github.io/webappsec-subresource-integrity/#cross-origin-data-lea
           )
         } else {
           ProcessChunkResult {
-            file: file.clone(),
+            file: file.to_string(),
             source: None,
             warnings: vec![format!("No asset found for source path '{}'", file)],
             placeholder: None,
@@ -254,7 +254,7 @@ async fn add_minssing_integrities(
     assets
       .par_iter()
       .filter_map(|(src, asset)| {
-        if integrities.contains_key(src) {
+        if integrities.contains_key(src.as_ref()) {
           return None;
         }
         asset.source.as_ref().map(|s| {
@@ -266,7 +266,10 @@ async fn add_minssing_integrities(
       .collect::<HashMap<_, _>>()
   };
 
-  integrities.write().await.extend(new_integrities);
+  integrities
+    .write()
+    .await
+    .extend(new_integrities.into_iter().map(|(k, v)| (k.to_string(), v)));
 }
 
 #[plugin_hook(CompilationProcessAssets for SubresourceIntegrityPlugin, stage = Compilation::PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE - 1)]
@@ -315,13 +318,16 @@ pub async fn detect_unresolved_integrity(
     .values()
   {
     for file in chunk.files() {
-      if let Some(source) = compilation.assets().get(file).and_then(|a| a.get_source())
+      if let Some(source) = compilation
+        .assets()
+        .get(file.as_ref())
+        .and_then(|a| a.get_source())
         && source
           .source()
           .into_string_lossy()
           .contains(PLACEHOLDER_PREFIX)
       {
-        contain_unresolved_files.push(file.clone());
+        contain_unresolved_files.push(file.to_string());
       }
     }
   }
diff --git a/crates/rspack_plugin_wasm/src/wasm_plugin.rs b/crates/rspack_plugin_wasm/src/wasm_plugin.rs
index aff795d10e03..0c3517a60d90 100644
--- a/crates/rspack_plugin_wasm/src/wasm_plugin.rs
+++ b/crates/rspack_plugin_wasm/src/wasm_plugin.rs
@@ -1,4 +1,4 @@
-use std::fmt::Debug;
+use std::{fmt::Debug, sync::Arc};
 
 use rspack_core::{
   ChunkGraph, ChunkUkey, Compilation, CompilationParams, CompilationRenderManifest,
@@ -77,7 +77,7 @@ async fn render_manifest(
     let asset_info = asset_info.with_asset_type(ManifestAssetType::Wasm);
     manifest.push(RenderManifestEntry {
       source: source.clone(),
-      filename: output_path,
+      filename: Arc::from(output_path),
       has_filename: true,
       info: asset_info,
       auxiliary: false,