diff --git a/src/dorkbox/collections/Collections.kt b/src/dorkbox/collections/Collections.kt
index c7a94e9..a5a8f0d 100644
--- a/src/dorkbox/collections/Collections.kt
+++ b/src/dorkbox/collections/Collections.kt
@@ -21,7 +21,7 @@ object Collections {
     /**
      * Gets the version number.
      */
-    const val version = "2.5"
+    const val version = "2.6"
 
     init {
         // Add this project to the updates system, which verifies this class + UUID + version information
diff --git a/src/dorkbox/collections/LockFreeArrayList.kt b/src/dorkbox/collections/LockFreeArrayList.kt
index 3df6858..7405367 100644
--- a/src/dorkbox/collections/LockFreeArrayList.kt
+++ b/src/dorkbox/collections/LockFreeArrayList.kt
@@ -17,7 +17,6 @@ package dorkbox.collections
 
 import java.io.Serializable
 import java.util.concurrent.atomic.*
-import kotlin.Array
 
 /**
  * This class uses the "single-writer-principle" for lock-free publication.
@@ -202,6 +201,13 @@ class LockFreeArrayList<E> : MutableList<E>, RandomAccess, Cloneable, Serializab
         return listRef[this] as ArrayList<E>
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing array
+     */
+    fun toList(): ArrayList<E> {
+        return ArrayList(listRef[this] as ArrayList<E>)
+    }
+
     // this must be at the end of the file!
     companion object {
         const val version = Collections.version
diff --git a/src/dorkbox/collections/LockFreeBiMap.kt b/src/dorkbox/collections/LockFreeBiMap.kt
index b54138c..a5d9c02 100644
--- a/src/dorkbox/collections/LockFreeBiMap.kt
+++ b/src/dorkbox/collections/LockFreeBiMap.kt
@@ -411,6 +411,20 @@ class LockFreeBiMap<K: Any, V: Any> : MutableMap<K, V>, Cloneable, Serializable
         @Suppress("UNCHECKED_CAST")
         get() = reverseREF[this].values as MutableCollection<K>
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): MutableMap<K, V> {
+        return HashMap(forwardREF[this] as MutableMap<K, V>)
+    }
+
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toReverseMap(): MutableMap<V, K> {
+        return HashMap(reverseREF[this] as MutableMap<V, K>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeHashMap.kt b/src/dorkbox/collections/LockFreeHashMap.kt
index d256115..a5b8fd5 100644
--- a/src/dorkbox/collections/LockFreeHashMap.kt
+++ b/src/dorkbox/collections/LockFreeHashMap.kt
@@ -193,6 +193,13 @@ class LockFreeHashMap<K: Any, V> : MutableMap<K, V>, Cloneable, Serializable {
         return mapREF[this].toString()
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): HashMap<K, V> {
+        return HashMap(mapREF[this] as HashMap<K, V>)
+    }
+
     // this must be at the end of the file!
     companion object {
         const val version = Collections.version
diff --git a/src/dorkbox/collections/LockFreeHashSet.kt b/src/dorkbox/collections/LockFreeHashSet.kt
index a60e145..df42f4d 100644
--- a/src/dorkbox/collections/LockFreeHashSet.kt
+++ b/src/dorkbox/collections/LockFreeHashSet.kt
@@ -17,7 +17,6 @@ package dorkbox.collections
 
 import java.io.Serializable
 import java.util.concurrent.atomic.*
-import kotlin.Array
 
 /**
  * This class uses the "single-writer-principle" for lock-free publication.
@@ -126,6 +125,13 @@ class LockFreeHashSet<E> : MutableSet<E>, Cloneable, Serializable {
         return setREF[this].toString()
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing set
+     */
+    fun toSet(): HashSet<E> {
+        return HashSet(setREF[this] as HashSet<E>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeIntBiMap.kt b/src/dorkbox/collections/LockFreeIntBiMap.kt
index 4011d9a..24260b0 100644
--- a/src/dorkbox/collections/LockFreeIntBiMap.kt
+++ b/src/dorkbox/collections/LockFreeIntBiMap.kt
@@ -349,7 +349,7 @@ class LockFreeIntBiMap<V: Any> : MutableMap<Int, V>, Cloneable, Serializable {
     override val entries: MutableSet<MutableMap.MutableEntry<Int, V>>
         // use the SWP to get a lock-free get of the value
         @Suppress("UNCHECKED_CAST")
-        get() = forwardREF[this].keys as MutableSet<MutableMap.MutableEntry<Int, V>>
+        get() = forwardREF[this].entries as MutableSet<MutableMap.MutableEntry<Int, V>>
 
 
 
@@ -421,6 +421,21 @@ class LockFreeIntBiMap<V: Any> : MutableMap<Int, V>, Cloneable, Serializable {
         // use the SWP to get a lock-free get of the value
         get() = reverseREF[this].values
 
+
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): IntMap<V> {
+        return IntMap(forwardREF[this] as IntMap<V>)
+    }
+
+    /**
+     * Return a non-thread-safe copy of the backing reverse-map
+     */
+    fun toReverseMap(): ObjectIntMap<V> {
+        return ObjectIntMap(reverseREF[this] as ObjectIntMap<V>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeIntMap.kt b/src/dorkbox/collections/LockFreeIntMap.kt
index b448bc1..f5cec15 100644
--- a/src/dorkbox/collections/LockFreeIntMap.kt
+++ b/src/dorkbox/collections/LockFreeIntMap.kt
@@ -213,6 +213,13 @@ class LockFreeIntMap<V> : MutableMap<Int, V>, Cloneable, Serializable {
         mapREF[this].shrink(maximumCapacity)
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): IntMap<V> {
+        return IntMap(mapREF[this] as IntMap<V>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeIntStringMap.kt b/src/dorkbox/collections/LockFreeIntStringMap.kt
index b7a9317..e70afaf 100644
--- a/src/dorkbox/collections/LockFreeIntStringMap.kt
+++ b/src/dorkbox/collections/LockFreeIntStringMap.kt
@@ -197,6 +197,14 @@ class LockFreeIntStringMap : MutableMap<Int, String?>, Cloneable, Serializable {
         return mapREF[this].toString()
     }
 
+
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): IntMap<String?> {
+        return IntMap(mapREF[this] as IntMap<String?>)
+    }
+
     // this must be at the end of the file!
     companion object {
         const val version = Collections.version
diff --git a/src/dorkbox/collections/LockFreeLongMap.kt b/src/dorkbox/collections/LockFreeLongMap.kt
index f845de9..9c8acce 100644
--- a/src/dorkbox/collections/LockFreeLongMap.kt
+++ b/src/dorkbox/collections/LockFreeLongMap.kt
@@ -213,6 +213,14 @@ class LockFreeLongMap<V> : MutableMap<Long, V>, Cloneable, Serializable {
         mapREF[this].shrink(maximumCapacity)
     }
 
+
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): LongMap<V> {
+        return LongMap(mapREF[this] as LongMap<V>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeObjectBiMap.kt b/src/dorkbox/collections/LockFreeObjectBiMap.kt
index 6ca1f6c..a060cae 100644
--- a/src/dorkbox/collections/LockFreeObjectBiMap.kt
+++ b/src/dorkbox/collections/LockFreeObjectBiMap.kt
@@ -418,6 +418,20 @@ class LockFreeObjectBiMap<K: Any, V: Any> : MutableMap<K, V>, Cloneable, Seriali
         @Suppress("UNCHECKED_CAST")
         get() = reverseREF[this].values as MutableCollection<K>
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): ObjectMap<K, V> {
+        return ObjectMap(forwardREF[this] as ObjectMap<K, V>)
+    }
+
+    /**
+     * Return a non-thread-safe copy of the backing reverse-map
+     */
+    fun toReverseMap(): ObjectMap<V, K> {
+        return ObjectMap(reverseREF[this] as ObjectMap<V, K>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeObjectIntBiMap.kt b/src/dorkbox/collections/LockFreeObjectIntBiMap.kt
index b567414..3ee2f2c 100644
--- a/src/dorkbox/collections/LockFreeObjectIntBiMap.kt
+++ b/src/dorkbox/collections/LockFreeObjectIntBiMap.kt
@@ -428,6 +428,21 @@ class LockFreeObjectIntBiMap<K: Any> : MutableMap<K, Int>, Cloneable, Serializab
         @Suppress("UNCHECKED_CAST")
         get() = reverseREF[this].values as MutableCollection<K>
 
+
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): ObjectIntMap<K> {
+        return ObjectIntMap(forwardREF[this] as ObjectIntMap<K>)
+    }
+
+    /**
+     * Return a non-thread-safe copy of the backing reverse-map
+     */
+    fun toReverseMap(): IntMap<K> {
+        return IntMap(reverseREF[this] as IntMap<K>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeObjectIntMap.kt b/src/dorkbox/collections/LockFreeObjectIntMap.kt
index fe62790..ddd54ec 100644
--- a/src/dorkbox/collections/LockFreeObjectIntMap.kt
+++ b/src/dorkbox/collections/LockFreeObjectIntMap.kt
@@ -210,6 +210,13 @@ class LockFreeObjectIntMap<K: Any> : MutableMap<K, Int>, Cloneable, Serializable
         mapREF[this].shrink(maximumCapacity)
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): ObjectIntMap<K> {
+        return ObjectIntMap(mapREF[this] as ObjectIntMap<K>)
+    }
+
     companion object {
         const val version = Collections.version
 
diff --git a/src/dorkbox/collections/LockFreeObjectMap.kt b/src/dorkbox/collections/LockFreeObjectMap.kt
index 493ec1d..8a2c972 100644
--- a/src/dorkbox/collections/LockFreeObjectMap.kt
+++ b/src/dorkbox/collections/LockFreeObjectMap.kt
@@ -217,6 +217,13 @@ class LockFreeObjectMap<K: Any, V> : MutableMap<K, V>, Cloneable, Serializable {
         mapREF[this].shrink(maximumCapacity)
     }
 
+    /**
+     * Return a non-thread-safe copy of the backing map
+     */
+    fun toMap(): ObjectMap<K, V> {
+        return ObjectMap(mapREF[this] as ObjectMap<K, V>)
+    }
+
     companion object {
         const val version = Collections.version