diff --git a/Data/Csv/Conversion.hs b/Data/Csv/Conversion.hs
--- a/Data/Csv/Conversion.hs
+++ b/Data/Csv/Conversion.hs
@@ -49,6 +49,9 @@
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Char8 as B8
 import qualified Data.ByteString.Lazy as L
+#if MIN_VERSION_bytestring(0,10,4)
+import qualified Data.ByteString.Short as SBS
+#endif
 import Data.Hashable (Hashable)
 import qualified Data.HashMap.Lazy as HM
 import Data.Int (Int8, Int16, Int32, Int64)
@@ -310,6 +313,182 @@
         toField a, toField b, toField c, toField d, toField e, toField f,
         toField g, toField h, toField i]
 
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j) where
+    parseRecord v
+        | n == 10    = (,,,,,,,,,) <$> unsafeIndex v 0
+                                   <*> unsafeIndex v 1
+                                   <*> unsafeIndex v 2
+                                   <*> unsafeIndex v 3
+                                   <*> unsafeIndex v 4
+                                   <*> unsafeIndex v 5
+                                   <*> unsafeIndex v 6
+                                   <*> unsafeIndex v 7
+                                   <*> unsafeIndex v 8
+                                   <*> unsafeIndex v 9
+        | otherwise = lengthMismatch 10 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j) where
+    toRecord (a, b, c, d, e, f, g, h, i, j) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j]
+
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j,
+          FromField k) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j, k) where
+    parseRecord v
+        | n == 11    = (,,,,,,,,,,) <$> unsafeIndex v 0
+                                    <*> unsafeIndex v 1
+                                    <*> unsafeIndex v 2
+                                    <*> unsafeIndex v 3
+                                    <*> unsafeIndex v 4
+                                    <*> unsafeIndex v 5
+                                    <*> unsafeIndex v 6
+                                    <*> unsafeIndex v 7
+                                    <*> unsafeIndex v 8
+                                    <*> unsafeIndex v 9
+                                    <*> unsafeIndex v 10
+        | otherwise = lengthMismatch 11 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j, ToField k) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j, k) where
+    toRecord (a, b, c, d, e, f, g, h, i, j, k) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j, toField k]
+
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j,
+          FromField k, FromField l) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j, k, l) where
+    parseRecord v
+        | n == 12    = (,,,,,,,,,,,) <$> unsafeIndex v 0
+                                     <*> unsafeIndex v 1
+                                     <*> unsafeIndex v 2
+                                     <*> unsafeIndex v 3
+                                     <*> unsafeIndex v 4
+                                     <*> unsafeIndex v 5
+                                     <*> unsafeIndex v 6
+                                     <*> unsafeIndex v 7
+                                     <*> unsafeIndex v 8
+                                     <*> unsafeIndex v 9
+                                     <*> unsafeIndex v 10
+                                     <*> unsafeIndex v 11
+        | otherwise = lengthMismatch 12 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j, ToField k, ToField l) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j, k, l) where
+    toRecord (a, b, c, d, e, f, g, h, i, j, k, l) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j, toField k, toField l]
+
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j,
+          FromField k, FromField l, FromField m) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m) where
+    parseRecord v
+        | n == 13    = (,,,,,,,,,,,,) <$> unsafeIndex v 0
+                                      <*> unsafeIndex v 1
+                                      <*> unsafeIndex v 2
+                                      <*> unsafeIndex v 3
+                                      <*> unsafeIndex v 4
+                                      <*> unsafeIndex v 5
+                                      <*> unsafeIndex v 6
+                                      <*> unsafeIndex v 7
+                                      <*> unsafeIndex v 8
+                                      <*> unsafeIndex v 9
+                                      <*> unsafeIndex v 10
+                                      <*> unsafeIndex v 11
+                                      <*> unsafeIndex v 12
+        | otherwise = lengthMismatch 13 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
+          ToField m) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m) where
+    toRecord (a, b, c, d, e, f, g, h, i, j, k, l, m) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j, toField k, toField l,
+        toField m]
+
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j,
+          FromField k, FromField l, FromField m, FromField n) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
+    parseRecord v
+        | n == 14    = (,,,,,,,,,,,,,) <$> unsafeIndex v 0
+                                       <*> unsafeIndex v 1
+                                       <*> unsafeIndex v 2
+                                       <*> unsafeIndex v 3
+                                       <*> unsafeIndex v 4
+                                       <*> unsafeIndex v 5
+                                       <*> unsafeIndex v 6
+                                       <*> unsafeIndex v 7
+                                       <*> unsafeIndex v 8
+                                       <*> unsafeIndex v 9
+                                       <*> unsafeIndex v 10
+                                       <*> unsafeIndex v 11
+                                       <*> unsafeIndex v 12
+                                       <*> unsafeIndex v 13
+        | otherwise = lengthMismatch 14 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
+          ToField m, ToField n) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
+    toRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j, toField k, toField l,
+        toField m, toField n]
+
+instance (FromField a, FromField b, FromField c, FromField d, FromField e,
+          FromField f, FromField g, FromField h, FromField i, FromField j,
+          FromField k, FromField l, FromField m, FromField n, FromField o) =>
+         FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
+    parseRecord v
+        | n == 15    = (,,,,,,,,,,,,,,) <$> unsafeIndex v 0
+                                        <*> unsafeIndex v 1
+                                        <*> unsafeIndex v 2
+                                        <*> unsafeIndex v 3
+                                        <*> unsafeIndex v 4
+                                        <*> unsafeIndex v 5
+                                        <*> unsafeIndex v 6
+                                        <*> unsafeIndex v 7
+                                        <*> unsafeIndex v 8
+                                        <*> unsafeIndex v 9
+                                        <*> unsafeIndex v 10
+                                        <*> unsafeIndex v 11
+                                        <*> unsafeIndex v 12
+                                        <*> unsafeIndex v 13
+                                        <*> unsafeIndex v 14
+        | otherwise = lengthMismatch 15 v
+          where
+            n = V.length v
+
+instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
+          ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
+          ToField m, ToField n, ToField o) =>
+         ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
+    toRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = V.fromList [
+        toField a, toField b, toField c, toField d, toField e, toField f,
+        toField g, toField h, toField i, toField j, toField k, toField l,
+        toField m, toField n, toField o]
+
 lengthMismatch :: Int -> Record -> Parser a
 lengthMismatch expected v =
     fail $ "cannot unpack array of length " ++
@@ -677,6 +856,16 @@
 instance ToField L.ByteString where
     toField = toStrict
     {-# INLINE toField #-}
+
+#if MIN_VERSION_bytestring(0,10,4)
+instance FromField SBS.ShortByteString where
+    parseField = pure . SBS.toShort
+    {-# INLINE parseField #-}
+
+instance ToField SBS.ShortByteString where
+    toField = SBS.fromShort
+    {-# INLINE toField #-}
+#endif
 
 -- | Assumes UTF-8 encoding. Fails on invalid byte sequences.
 instance FromField T.Text where
diff --git a/cassava.cabal b/cassava.cabal
--- a/cassava.cabal
+++ b/cassava.cabal
@@ -1,5 +1,5 @@
 Name:                cassava
-Version:             0.4.3.1
+Version:             0.4.4.0
 Synopsis:            A CSV parsing and encoding library
 Description:
   A CSV parsing and encoding library optimized for ease of use and high
@@ -17,6 +17,7 @@
 Build-type:          Simple
 Cabal-version:       >=1.8
 Extra-source-files:  examples/*.hs
+Tested-with:         GHC == 7.10.2, GHC == 7.8.4, GHC == 7.6.3
 
 Library
   Exposed-modules:
@@ -92,7 +93,7 @@
 
   Build-depends:
     array < 0.6,
-    attoparsec >= 0.10.2 && < 0.13,
+    attoparsec >= 0.10.2 && < 0.14,
     base >= 4.5 && < 5,
     blaze-builder < 0.5,
     bytestring < 0.11,