diff --git a/Control/Monad/Array.hs b/Control/Monad/Array.hs
--- a/Control/Monad/Array.hs
+++ b/Control/Monad/Array.hs
@@ -1,8 +1,9 @@
 {-# LANGUAGE StandaloneDeriving, UnboxedTuples, MagicHash, RankNTypes, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances, GeneralizedNewtypeDeriving #-}
 
-module Control.Monad.Array (module Control.Monad.Array.Class, module Control.Monad.Array.ArrayT, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap) where
+module Control.Monad.Array (module Control.Monad.Array.Class, module Control.Monad.Array.ArrayT, module Control.Monad.Array.MArray, module Control.Monad.Array.IntMap, module Control.Monad.Array.Unboxed) where
 
 import Control.Monad.Array.Class
 import Control.Monad.Array.ArrayT
 import Control.Monad.Array.MArray
 import Control.Monad.Array.IntMap
+import Control.Monad.Array.Unboxed
diff --git a/Control/Monad/Array/ArrayT.hs b/Control/Monad/Array/ArrayT.hs
--- a/Control/Monad/Array/ArrayT.hs
+++ b/Control/Monad/Array/ArrayT.hs
@@ -4,11 +4,11 @@
 module Control.Monad.Array.ArrayT (ArrayM, ArrayT, runArrayM, runArrayM_, runArrayT, runArrayT_) where
 
 import Control.Monad.Array.Class
+import Control.Monad.ST.Class
 
 import GHC.Exts
 import GHC.ST(ST(..))
 
-import Control.Monad.ST.Class
 import Control.Monad.State.Strict
 import Control.Monad.Reader.Class
 import Control.Monad.Writer.Class
@@ -48,6 +48,7 @@
 emptyElement = error "Undefined array element"
 
 instance (MonadST m, Monad m) => MonadArray (ArrayT e m) where
+	{-# SPECIALIZE instance MonadArray (ArrayM s e) #-}
 	{-# INLINE unsafeReadAt #-}
 	{-# INLINE unsafeWriteAt #-}
 	{-# INLINE askSize #-}
diff --git a/Control/Monad/Array/Unboxed.hs b/Control/Monad/Array/Unboxed.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Array/Unboxed.hs
@@ -0,0 +1,51 @@
+{-# LANGUAGE Rank2Types,  UndecidableInstances, MultiParamTypeClasses, TypeFamilies, FlexibleInstances, GeneralizedNewtypeDeriving #-}
+
+module Control.Monad.Array.Unboxed where
+
+import Control.Monad.ST.Class
+import Control.Monad.Array.Class
+
+import Data.Array.Vector
+
+import Control.Monad.ST
+import Control.Monad.State.Strict
+import Control.Monad.Reader
+import Control.Monad.Writer.Class
+
+type UArrayM s e = UArrayT e (ST s)
+newtype UArrayT e m a = UArrayT {runUArrayT :: StateT (MUArr e (StateThread m)) m a} deriving (Monad, MonadReader r, MonadWriter w, MonadIO, MonadFix)
+
+evalUArrayT :: (UA e, MonadST m, Monad m) => Int -> UArrayT e m a -> m a
+evalUArrayT n m = liftST (newMU n) >>= evalStateT (runUArrayT m)
+
+defaultUA :: UA e => e
+defaultUA = runST $ do	arr <- newMU 1
+			readMU arr 0
+
+evalUArrayM :: UA e => Int -> (forall s . UArrayM s e a) -> a
+evalUArrayM n m = runST (evalUArrayT n m)
+
+instance MonadTrans (UArrayT e) where
+	lift m = UArrayT (lift m)
+
+instance MonadState s m => MonadState s (UArrayT e m) where
+	get = lift get
+	put = lift . put
+
+-- instance MonadReader r m => MonadReader r (UArrayT e m) where
+-- 	ask = lift ask
+-- 	local f (UArrayT m) = UArrayT $ ReaderT $ \ r -> local f (runReaderT m r)
+
+instance (UA e, MonadST m, Monad m) => MonadArray (UArrayT e m) where
+	{-# SPECIALIZE instance UA e => MonadArray (UArrayM s e) #-}
+	type ArrayElem (UArrayT e m) = e
+	askSize = UArrayT $ gets lengthMU
+	readAt i = UArrayT $ gets (`readMU` i) >>= liftST
+	writeAt i x = UArrayT $ gets (\ arr -> writeMU arr i x) >>= liftST
+	resize n' = UArrayT $ do	n <- gets lengthMU
+					ice <- gets unsafeFreezeAllMU
+					put =<< liftST (do
+						noob <- newMU n'
+						copyMU noob 0 =<< ice
+						return noob)
+	askElems = UArrayT $ liftST =<< gets (liftM fromU . unsafeFreezeAllMU)
diff --git a/stateful-mtl.cabal b/stateful-mtl.cabal
--- a/stateful-mtl.cabal
+++ b/stateful-mtl.cabal
@@ -1,5 +1,5 @@
 name:		stateful-mtl
-version:	1.0.4
+version:	1.0.5
 synopsis:	Stateful monad transformers with pure evaluation semantics.
 description:	Stateful monad transformers with pure evaluation semantics, useful for monadically pulling out implementation details of array manipulation and operations in the ST monad.  Includes typeclasses suitable for guaranteeing single-threaded monad behavior, avoiding previously encountered problems with ST monad transformers.  This package remains in a state of flux, so please notify the author about features you like or dislike.
 tested-with:	GHC
@@ -8,7 +8,7 @@
 license-file:	LICENSE
 author:		Louis Wasserman
 maintainer:	wasserman.louis@gmail.com
-build-Depends:	base, array, ghc-prim, mtl, containers, MaybeT
+build-Depends:	base, array, ghc-prim, mtl, containers, MaybeT, uvector
 build-type:	Simple
-Exposed-modules:Control.Monad.Array, Control.Monad.Array.ArrayT, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.Trans.Operations
+Exposed-modules:Control.Monad.Array, Control.Monad.Array.ArrayT, Control.Monad.Array.IntMap, Control.Monad.Array.MArray, Control.Monad.Array.Class, Control.Monad.ST.Class, Control.Monad.Trans.Operations, Control.Monad.Array.Unboxed
 ghc-options: