diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for describe
 
+## 0.2.0.1 -- 2019-10-06
+
+* Exposed hidden instances.
+
 ## 0.2.0.0 -- 2019-10-06
 
 * Added `Describe` type class.
diff --git a/describe.cabal b/describe.cabal
--- a/describe.cabal
+++ b/describe.cabal
@@ -3,7 +3,7 @@
 --   For further documentation, see http://haskell.org/cabal/users-guide/
 
 name:                describe
-version:             0.2.0.0
+version:             0.2.0.1
 synopsis:            Combinators for describing binary data structures
 description:         Combinators for describing binary data structures, which eliminate the boilerplate of having to write isomorphic Get and Put instances. Please see the Github page for examples.
 homepage:            https://github.com/riugabachi/describe
@@ -23,6 +23,7 @@
                       MultiParamTypeClasses,
                       AllowAmbiguousTypes,
                       FunctionalDependencies,
+                      TypeFamilies,
                       TypeOperators,
                       FlexibleContexts,
                       DefaultSignatures,
@@ -44,6 +45,7 @@
   import: deps
   exposed-modules:     Data.Serialize.Describe,
                        Data.Serialize.Describe.Descriptor,
+                       Data.Serialize.Describe.Endianness,
                        Data.Serialize.Describe.Combinators,
                        Data.Serialize.Describe.Combinators.LE,
                        Data.Serialize.Describe.Combinators.BE,
diff --git a/src/Data/Serialize/Describe/Class.hs b/src/Data/Serialize/Describe/Class.hs
--- a/src/Data/Serialize/Describe/Class.hs
+++ b/src/Data/Serialize/Describe/Class.hs
@@ -3,9 +3,19 @@
 ) where
 
 import GHC.Generics
+import GHC.TypeNats
 import Control.Monad
+import qualified Data.Vector.Fixed as V
+import Data.Vector.Fixed.Boxed (Vec)
+import Data.Int
+import Data.Proxy
+import Data.Word
 import Data.Serialize.Describe.Descriptor
+import Data.Serialize.Describe.Endianness
+import qualified Data.Serialize.Describe.Combinators.LE as LE
+import qualified Data.Serialize.Describe.Combinators.BE as BE
 
+
 class Describe a where
   describe :: (s -> a) -> Descriptor s a
 
@@ -34,3 +44,67 @@
     where
       extract (K1 x) = x
 
+instance Describe Bool where
+    describe f = toEnum . fromIntegral <$> describe (fromIntegral @_ @Word8 . fromEnum . f)
+
+instance Describe Word8 where
+    describe f = Descriptor (unwrapGet (LE.w8 f), \s -> unwrapPut s (LE.w8 f >> pure (f s)))
+
+instance Describe (LE Word16) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.w16 (unwrapLE . f)), \s -> unwrapPut s (LE.w16 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (LE Word32) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.w32 (unwrapLE . f)), \s -> unwrapPut s (LE.w32 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (LE Word64) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.w64 (unwrapLE . f)), \s -> unwrapPut s (LE.w64 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (BE Word16) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.w16 (unwrapBE . f)), \s -> unwrapPut s (BE.w16 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (BE Word32) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.w32 (unwrapBE . f)), \s -> unwrapPut s (BE.w32 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (BE Word64) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.w64 (unwrapBE . f)), \s -> unwrapPut s (BE.w64 (unwrapBE . f) >> pure (f s)))
+
+instance Describe Int8 where
+    describe f = Descriptor (unwrapGet (LE.i8 f), \s -> unwrapPut s (LE.i8 f >> pure (f s)))
+
+instance Describe (LE Int16) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.i16 (unwrapLE . f)), \s -> unwrapPut s (LE.i16 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (LE Int32) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.i32 (unwrapLE . f)), \s -> unwrapPut s (LE.i32 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (LE Int64) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.i64 (unwrapLE . f)), \s -> unwrapPut s (LE.i64 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (BE Int16) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.i16 (unwrapBE . f)), \s -> unwrapPut s (BE.i16 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (BE Int32) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.i32 (unwrapBE . f)), \s -> unwrapPut s (BE.i32 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (BE Int64) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.i64 (unwrapBE . f)), \s -> unwrapPut s (BE.i64 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (LE Float) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.f32 (unwrapLE . f)), \s -> unwrapPut s (LE.f32 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (LE Double) where
+    describe f = Descriptor (unwrapGet (LE <$> LE.f64 (unwrapLE . f)), \s -> unwrapPut s (LE.f64 (unwrapLE . f) >> pure (f s)))
+
+instance Describe (BE Float) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.f32 (unwrapBE . f)), \s -> unwrapPut s (BE.f32 (unwrapBE . f) >> pure (f s)))
+
+instance Describe (BE Double) where
+    describe f = Descriptor (unwrapGet (BE <$> BE.f64 (unwrapBE . f)), \s -> unwrapPut s (BE.f64 (unwrapBE . f) >> pure (f s)))
+
+instance Describe () where
+  describe _ = pure ()
+
+instance (Describe a, V.Arity n, V.Vector (Vec n) a, KnownNat n) => Describe (Vec n a) where
+    describe f =
+       V.fromList <$> forM [0..fromIntegral (natVal (Proxy :: Proxy n))-1] 
+        (\i -> describe $ (V.! i) . f)
diff --git a/src/Data/Serialize/Describe/Combinators.hs b/src/Data/Serialize/Describe/Combinators.hs
--- a/src/Data/Serialize/Describe/Combinators.hs
+++ b/src/Data/Serialize/Describe/Combinators.hs
@@ -1,8 +1,7 @@
+-- | Various type-level combinators to ease generic derivation of 'Describe'
 module Data.Serialize.Describe.Combinators(
   Optional(..),
-  StaticPred(..),
-  LE(..),
-  BE(..)
+  StaticPred(..)
 ) where
 
 import GHC.TypeNats
@@ -11,10 +10,6 @@
 import Data.Serialize.Describe.Descriptor
 import Data.Serialize.Describe.Class
 import qualified Data.Serialize.Get as G
-
-newtype LE a = LE { unwrapLE :: a }
-
-newtype BE a = BE { unwrapBE :: a }
 
 newtype Optional p t = Optional { unwrapOptional :: Maybe t }
 
diff --git a/src/Data/Serialize/Describe/Endianness.hs b/src/Data/Serialize/Describe/Endianness.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Serialize/Describe/Endianness.hs
@@ -0,0 +1,9 @@
+module Data.Serialize.Describe.Endianness(
+  LE(..),
+  BE(..)
+) where
+
+newtype LE a = LE { unwrapLE :: a }
+
+newtype BE a = BE { unwrapBE :: a }
+