diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 CHANGELOG](http://keepachangelog.com/). This project adheres to [Semantic
 Versioning](http://semver.org/).
 
+## [0.5.1] - 2015-09-01
+### Fixed
+- Intances of `Word` and `Int` now stop generating at its maxium bound.
+
 ## [0.5] - 2015-08-31
 ### Changed
 - `Text` and `ByteString` Serial instances are now exhaustive.
diff --git a/Test/SmallCheck/Series/Instances.hs b/Test/SmallCheck/Series/Instances.hs
--- a/Test/SmallCheck/Series/Instances.hs
+++ b/Test/SmallCheck/Series/Instances.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE MultiWayIf #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 {-|
 'Serial' instances are provided for the following types:
@@ -33,68 +34,74 @@
 module Test.SmallCheck.Series.Instances () where
 
 #if !MIN_VERSION_base(4,8,0)
-import Control.Applicative ((<$>))
+import Control.Applicative ((<$>), pure)
 #endif
+import Control.Applicative ((<|>), empty)
 import Data.Int
 import Data.Word
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy as BL
 import qualified Data.Text as T
 import qualified Data.Text.Lazy as TL
-import Data.Map
+import Data.Map (Map)
 import qualified Data.Map as Map
 import Test.SmallCheck.Series
+import Control.Monad.Logic (interleave)
 
-instance Monad m => Serial m Int8 where
-    series = (fromIntegral :: Int -> Int8) <$> series
-instance Monad m => CoSerial m Int8 where
-    coseries rs = (. (fromIntegral :: Int8 -> Int)) <$> coseries rs
+instance Monad m => Serial m Int8 where series = ints
+instance Monad m => CoSerial m Int8 where coseries = coInts
 
-instance Monad m => Serial m Int16 where
-    series = (fromIntegral :: Int -> Int16) <$> series
-instance Monad m => CoSerial m Int16 where
-    coseries rs = (. (fromIntegral :: Int16 -> Int)) <$> coseries rs
+instance Monad m => Serial m Int16 where series = ints
+instance Monad m => CoSerial m Int16 where coseries = coInts
 
-instance Monad m => Serial m Int32 where
-    series = (fromIntegral :: Int -> Int32) <$> series
-instance Monad m => CoSerial m Int32 where
-    coseries rs = (. (fromIntegral :: Int32 -> Int)) <$> coseries rs
+instance Monad m => Serial m Int32 where series = ints
+instance Monad m => CoSerial m Int32 where coseries = coInts
 
-instance Monad m => Serial m Int64 where
-    series = (fromIntegral :: Int -> Int64) <$> series
-instance Monad m => CoSerial m Int64 where
-    coseries rs = (. (fromIntegral :: Int64 -> Int)) <$> coseries rs
+instance Monad m => Serial m Int64 where series = ints
+instance Monad m => CoSerial m Int64 where coseries = coInts
 
-instance Monad m => Serial m Word where
-    series = generate $ \d -> take (d+1) [0..maxBound]
-instance Monad m => CoSerial m Word where
-    coseries rs =
-        alts0 rs >>- \z ->
-        alts1 rs >>- \f ->
-        return $ \w ->
-        if w > 0
-           then f (w-1)
-           else z
+ints :: (Monad m, Integral n, Bounded n) => Series m n
+ints = generate (\d -> if d >= 0 then pure 0 else empty) <|>
+    nats `interleave` (fmap negate nats)
+  where
+    nats = generate $ \d -> take d [1..maxBound]
 
-instance Monad m => Serial m Word8 where
-    series = (fromIntegral :: Word -> Word8) <$> series
-instance Monad m => CoSerial m Word8 where
-    coseries rs = (. (fromIntegral :: Word8 -> Word)) <$> coseries rs
+coInts :: (Integral n, CoSerial m n) => Series m b -> Series m (n -> b)
+coInts rs =
+    alts0 rs >>- \z ->
+    alts1 rs >>- \f ->
+    alts1 rs >>- \g ->
+    return $ \i -> if
+      | i > 0 -> f (i - 1)
+      | i < 0 -> g ((abs i - 1))
+      | otherwise -> z
 
-instance Monad m => Serial m Word16 where
-    series = (fromIntegral :: Word -> Word16) <$> series
-instance Monad m => CoSerial m Word16 where
-    coseries rs = (. (fromIntegral :: Word16 -> Word)) <$> coseries rs
+instance Monad m => Serial m Word where series = nats0
+instance Monad m => CoSerial m Word where coseries = conats0
 
-instance Monad m => Serial m Word32 where
-    series = (fromIntegral :: Word -> Word32) <$> series
-instance Monad m => CoSerial m Word32 where
-    coseries rs = (. (fromIntegral :: Word32 -> Word)) <$> coseries rs
+instance Monad m => Serial m Word8 where series = nats0
+instance Monad m => CoSerial m Word8 where coseries = conats0
 
-instance Monad m => Serial m Word64 where
-    series = (fromIntegral :: Word -> Word64) <$> series
-instance Monad m => CoSerial m Word64 where
-    coseries rs = (. (fromIntegral :: Word64 -> Word)) <$> coseries rs
+instance Monad m => Serial m Word16 where series = nats0
+instance Monad m => CoSerial m Word16 where coseries = conats0
+
+instance Monad m => Serial m Word32 where series = nats0
+instance Monad m => CoSerial m Word32 where coseries = conats0
+
+instance Monad m => Serial m Word64 where series = nats0
+instance Monad m => CoSerial m Word64 where coseries = conats0
+
+nats0 :: (Integral n, Bounded n) => Series m n
+nats0 = generate $ \d -> take (d+1) [0..maxBound]
+
+conats0 :: (Integral a, CoSerial m a) => Series m b -> Series m (a -> b)
+conats0 rs =
+    alts0 rs >>- \z ->
+    alts1 rs >>- \f ->
+    return $ \n ->
+    if n > 0
+        then f (n-1)
+        else z
 
 instance Monad m => Serial m B.ByteString where
     series = cons0 B.empty \/ cons2 B.cons
diff --git a/smallcheck-series.cabal b/smallcheck-series.cabal
--- a/smallcheck-series.cabal
+++ b/smallcheck-series.cabal
@@ -1,5 +1,5 @@
 name:                smallcheck-series
-version:             0.5
+version:             0.5.1
 synopsis:            Extra SmallCheck series and utilities
 description:
   Orphan