diff --git a/.github/workflows/rust-ci.yml b/.github/workflows/rust-ci.yml
index f9a6d5bd5..28cb8f4b8 100644
--- a/.github/workflows/rust-ci.yml
+++ b/.github/workflows/rust-ci.yml
@@ -96,6 +96,9 @@ jobs:
     - name: Run tests
       run: cargo test --release
 
+    - name: Run integration tests
+      run: cargo test --release --test integration
+
   msys2-build-test:
     strategy:
       fail-fast: false
@@ -183,3 +186,6 @@ jobs:
     - name: Run tests
       run: cargo test --release
 
+    - name: Run integration tests
+      run: cargo test --release --test integration
+
diff --git a/Cargo.lock b/Cargo.lock
index 9dd4b7ae0..de7fbe31d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -166,6 +166,7 @@ dependencies = [
  "indexmap 2.10.0",
  "mini_harness",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -543,6 +544,7 @@ dependencies = [
  "once_cell",
  "ordered-float",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -564,6 +566,7 @@ dependencies = [
  "mir",
  "mir_build",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -823,6 +826,7 @@ dependencies = [
  "indexmap 2.10.0",
  "lasso",
  "list_pool",
+ "rustc-hash 2.1.1",
  "smallvec",
  "stdx",
  "typed-index-collections",
@@ -842,6 +846,7 @@ dependencies = [
  "mir",
  "mir_interpret",
  "mir_reader",
+ "rustc-hash 2.1.1",
  "stdx",
  "typed-index-collections",
  "typed_indexmap",
@@ -892,12 +897,12 @@ dependencies = [
 name = "mir_opt"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "bitset",
  "expect-test",
  "hashbrown 0.14.5",
  "mir",
  "mir_reader",
+ "rustc-hash 2.1.1",
  "stdx",
  "typed-index-collections",
  "workqueue",
@@ -1025,7 +1030,6 @@ dependencies = [
 name = "osdi"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "base_n",
  "camino",
  "expect-test",
@@ -1043,6 +1047,7 @@ dependencies = [
  "mir_llvm",
  "paths",
  "rayon-core",
+ "rustc-hash 2.1.1",
  "salsa",
  "sim_back",
  "smol_str",
@@ -1229,7 +1234,7 @@ checksum = "0a542b0253fa46e632d27a1dc5cf7b930de4df8659dc6e720b647fc72147ae3d"
 dependencies = [
  "countme",
  "hashbrown 0.14.5",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "text-size",
 ]
 
@@ -1245,6 +1250,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "ryu_floating_decimal"
 version = "0.1.0"
@@ -1265,7 +1276,7 @@ dependencies = [
  "log",
  "oorandom",
  "parking_lot",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "salsa-macros",
  "smallvec",
 ]
@@ -1338,6 +1349,7 @@ dependencies = [
  "mir_build",
  "mir_interpret",
  "mir_opt",
+ "rustc-hash 2.1.1",
  "smol_str",
  "stdx",
  "syntax",
@@ -1489,8 +1501,8 @@ dependencies = [
 name = "typed_indexmap"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "indexmap 2.10.0",
+ "rustc-hash 2.1.1",
 ]
 
 [[package]]
@@ -1591,11 +1603,11 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 name = "vfs"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "chardetng",
  "encoding_rs",
  "indexmap 2.10.0",
  "paths",
+ "rustc-hash 2.1.1",
 ]
 
 [[package]]
diff --git a/lib/typed_indexmap/Cargo.toml b/lib/typed_indexmap/Cargo.toml
index 81c27b390..5759cce17 100644
--- a/lib/typed_indexmap/Cargo.toml
+++ b/lib/typed_indexmap/Cargo.toml
@@ -11,4 +11,4 @@ doctest = false
 
 [dependencies]
 indexmap = "2.0"
-ahash = "0.8"
+rustc-hash = "2.0"
diff --git a/lib/typed_indexmap/src/map.rs b/lib/typed_indexmap/src/map.rs
index 5364f92c5..cd290d788 100644
--- a/lib/typed_indexmap/src/map.rs
+++ b/lib/typed_indexmap/src/map.rs
@@ -1,11 +1,11 @@
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::hash::{BuildHasherDefault, Hash};
 use std::iter;
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut};
 
-use ahash::RandomState;
 use indexmap::{Equivalent, IndexMap};
+use rustc_hash::FxHasher;
 
 pub type Iter<'a, I, K, V> = iter::Map<
     iter::Enumerate<indexmap::map::Iter<'a, K, V>>,
@@ -15,7 +15,7 @@ pub type Iter<'a, I, K, V> = iter::Map<
 #[repr(transparent)]
 pub struct TiMap<I, K, V> {
     /// raw set property
-    pub raw: IndexMap<K, V, ahash::RandomState>,
+    pub raw: IndexMap<K, V, BuildHasherDefault<FxHasher>>,
     _marker: PhantomData<fn(I) -> I>,
 }
 
@@ -38,7 +38,10 @@ impl<I, K: Clone, V: Clone> Clone for TiMap<I, K, V> {
 
 impl<I, K, V> Default for TiMap<I, K, V> {
     fn default() -> Self {
-        Self { raw: IndexMap::default(), _marker: PhantomData }
+        Self {
+            raw: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            _marker: PhantomData,
+        }
     }
 }
 
@@ -75,7 +78,7 @@ impl<I, K, V> TiMap<I, K, V> {
 
     pub fn with_capacity(cap: usize) -> Self {
         Self {
-            raw: IndexMap::with_capacity_and_hasher(cap, RandomState::new()),
+            raw: IndexMap::with_capacity_and_hasher(cap, BuildHasherDefault::<FxHasher>::default()),
             _marker: PhantomData,
         }
     }
@@ -177,21 +180,24 @@ where
     }
 }
 
-impl<I, K, V> From<IndexMap<K, V, ahash::RandomState>> for TiMap<I, K, V> {
-    fn from(raw: IndexMap<K, V, ahash::RandomState>) -> Self {
+impl<I, K, V> From<IndexMap<K, V, BuildHasherDefault<FxHasher>>> for TiMap<I, K, V> {
+    fn from(raw: IndexMap<K, V, BuildHasherDefault<FxHasher>>) -> Self {
         TiMap { raw, _marker: PhantomData }
     }
 }
 
 impl<I, K: Hash + Eq, V> FromIterator<(K, V)> for TiMap<I, K, V> {
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
-        Self { raw: iter.into_iter().collect(), _marker: PhantomData }
+        let mut map = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        map.extend(iter);
+        Self { raw: map, _marker: PhantomData }
     }
 }
 
-impl<I, K, V> AsRef<TiMap<I, K, V>> for IndexMap<K, V, RandomState> {
+impl<I, K, V> AsRef<TiMap<I, K, V>> for IndexMap<K, V, BuildHasherDefault<FxHasher>> {
     fn as_ref(&self) -> &TiMap<I, K, V> {
-        let ptr = self as *const IndexMap<K, V, RandomState> as *const TiMap<I, K, V>;
+        let ptr =
+            self as *const IndexMap<K, V, BuildHasherDefault<FxHasher>> as *const TiMap<I, K, V>;
         // safety: this is save because of repr(transparent)
         unsafe { &*ptr }
     }
diff --git a/lib/typed_indexmap/src/set.rs b/lib/typed_indexmap/src/set.rs
index 5bacf9402..8405ef751 100644
--- a/lib/typed_indexmap/src/set.rs
+++ b/lib/typed_indexmap/src/set.rs
@@ -1,17 +1,18 @@
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::hash::{BuildHasherDefault, Hash};
 use std::iter;
 use std::marker::PhantomData;
 use std::ops::Index;
 
 use indexmap::{Equivalent, IndexSet};
+use rustc_hash::FxHasher;
 
 pub type Iter<'a, K, V> =
     iter::Map<iter::Enumerate<indexmap::set::Iter<'a, V>>, fn((usize, &'a V)) -> (K, &'a V)>;
 
 pub struct TiSet<K, V> {
     /// raw set property
-    pub raw: IndexSet<V, ahash::RandomState>,
+    pub raw: IndexSet<V, BuildHasherDefault<FxHasher>>,
     _marker: PhantomData<fn(K) -> K>,
 }
 
@@ -33,14 +34,17 @@ impl<K, V: Clone> Clone for TiSet<K, V> {
 
 impl<K, V> Default for TiSet<K, V> {
     fn default() -> Self {
-        Self { raw: IndexSet::default(), _marker: PhantomData }
+        Self {
+            raw: IndexSet::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            _marker: PhantomData,
+        }
     }
 }
 
 impl<K, V> TiSet<K, V> {
     pub fn with_capacity(cap: usize) -> TiSet<K, V> {
         TiSet {
-            raw: IndexSet::with_capacity_and_hasher(cap, ahash::RandomState::default()),
+            raw: IndexSet::with_capacity_and_hasher(cap, BuildHasherDefault::<FxHasher>::default()),
             _marker: PhantomData,
         }
     }
@@ -174,6 +178,8 @@ where
     V: Eq + Hash,
 {
     fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
-        Self { raw: iter.into_iter().collect(), _marker: PhantomData }
+        let mut set = IndexSet::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        set.extend(iter);
+        Self { raw: set, _marker: PhantomData }
     }
 }
diff --git a/melange/core/src/simulation.rs b/melange/core/src/simulation.rs
index 6a7d350bf..f834903a8 100644
--- a/melange/core/src/simulation.rs
+++ b/melange/core/src/simulation.rs
@@ -91,13 +91,13 @@ impl Circuit {
         eval_ctx: ExprEvalCtxRef,
         arena: &Arena,
         config: SimConfig,
-    ) -> Result<Simulation> {
+    ) -> Result<Simulation<'_>> {
         let mut res = self.setup_simulation(config)?;
         res.prepare_solver(eval_ctx, arena)?;
         Ok(res)
     }
 
-    pub fn setup_simulation(&self, config: SimConfig) -> Result<Simulation> {
+    pub fn setup_simulation(&self, config: SimConfig) -> Result<Simulation<'_>> {
         let model_data: Box<TiSlice<_, _>> = self
             .models()
             .map(|model| {
diff --git a/openvaf/basedb/Cargo.toml b/openvaf/basedb/Cargo.toml
index 2ab9505b1..4499f9561 100644
--- a/openvaf/basedb/Cargo.toml
+++ b/openvaf/basedb/Cargo.toml
@@ -35,6 +35,7 @@ typed-index-collections = "3.1"
 parking_lot = "0.12"
 indexmap = "2.0"
 ahash = "0.8"
+rustc-hash = "2.0"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/basedb/src/lints.rs b/openvaf/basedb/src/lints.rs
index 97f626912..dd776ec58 100644
--- a/openvaf/basedb/src/lints.rs
+++ b/openvaf/basedb/src/lints.rs
@@ -1,7 +1,9 @@
 use std::fmt::{self, Display, Formatter};
+use std::hash::BuildHasherDefault;
 use std::sync::Arc;
 
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use vfs::FileId;
 
@@ -101,7 +103,7 @@ pub struct LintData {
 /// and `str (lint name) -> LintData`
 #[derive(Debug, Default, Eq, PartialEq)]
 pub struct LintRegistry {
-    lints: IndexMap<&'static str, LintData, ahash::RandomState>,
+    lints: IndexMap<&'static str, LintData, BuildHasherDefault<FxHasher>>,
 }
 
 impl LintRegistry {
diff --git a/openvaf/hir_def/Cargo.toml b/openvaf/hir_def/Cargo.toml
index b064a3dc2..cb8874444 100644
--- a/openvaf/hir_def/Cargo.toml
+++ b/openvaf/hir_def/Cargo.toml
@@ -31,6 +31,7 @@ typed-index-collections = "3.1"
 
 # Performant collections
 ahash = "0.8"
+rustc-hash = "2.0"
 indexmap = "2.0"
 
 [dev-dependencies]
diff --git a/openvaf/hir_def/src/builtin.rs b/openvaf/hir_def/src/builtin.rs
index c3a12e939..5729cfb54 100644
--- a/openvaf/hir_def/src/builtin.rs
+++ b/openvaf/hir_def/src/builtin.rs
@@ -1,7 +1,9 @@
 //! Generated by `generate_builtins`, do not edit by hand.
 
-use ahash::RandomState;
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use syntax::name::{kw, sysfun, Name};
 
 use crate::nameres::ScopeDefItem;
@@ -238,7 +240,7 @@ impl BuiltIn {
         }
     }
 }
-pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>) {
+pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>) {
     dst.insert(kw::abs, BuiltIn::abs.into());
     dst.insert(kw::acos, BuiltIn::acos.into());
     dst.insert(kw::acosh, BuiltIn::acosh.into());
@@ -371,7 +373,9 @@ pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>)
     dst.insert(kw::slew, BuiltIn::slew.into());
     dst.insert(kw::transition, BuiltIn::transition.into());
 }
-pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>) {
+pub fn insert_module_builtin_scope(
+    dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>,
+) {
     dst.insert(sysfun::mfactor, ParamSysFun::mfactor.into());
     dst.insert(sysfun::xposition, ParamSysFun::xposition.into());
     dst.insert(sysfun::yposition, ParamSysFun::yposition.into());
diff --git a/openvaf/hir_def/src/nameres.rs b/openvaf/hir_def/src/nameres.rs
index 17b1858e4..a49591c3b 100644
--- a/openvaf/hir_def/src/nameres.rs
+++ b/openvaf/hir_def/src/nameres.rs
@@ -1,3 +1,4 @@
+use std::hash::BuildHasherDefault;
 use std::ops::{Index, IndexMut};
 use std::sync::Arc;
 
@@ -5,6 +6,7 @@ use arena::{Arena, Idx};
 use basedb::{AstIdMap, ErasedAstId, FileId};
 use indexmap::IndexMap;
 use once_cell::sync::Lazy;
+use rustc_hash::FxHasher;
 use stdx::{impl_display, impl_from, impl_from_typed};
 use syntax::name::{kw, Name};
 use syntax::{AstNode, Parse, SourceFile, TextRange};
@@ -271,18 +273,19 @@ impl_from_typed! {
     for ScopeOrigin
 }
 
-static BUILTIN_SCOPE: Lazy<IndexMap<Name, ScopeDefItem, ahash::RandomState>> = Lazy::new(|| {
-    let mut scope = IndexMap::default();
-    insert_builtin_scope(&mut scope);
-    scope
-});
+static BUILTIN_SCOPE: Lazy<IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>> =
+    Lazy::new(|| {
+        let mut scope = IndexMap::default();
+        insert_builtin_scope(&mut scope);
+        scope
+    });
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Scope {
     pub origin: ScopeOrigin,
     parent: Option<LocalScopeId>,
-    pub children: IndexMap<Name, LocalScopeId, ahash::RandomState>,
-    pub declarations: IndexMap<Name, ScopeDefItem, ahash::RandomState>,
+    pub children: IndexMap<Name, LocalScopeId, BuildHasherDefault<FxHasher>>,
+    pub declarations: IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>,
 }
 
 impl DefMap {
diff --git a/openvaf/hir_lower/Cargo.toml b/openvaf/hir_lower/Cargo.toml
index 84c7e7454..af3fffa08 100644
--- a/openvaf/hir_lower/Cargo.toml
+++ b/openvaf/hir_lower/Cargo.toml
@@ -22,6 +22,7 @@ mir = {version = "0.0.0", path = "../mir" }
 mir_build = {version = "0.0.0", path = "../mir_build" }
 
 ahash = "0.8"
+rustc-hash = "2.0"
 typed-index-collections = "3.1"
 indexmap = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
diff --git a/openvaf/hir_lower/src/lib.rs b/openvaf/hir_lower/src/lib.rs
index 6dc719f01..1f54f72e6 100644
--- a/openvaf/hir_lower/src/lib.rs
+++ b/openvaf/hir_lower/src/lib.rs
@@ -1,3 +1,4 @@
+use std::hash::BuildHasherDefault;
 use std::iter::FilterMap;
 
 use ahash::{AHashMap, AHashSet};
@@ -11,6 +12,7 @@ use lasso::Rodeo;
 use mir::builder::InstBuilder;
 use mir::{DataFlowGraph, FuncRef, Function, Inst, KnownDerivatives, Param, Unknown, Value};
 use mir_build::{FunctionBuilder, FunctionBuilderContext, RetBuilder};
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
@@ -220,13 +222,13 @@ impl_debug_display! {
 
 /// A mapping between abstractions used in the MIR and the corresponding
 /// information from the HIR. This allows the MIR to remain independent of the frontend/HIR
-#[derive(Debug, PartialEq, Default, Clone)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct HirInterner {
-    pub outputs: IndexMap<PlaceKind, PackedOption<Value>, ahash::RandomState>,
+    pub outputs: IndexMap<PlaceKind, PackedOption<Value>, BuildHasherDefault<FxHasher>>,
     pub params: TiMap<Param, ParamKind, Value>,
     pub callbacks: TiSet<FuncRef, CallBackKind>,
     pub callback_uses: TiVec<FuncRef, Vec<Inst>>,
-    pub tagged_reads: IndexMap<Value, Variable, ahash::RandomState>,
+    pub tagged_reads: IndexMap<Value, Variable, BuildHasherDefault<FxHasher>>,
     pub implicit_equations: TiVec<ImplicitEquation, ImplicitEquationKind>,
     pub lim_state: TiMap<LimitState, Value, Vec<(Value, bool)>>,
 }
@@ -236,6 +238,20 @@ pub type LiveParams<'a> = FilterMap<
     fn((Param, (&'a ParamKind, &'a Value))) -> Option<(Param, &'a ParamKind, Value)>,
 >;
 
+impl Default for HirInterner {
+    fn default() -> Self {
+        Self {
+            outputs: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            params: TiMap::default(),
+            callbacks: TiSet::default(),
+            callback_uses: TiVec::default(),
+            tagged_reads: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            implicit_equations: TiVec::default(),
+            lim_state: TiMap::default(),
+        }
+    }
+}
+
 impl HirInterner {
     fn contains_ddx(
         ddx_calls: &mut AHashMap<FuncRef, (HybridBitSet<Unknown>, HybridBitSet<Unknown>)>,
diff --git a/openvaf/mir/Cargo.toml b/openvaf/mir/Cargo.toml
index 7b36c947e..591cd3d02 100644
--- a/openvaf/mir/Cargo.toml
+++ b/openvaf/mir/Cargo.toml
@@ -16,6 +16,7 @@ list_pool = {version = "0.0.0" , path = "../../lib/list_pool"}
 typed-index-collections = "3.1"
 lasso = {version = "0.7", features = ["ahash"]}
 ahash = "0.8"
+rustc-hash = "2.0"
 bitset = {version = "0.0.0", path = "../../lib/bitset" }
 typed_indexmap = { version = "0.0.0", path = "../../lib/typed_indexmap" }
 dot = "0.1.4"
diff --git a/openvaf/mir/src/serialize.rs b/openvaf/mir/src/serialize.rs
index 4dc09fe49..bfe158574 100644
--- a/openvaf/mir/src/serialize.rs
+++ b/openvaf/mir/src/serialize.rs
@@ -1,8 +1,9 @@
 use std::fmt::{self, Display, Write};
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use indexmap::{IndexMap, IndexSet};
 use lasso::Rodeo;
+use rustc_hash::FxHasher;
 
 use crate::{
     Block, Const, ControlFlowGraph, Function, Inst, InstructionData, Param, Value, ValueDef,
@@ -34,15 +35,15 @@ impl Function {
         mut param_name: impl FnMut(Param) -> (&'static str, String),
         outputs: impl Iterator<Item = (String, Value)>,
     ) -> String {
-        let mut inst_map = IndexSet::default();
-        let bb_map = cfg
+        let mut inst_map: IndexSet<Inst, BuildHasherDefault<FxHasher>> = IndexSet::default();
+        let bb_map: IndexSet<Block, BuildHasherDefault<FxHasher>> = cfg
             .reverse_postorder(self)
             .map(|bb| {
                 inst_map.extend(self.layout.block_insts(bb));
                 bb
             })
             .collect();
-        let mut val_map: IndexSet<Value, RandomState> = IndexSet::default();
+        let mut val_map: IndexSet<Value, BuildHasherDefault<FxHasher>> = IndexSet::default();
         for &inst in inst_map.iter() {
             if let InstructionData::PhiNode(phi) = &self.dfg.insts[inst] {
                 val_map.extend(self.dfg.phi_edges(phi).map(|(_, val)| val))
@@ -99,9 +100,9 @@ impl Function {
 struct Serializer<'a> {
     cfg: &'a ControlFlowGraph,
     func: &'a Function,
-    inst_map: &'a IndexSet<Inst, RandomState>,
-    bb_map: &'a IndexSet<Block, RandomState>,
-    val_map: &'a IndexSet<Value, RandomState>,
+    inst_map: &'a IndexSet<Inst, BuildHasherDefault<FxHasher>>,
+    bb_map: &'a IndexSet<Block, BuildHasherDefault<FxHasher>>,
+    val_map: &'a IndexSet<Value, BuildHasherDefault<FxHasher>>,
     inputs: &'a IndexMap<&'static str, Vec<(String, usize)>>,
     intern: &'a Rodeo,
     buf: String,
diff --git a/openvaf/mir_autodiff/Cargo.toml b/openvaf/mir_autodiff/Cargo.toml
index 42382dfcf..5aa8ff9fd 100644
--- a/openvaf/mir_autodiff/Cargo.toml
+++ b/openvaf/mir_autodiff/Cargo.toml
@@ -21,6 +21,7 @@ arena = { version = "0.0.0", path = "../../lib/arena" }
 indexmap = "2.0"
 typed-index-collections = "3.1"
 ahash = "0.8"
+rustc-hash = "2.0"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/mir_autodiff/src/builder.rs b/openvaf/mir_autodiff/src/builder.rs
index 0d608baa5..03ee0f3c5 100644
--- a/openvaf/mir_autodiff/src/builder.rs
+++ b/openvaf/mir_autodiff/src/builder.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
 use std::ops::Range;
 
 use ahash::AHashMap;
@@ -8,6 +10,7 @@ use mir::{
     Block, Function, Inst, InstructionData, Opcode, SourceLoc, Unknown, Value, F_LOG10_E, F_ONE,
     F_TWO, F_ZERO,
 };
+use rustc_hash::FxHasher;
 use stdx::iter::zip;
 use stdx::packed_option::{PackedOption, ReservedValue};
 
@@ -22,8 +25,8 @@ pub fn build_derivatives(
     intern: &mut DerivativeIntern,
     live_derivatives: &LiveDerivatives,
     post_order: &[Block],
-) -> AHashMap<(Value, Unknown), Value> {
-    let derivative_values: AHashMap<(Value, Unknown), Value> =
+) -> HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>> {
+    let derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>> =
         intern.unknowns.iter_enumerated().map(|(unknown, &val)| ((val, unknown), F_ONE)).collect();
 
     let mut known_values = BitSet::new_empty(func.dfg.num_values());
@@ -56,7 +59,7 @@ pub(crate) struct DerivativeBuilder<'a, 'u> {
     live_derivatives: &'a LiveDerivatives,
     intern: &'a mut DerivativeIntern<'u>,
 
-    derivative_values: AHashMap<(Value, Unknown), Value>,
+    derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     known_values: BitSet<Value>,
     dst: (Inst, SourceLoc),
     new_block: Option<Block>,
@@ -448,7 +451,7 @@ impl<'a, 'u> DerivativeBuilder<'a, 'u> {
 
     fn derivative_of_(
         intern: &DerivativeIntern,
-        derivative_values: &AHashMap<(Value, Unknown), Value>,
+        derivative_values: &HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
         mut val: Value,
         derivative: Derivative,
     ) -> Value {
diff --git a/openvaf/mir_autodiff/src/lib.rs b/openvaf/mir_autodiff/src/lib.rs
index 1de40e026..ccd29d988 100644
--- a/openvaf/mir_autodiff/src/lib.rs
+++ b/openvaf/mir_autodiff/src/lib.rs
@@ -4,12 +4,15 @@ mod live_derivatives;
 mod postorder;
 mod subgraph;
 
-use ahash::AHashMap;
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
+
 pub use builder::build_derivatives;
 pub use live_derivatives::LiveDerivatives;
 use mir::{
     DataFlowGraph, DominatorTree, Function, Inst, InstructionData, KnownDerivatives, Opcode, Value,
 };
+use rustc_hash::FxHasher;
 
 use crate::intern::{Derivative, DerivativeIntern};
 
@@ -18,7 +21,7 @@ pub fn auto_diff(
     dom_tree: &DominatorTree,
     derivatives: &KnownDerivatives,
     extra_derivatives: &[(Value, mir::Unknown)],
-) -> AHashMap<(Value, mir::Unknown), Value> {
+) -> HashMap<(Value, mir::Unknown), Value, BuildHasherDefault<FxHasher>> {
     let func = func.as_mut();
     let mut intern = DerivativeIntern::new(derivatives);
     let live_derivative = LiveDerivatives::build(func, &mut intern, extra_derivatives, dom_tree);
diff --git a/openvaf/mir_autodiff/src/subgraph.rs b/openvaf/mir_autodiff/src/subgraph.rs
index d94b8a47a..107b03723 100644
--- a/openvaf/mir_autodiff/src/subgraph.rs
+++ b/openvaf/mir_autodiff/src/subgraph.rs
@@ -1,8 +1,10 @@
+use std::hash::BuildHasherDefault;
 use std::mem::{replace, take};
 
 use bitset::{BitSet, HybridBitSet, SparseBitSet};
 use indexmap::IndexMap;
 use mir::{Block, DominatorTree, Function, Inst, Opcode, Unknown, Value, ValueDef};
+use rustc_hash::FxHasher;
 
 use crate::intern::{Derivative, DerivativeInfo, DerivativeIntern};
 use crate::{zero_derivative, ChainRule, LiveDerivatives};
@@ -24,7 +26,7 @@ struct SubGraphExplorer<'a, 'b> {
     saved_insts: i32,
     completed_subgraphs: Vec<HybridBitSet<Unknown>>,
 
-    derivative_map: IndexMap<Derivative, (Derivative, Derivative), ahash::RandomState>,
+    derivative_map: IndexMap<Derivative, (Derivative, Derivative), BuildHasherDefault<FxHasher>>,
 }
 
 impl<'a, 'b> SubGraphExplorer<'a, 'b> {
diff --git a/openvaf/mir_opt/Cargo.toml b/openvaf/mir_opt/Cargo.toml
index 53c21086e..64f9fb59c 100644
--- a/openvaf/mir_opt/Cargo.toml
+++ b/openvaf/mir_opt/Cargo.toml
@@ -17,8 +17,8 @@ workqueue = {version = "0.0.0", path = "../../lib/workqueue" }
 bitset = {version = "0.0.0", path = "../../lib/bitset" }
 
 typed-index-collections = "3.1"
-ahash = "0.8"
 hashbrown = {version = "0.14", features = ["raw"]}
+rustc-hash = "2.1"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/mir_opt/src/global_value_numbering.rs b/openvaf/mir_opt/src/global_value_numbering.rs
index f96fd9e85..4d8ccafa6 100644
--- a/openvaf/mir_opt/src/global_value_numbering.rs
+++ b/openvaf/mir_opt/src/global_value_numbering.rs
@@ -1,15 +1,15 @@
 use std::cmp::Ordering;
-use std::hash::{BuildHasher, Hash, Hasher};
+use std::hash::{BuildHasher, BuildHasherDefault, Hash, Hasher};
 use std::mem::{swap, ManuallyDrop};
 use std::ops::{Index, IndexMut};
 
-use ahash::RandomState;
 use bitset::{BitSet, HybridBitSet};
 use hashbrown::raw::RawTable;
 use mir::{
     Block, DominatorTree, FuncRef, Function, Inst, InstructionData, Opcode, Value, ValueDef,
     ValueList,
 };
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_idx_from, impl_idx_math};
 use typed_index_collections::TiVec;
@@ -188,7 +188,7 @@ impl GVNExpression {
         }
     }
 
-    fn hash(&self, state: &RandomState, func: &Function) -> u64 {
+    fn hash(&self, state: &BuildHasherDefault<FxHasher>, func: &Function) -> u64 {
         let mut hasher = state.build_hasher();
         self.opcode.hash(&mut hasher);
         match self.opcode {
@@ -354,7 +354,7 @@ struct ClassMap {
     inst_class: TiVec<Inst, PackedOption<ClassId>>,
     expr_class: RawTable<ClassId>,
     classes: TiVec<ClassId, EquivalenceClass>,
-    state: RandomState,
+    state: BuildHasherDefault<FxHasher>,
 }
 
 impl ClassMap {
diff --git a/openvaf/osdi/Cargo.toml b/openvaf/osdi/Cargo.toml
index 8e59d3b8c..4b186a079 100644
--- a/openvaf/osdi/Cargo.toml
+++ b/openvaf/osdi/Cargo.toml
@@ -28,7 +28,7 @@ llvm-sys = "181.1.1"
 target = { version = "0.0.0", path = "../target"}
 
 typed-index-collections = "3.1"
-ahash = "0.8"
+rustc-hash = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
 
 salsa = "0.17.0-pre.2"
diff --git a/openvaf/osdi/src/inst_data.rs b/openvaf/osdi/src/inst_data.rs
index 189aa857a..b8fd1db3e 100644
--- a/openvaf/osdi/src/inst_data.rs
+++ b/openvaf/osdi/src/inst_data.rs
@@ -1,7 +1,7 @@
 use core::ffi::c_uint;
 use core::ptr::NonNull;
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use hir::{CompilationDB, ParamSysFun, Parameter, Variable};
 use hir_lower::{HirInterner, LimitState, ParamKind, PlaceKind};
 use indexmap::IndexMap;
@@ -21,6 +21,7 @@ use llvm_sys::target::{LLVMOffsetOfElement, LLVMTargetDataRef};
 use llvm_sys::LLVMIntPredicate;
 use mir::{strip_optbarrier, Const, Function, Param, ValueDef, F_ZERO};
 use mir_llvm::{CodegenCx, MemLoc, UNNAMED};
+use rustc_hash::FxHasher;
 use sim_back::dae::{self, MatrixEntryId, SimUnknown};
 use sim_back::init::CacheSlot;
 use stdx::packed_option::PackedOption;
@@ -212,13 +213,13 @@ pub struct OsdiInstanceData<'ll> {
     pub collapsed: &'ll llvm_sys::LLVMType,
 
     // llvm types for dynamic instance data struct fields
-    pub params: IndexMap<OsdiInstanceParam, &'ll llvm_sys::LLVMType, RandomState>,
+    pub params: IndexMap<OsdiInstanceParam, &'ll llvm_sys::LLVMType, BuildHasherDefault<FxHasher>>,
     pub eval_outputs: TiMap<EvalOutputSlot, mir::Value, &'ll llvm_sys::LLVMType>,
     pub cache_slots: TiVec<CacheSlot, &'ll llvm_sys::LLVMType>,
 
     pub residual: TiVec<SimUnknown, Residual>,
     pub noise: Vec<NoiseSource>,
-    pub opvars: IndexMap<Variable, EvalOutput, RandomState>,
+    pub opvars: IndexMap<Variable, EvalOutput, BuildHasherDefault<FxHasher>>,
     pub jacobian: TiVec<MatrixEntryId, MatrixEntry>,
     pub bound_step: Option<EvalOutputSlot>,
 }
@@ -244,21 +245,17 @@ impl<'ll> OsdiInstanceData<'ll> {
         let user_inst_params = module.info.params.iter().filter_map(|(param, info)| {
             info.is_instance.then(|| (OsdiInstanceParam::User(*param), lltype(&param.ty(db), cx)))
         });
-        let params: IndexMap<_, _, _> =
-            builtin_inst_params.chain(alias_inst_params).chain(user_inst_params).collect();
+        let mut params = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        params.extend(builtin_inst_params.chain(alias_inst_params).chain(user_inst_params));
 
         let mut eval_outputs = TiMap::default();
-        let opvars = module
-            .info
-            .op_vars
-            .keys()
-            .map(|var| {
-                let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked();
-                let ty = lltype(&var.ty(db), cx);
-                let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty);
-                (*var, pos)
-            })
-            .collect();
+        let mut opvars = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        opvars.extend(module.info.op_vars.keys().map(|var| {
+            let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked();
+            let ty = lltype(&var.ty(db), cx);
+            let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty);
+            (*var, pos)
+        }));
         let residual = module
             .dae_system
             .residual
diff --git a/openvaf/osdi/src/lib.rs b/openvaf/osdi/src/lib.rs
index 970d2ac6c..c94e375b9 100644
--- a/openvaf/osdi/src/lib.rs
+++ b/openvaf/osdi/src/lib.rs
@@ -1,8 +1,11 @@
 use std::collections::HashMap;
 use std::ffi::CString;
+use std::hash::BuildHasherDefault;
 use std::ptr::NonNull;
 use std::sync::{Arc, Mutex};
 
+use rustc_hash::FxHasher;
+
 use base_n::CASE_INSENSITIVE;
 use camino::{Utf8Path, Utf8PathBuf};
 use hir::{CompilationDB, ParamSysFun, Type};
@@ -115,8 +118,9 @@ pub fn compile<'a>(
 
     let main_file = dst.with_extension("o");
 
-    let unoptirs = Arc::new(Mutex::new(HashMap::new()));
-    let irs = Arc::new(Mutex::new(HashMap::new()));
+    let unoptirs =
+        Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default())));
+    let irs = Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default())));
 
     // Build natures, disciplines, and attributes vectors, intern strings in Rodeo
     let (natures_vec, disciplines_vec, attributes_vec) = nda_arrays(&*db, &mut literals);
diff --git a/openvaf/osdi/src/model_data.rs b/openvaf/osdi/src/model_data.rs
index 0d2bc2f09..6b9b199ba 100644
--- a/openvaf/osdi/src/model_data.rs
+++ b/openvaf/osdi/src/model_data.rs
@@ -1,11 +1,12 @@
 use core::ptr::NonNull;
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use hir::{CompilationDB, Parameter};
 use indexmap::IndexMap;
 use llvm_sys::core::{LLVMBuildLoad2, LLVMBuildStore, LLVMBuildStructGEP2};
 use llvm_sys::LLVMValue as Value;
 use mir_llvm::{CodegenCx, MemLoc, UNNAMED};
+use rustc_hash::FxHasher;
 
 use crate::compilation_unit::OsdiModule;
 use crate::inst_data::{OsdiInstanceData, OsdiInstanceParam};
@@ -15,7 +16,7 @@ const NUM_CONST_FIELDS: u32 = 1;
 
 pub struct OsdiModelData<'ll> {
     pub param_given: &'ll llvm_sys::LLVMType,
-    pub params: IndexMap<Parameter, &'ll llvm_sys::LLVMType, RandomState>,
+    pub params: IndexMap<Parameter, &'ll llvm_sys::LLVMType, BuildHasherDefault<FxHasher>>,
     pub ty: &'ll llvm_sys::LLVMType,
 }
 
@@ -27,18 +28,14 @@ impl<'ll> OsdiModelData<'ll> {
         inst_data: &OsdiInstanceData<'ll>,
     ) -> Self {
         let inst_params = &inst_data.params;
-        let params: IndexMap<_, _, _> = cgunit
-            .info
-            .params
-            .keys()
-            .filter_map(|param| {
-                if inst_params.contains_key(&OsdiInstanceParam::User(*param)) {
-                    None
-                } else {
-                    Some((*param, lltype(&param.ty(db), cx)))
-                }
-            })
-            .collect();
+        let mut params = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        params.extend(cgunit.info.params.keys().filter_map(|param| {
+            if inst_params.contains_key(&OsdiInstanceParam::User(*param)) {
+                None
+            } else {
+                Some((*param, lltype(&param.ty(db), cx)))
+            }
+        }));
 
         let param_given = bitfield::arr_ty((inst_params.len() + params.len()) as u32, cx);
 
diff --git a/openvaf/sim_back/Cargo.toml b/openvaf/sim_back/Cargo.toml
index 31fc5282f..ec2fda79d 100644
--- a/openvaf/sim_back/Cargo.toml
+++ b/openvaf/sim_back/Cargo.toml
@@ -24,6 +24,7 @@ mir_opt = { version = "0.0.0", path = "../mir_opt" }
 
 typed-index-collections = "3.1"
 ahash = "0.8"
+rustc-hash = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
 
 indexmap = "2.0"
diff --git a/openvaf/sim_back/src/dae.rs b/openvaf/sim_back/src/dae.rs
index 57b4c7be0..2e22fd502 100644
--- a/openvaf/sim_back/src/dae.rs
+++ b/openvaf/sim_back/src/dae.rs
@@ -1,5 +1,8 @@
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexSet;
 use mir::{strip_optbarrier, Value, F_ZERO};
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
 use typed_indexmap::TiSet;
@@ -40,7 +43,7 @@ pub struct DaeSystem {
     pub jacobian: TiVec<MatrixEntryId, MatrixEntry>,
     /// list of parameter which are known to be small signal values (always zero during
     /// large signal simulation).
-    pub small_signal_parameters: IndexSet<Value, ahash::RandomState>,
+    pub small_signal_parameters: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     /// noise
     pub noise_sources: Vec<NoiseSource>,
     /// model inputs (node pairs)
diff --git a/openvaf/sim_back/src/dae/builder.rs b/openvaf/sim_back/src/dae/builder.rs
index 2fa47016b..3c6b6d4b6 100644
--- a/openvaf/sim_back/src/dae/builder.rs
+++ b/openvaf/sim_back/src/dae/builder.rs
@@ -1,7 +1,3 @@
-use std::mem::replace;
-use std::vec;
-
-use ahash::AHashMap;
 use bitset::BitSet;
 use hir::{BranchWrite, CompilationDB, Node, ParamSysFun};
 use hir_lower::{CurrentKind, HirInterner, ImplicitEquation, ParamKind};
@@ -13,6 +9,11 @@ use mir::{
     Value, FALSE, F_ONE, F_ZERO, TRUE,
 };
 use mir_autodiff::auto_diff;
+use rustc_hash::FxHasher;
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
+use std::mem::replace;
+use std::vec;
 use typed_index_collections::TiVec;
 
 use crate::context::Context;
@@ -122,7 +123,7 @@ impl<'a> Builder<'a> {
 
     pub(super) fn with_small_signal_network(
         mut self,
-        small_signal_parameters: IndexSet<Value, ahash::RandomState>,
+        small_signal_parameters: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     ) -> Self {
         self.system.small_signal_parameters = small_signal_parameters;
         self
@@ -219,7 +220,7 @@ impl<'a> Builder<'a> {
     fn build_lim_rhs(
         &mut self,
         derivative_info: &KnownDerivatives,
-        derivatives: AHashMap<(Value, Unknown), Value>,
+        derivatives: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     ) {
         for residual in &mut self.system.residual {
             for (state, (unchanged, lim_vals)) in self.intern.lim_state.iter_enumerated() {
@@ -272,7 +273,7 @@ impl<'a> Builder<'a> {
         &mut self,
         sim_unknown_reads: &[(ParamKind, Value)],
         derivative_info: &KnownDerivatives,
-        derivatives: &AHashMap<(Value, Unknown), Value>,
+        derivatives: &HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     ) {
         self.system.jacobian =
             TiVec::with_capacity(self.system.unknowns.len() * self.system.unknowns.len());
diff --git a/openvaf/sim_back/src/init.rs b/openvaf/sim_back/src/init.rs
index aaab86318..9c3e4254f 100644
--- a/openvaf/sim_back/src/init.rs
+++ b/openvaf/sim_back/src/init.rs
@@ -1,4 +1,6 @@
-use ahash::{AHashMap, AHashSet, RandomState};
+use std::hash::BuildHasherDefault;
+
+use ahash::{AHashMap, AHashSet};
 use bitset::{BitSet, SparseBitMatrix};
 use hir::{CompilationDB, Type};
 use hir_lower::{HirInterner, ParamKind, PlaceKind};
@@ -10,6 +12,7 @@ use mir::{
     InstructionData, Opcode, Value, FALSE,
 };
 use mir_opt::{aggressive_dead_code_elimination, simplify_cfg, simplify_cfg_init, ClassId, GVN};
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_indexmap::TiMap;
@@ -31,7 +34,7 @@ impl_debug_display! {match CacheSlot{CacheSlot(id) => "cslot{id}";}}
 pub struct Initialization {
     pub func: Function,
     pub intern: HirInterner,
-    pub cached_vals: IndexMap<Value, CacheSlot, RandomState>,
+    pub cached_vals: IndexMap<Value, CacheSlot, BuildHasherDefault<FxHasher>>,
     pub cache_slots: TiMap<CacheSlot, (PackedOption<ClassId>, u32), hir::Type>,
 }
 
@@ -62,7 +65,7 @@ impl Initialization {
 
 struct Builder<'a> {
     init: Initialization,
-    init_cache: IndexMap<Value, Inst, RandomState>,
+    init_cache: IndexMap<Value, Inst, BuildHasherDefault<FxHasher>>,
     // inputs
     func: &'a mut Function,
     cfg: &'a mut ControlFlowGraph,
@@ -81,11 +84,17 @@ impl<'a> Builder<'a> {
         Builder {
             init: Initialization {
                 func: Function::with_name(format!("{}_init", &ctx.func.name)),
-                cached_vals: IndexMap::with_capacity_and_hasher(128, RandomState::new()),
+                cached_vals: IndexMap::with_capacity_and_hasher(
+                    128,
+                    BuildHasherDefault::<FxHasher>::default(),
+                ),
                 cache_slots: TiMap::default(),
                 intern: HirInterner::default(),
             },
-            init_cache: IndexMap::with_capacity_and_hasher(256, RandomState::default()),
+            init_cache: IndexMap::with_capacity_and_hasher(
+                256,
+                BuildHasherDefault::<FxHasher>::default(),
+            ),
             func: &mut ctx.func,
             cfg: &mut ctx.cfg,
             dom_tree: &mut ctx.dom_tree,
diff --git a/openvaf/sim_back/src/module_info.rs b/openvaf/sim_back/src/module_info.rs
index 20df49c41..2e33538b7 100644
--- a/openvaf/sim_back/src/module_info.rs
+++ b/openvaf/sim_back/src/module_info.rs
@@ -1,3 +1,5 @@
+use std::hash::BuildHasherDefault;
+
 use ahash::AHashSet;
 use hir::diagnostics::{BaseDB, ConsoleSink, Diagnostic, FileId, Label, LabelStyle, Report};
 use hir::{
@@ -5,6 +7,7 @@ use hir::{
     ResolvedAliasParameter, ScopeDef, Variable,
 };
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use smol_str::SmolStr;
 use syntax::ast::{self, Expr};
 use syntax::sourcemap::FileSpan;
@@ -42,9 +45,9 @@ pub fn collect_modules(
 
 pub struct ModuleInfo {
     pub module: Module,
-    pub params: IndexMap<Parameter, ParamInfo, ahash::RandomState>,
-    pub sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, ahash::RandomState>,
-    pub op_vars: IndexMap<Variable, OpVar, ahash::RandomState>,
+    pub params: IndexMap<Parameter, ParamInfo, BuildHasherDefault<FxHasher>>,
+    pub sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, BuildHasherDefault<FxHasher>>,
+    pub op_vars: IndexMap<Variable, OpVar, BuildHasherDefault<FxHasher>>,
 }
 
 impl ModuleInfo {
@@ -55,10 +58,12 @@ impl ModuleInfo {
         sink: &mut ConsoleSink,
         all_vars_opvars: bool,
     ) -> ModuleInfo {
-        let mut params: IndexMap<Parameter, ParamInfo, ahash::RandomState> = IndexMap::default();
-        let mut sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, ahash::RandomState> =
+        let mut params: IndexMap<Parameter, ParamInfo, BuildHasherDefault<FxHasher>> =
+            IndexMap::default();
+        let mut sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, BuildHasherDefault<FxHasher>> =
+            IndexMap::default();
+        let mut op_vars: IndexMap<Variable, OpVar, BuildHasherDefault<FxHasher>> =
             IndexMap::default();
-        let mut op_vars = IndexMap::default();
 
         let ast = cu.ast(db);
 
diff --git a/openvaf/sim_back/src/topology.rs b/openvaf/sim_back/src/topology.rs
index 2a31741c2..0133e1993 100644
--- a/openvaf/sim_back/src/topology.rs
+++ b/openvaf/sim_back/src/topology.rs
@@ -17,6 +17,8 @@
 //!   generation of unnecessary derivatives.
 //!
 
+use std::hash::BuildHasherDefault;
+
 use ahash::AHashMap;
 use bitset::{BitSet, SparseBitMatrix};
 use hir_lower::{CallBackKind, HirInterner, ImplicitEquation, ParamKind, PlaceKind};
@@ -25,6 +27,7 @@ use lasso::Spur;
 use mir::{strip_optbarrier, Function, Inst, Value, F_ZERO, TRUE};
 use mir_build::SSAVariableBuilder;
 use mir_opt::simplify_cfg_no_phi_merge;
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
 use typed_indexmap::TiMap;
@@ -150,7 +153,7 @@ impl Noise {
 pub(crate) struct Topology {
     pub(crate) branches: TiMap<BranchId, BranchWrite, BranchInfo>,
     pub(crate) implicit_equations: TiVec<ImplicitEquation, Contribution>,
-    pub(crate) small_signal_vals: IndexSet<Value, ahash::RandomState>,
+    pub(crate) small_signal_vals: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     contributes: AHashMap<Value, ContributeKind>,
 }
 
@@ -284,7 +287,7 @@ impl Topology {
             implicit_equations,
             small_signal_vals: IndexSet::with_capacity_and_hasher(
                 128,
-                ahash::RandomState::default(),
+                BuildHasherDefault::<FxHasher>::default(),
             ),
         };
         let num_insts = ctx.func.dfg.num_insts();
diff --git a/openvaf/sim_back/src/topology/small_signal_network.rs b/openvaf/sim_back/src/topology/small_signal_network.rs
index 45da1a708..1090dc820 100644
--- a/openvaf/sim_back/src/topology/small_signal_network.rs
+++ b/openvaf/sim_back/src/topology/small_signal_network.rs
@@ -1,9 +1,11 @@
+use std::hash::BuildHasherDefault;
 use std::iter::once;
 use std::mem::take;
 
 use hir::Node;
 use indexmap::IndexMap;
 use mir::{Const, InstructionData, Opcode, Value, ValueDef, FALSE, F_ZERO};
+use rustc_hash::FxHasher;
 
 use crate::topology::Builder;
 use crate::util::{add, update_optbarrier};
@@ -305,7 +307,8 @@ impl Builder<'_> {
     }
 
     fn collect_candidates(&mut self) -> Vec<Candidate> {
-        let mut nodes = IndexMap::with_capacity_and_hasher(32, ahash::RandomState::new());
+        let mut nodes =
+            IndexMap::with_capacity_and_hasher(32, BuildHasherDefault::<FxHasher>::default());
         let mut candidates = Vec::new();
         for (_, (&branch, contributes)) in self.topology.branches() {
             let (hi, lo) = branch.nodes(self.db);
diff --git a/openvaf/vfs/Cargo.toml b/openvaf/vfs/Cargo.toml
index cac615bac..405ad174a 100644
--- a/openvaf/vfs/Cargo.toml
+++ b/openvaf/vfs/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 
 paths = {path="../../lib/paths",version="0.0.0"}
 indexmap = "2.0"
-ahash = "0.8"
+rustc-hash = "2.0"
 encoding_rs = "0.8"
 chardetng = "0.1"
 
diff --git a/openvaf/vfs/src/path_interner.rs b/openvaf/vfs/src/path_interner.rs
index 027cd8bf1..c7409e582 100644
--- a/openvaf/vfs/src/path_interner.rs
+++ b/openvaf/vfs/src/path_interner.rs
@@ -2,14 +2,17 @@
 //! no longer exist -- the assumption is total size of paths we ever look at is
 //! not too big.
 
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexSet;
+use rustc_hash::FxHasher;
 
 use crate::{FileId, VfsPath};
 
 /// Structure to map between [`VfsPath`] and [`FileId`].
 #[derive(Default, Debug)]
 pub(crate) struct PathInterner {
-    map: IndexSet<VfsPath, ahash::RandomState>,
+    map: IndexSet<VfsPath, BuildHasherDefault<FxHasher>>,
 }
 
 impl PathInterner {
diff --git a/sourcegen/src/hir_builtins.rs b/sourcegen/src/hir_builtins.rs
index 686f228b7..79e5637bd 100644
--- a/sourcegen/src/hir_builtins.rs
+++ b/sourcegen/src/hir_builtins.rs
@@ -292,18 +292,20 @@ fn generate_builtins() {
             }
         }
 
-        pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>){
+        pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>){
             #(dst.insert(#kw_types::#kws,BuiltIn::#variants.into());)*
         }
 
 
-        pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>){
+        pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>){
             #(dst.insert(sysfun::#params,ParamSysFun::#params.into());)*
         }
     };
 
-    let header = "use ahash::RandomState;
+    let header = "use std::hash::BuildHasherDefault;
+
         use indexmap::IndexMap;
+        use rustc_hash::FxHasher;
         use syntax::name::{kw, sysfun, Name};
 
         use crate::nameres::ScopeDefItem;