diff --git a/src/Data/Color.hs b/src/Data/Color.hs
--- a/src/Data/Color.hs
+++ b/src/Data/Color.hs
@@ -3,15 +3,18 @@
 
 module Data.Color (
 	-- * Alpha
-	Alpha, pattern AlphaWord8, pattern AlphaWord16, pattern AlphaDouble,
-	alphaDouble, alphaRealToFrac,
+	Alpha, pattern AlphaWord8, pattern AlphaWord16, pattern AlphaWord32,
+	pattern AlphaInt32, alphaInt32,
+	pattern AlphaDouble, alphaDouble, alphaRealToFrac,
 	-- * RGB
-	Rgb, pattern RgbWord8, pattern RgbWord16, pattern RgbDouble,
-	rgbDouble, rgbRealToFrac,
+	Rgb, pattern RgbWord8, pattern RgbWord16, pattern RgbWord32,
+	pattern RgbInt32, rgbInt32,
+	pattern RgbDouble, rgbDouble, rgbRealToFrac,
 	-- * RGBA
 	-- ** Straight
-	Rgba, pattern RgbaWord8, pattern RgbaWord16, pattern RgbaDouble,
-	rgbaDouble,
+	Rgba, pattern RgbaWord8, pattern RgbaWord16, pattern RgbaWord32,
+	pattern RgbaInt32, rgbaInt32,
+	pattern RgbaDouble, rgbaDouble,
 	-- ** Premultiplied
 	pattern RgbaPremultipliedWord8, rgbaPremultipliedWord8,
 	pattern RgbaPremultipliedWord16, rgbaPremultipliedWord16,
diff --git a/src/Data/Color/Internal.hs b/src/Data/Color/Internal.hs
--- a/src/Data/Color/Internal.hs
+++ b/src/Data/Color/Internal.hs
@@ -4,15 +4,18 @@
 
 module Data.Color.Internal (
 	-- * Alpha
-	Alpha(..), pattern AlphaWord8, pattern AlphaWord16, pattern AlphaDouble,
-	alphaDouble, alphaRealToFrac,
+	Alpha(..), pattern AlphaWord8, pattern AlphaWord16, pattern AlphaWord32,
+	pattern AlphaInt32, alphaInt32,
+	pattern AlphaDouble, alphaDouble, alphaRealToFrac,
 	-- * RGB
-	Rgb(..), pattern RgbWord8, pattern RgbWord16, pattern RgbDouble,
-	rgbDouble, rgbRealToFrac,
+	Rgb(..), pattern RgbWord8, pattern RgbWord16, pattern RgbWord32,
+	pattern RgbInt32, rgbInt32,
+	pattern RgbDouble, rgbDouble, rgbRealToFrac,
 	-- * RGBA
 	-- ** Straight
-	Rgba(..), pattern RgbaWord8, pattern RgbaWord16, pattern RgbaDouble,
-	rgbaDouble,
+	Rgba(..), pattern RgbaWord8, pattern RgbaWord16, pattern RgbaWord32,
+	pattern RgbaInt32, rgbaInt32,
+	pattern RgbaDouble, rgbaDouble,
 	-- ** Premultiplied
 	pattern RgbaPremultipliedWord8, rgbaPremultipliedWord8,
 	pattern RgbaPremultipliedWord16, rgbaPremultipliedWord16,
@@ -23,9 +26,13 @@
 	rgbaRealToFrac ) where
 
 import Data.Bits
+import Data.Bool
 import Data.Word
+import Data.Int
 
-data Alpha d = AlphaWord8_ Word8 | AlphaWord16_ Word16 | AlphaDouble_ d
+data Alpha d
+	= AlphaWord8_ Word8 | AlphaWord16_ Word16 | AlphaWord32_ Word32
+	| AlphaInt32_ Int32 | AlphaDouble_ d
 	deriving Show
 
 {-# COMPLETE AlphaWord8 #-}
@@ -38,6 +45,8 @@
 fromAlphaWord8 = \case
 	AlphaWord8_ a -> a
 	AlphaWord16_ a -> fromIntegral $ a `shiftR` 8
+	AlphaWord32_ a -> fromIntegral $ a `shiftR` 24
+	AlphaInt32_ a -> fromIntegral $ a `shiftR` 23
 	AlphaDouble_ a -> cDoubleToWord8 a
 
 {-# COMPLETE AlphaWord16 #-}
@@ -50,8 +59,44 @@
 fromAlphaWord16 = \case
 	AlphaWord8_ (fromIntegral -> a) -> a `shiftL` 8 .|. a
 	AlphaWord16_ a -> a
+	AlphaWord32_ a -> fromIntegral $ a `shiftR` 16
+	AlphaInt32_ a -> fromIntegral $ a `shiftR` 15
 	AlphaDouble_ a -> cDoubleToWord16 a
 
+{-# COMPLETE AlphaWord32 #-}
+
+pattern AlphaWord32 :: RealFrac d => Word32 -> Alpha d
+pattern AlphaWord32 a <- (fromAlphaWord32 -> a)
+	where AlphaWord32 = AlphaWord32_
+
+fromAlphaWord32 :: RealFrac d => Alpha d -> Word32
+fromAlphaWord32 = \case
+	AlphaWord8_ (fromIntegral -> a) ->
+		a `shiftL` 24 .|. a `shiftL` 16 .|. a `shiftL` 8 .|. a
+	AlphaWord16_ (fromIntegral -> a) -> a `shiftL` 16 .|. a
+	AlphaWord32_ a -> a
+	AlphaInt32_ (fromIntegral -> a) -> a `shiftL` 1 .|. a `shiftR` 30
+	AlphaDouble_ a -> cDoubleToWord32 a
+
+{-# COMPLETE AlphaInt32 #-}
+
+pattern AlphaInt32 :: RealFrac d => Int32 -> Alpha d
+pattern AlphaInt32 a <- (fromAlphaInt32 -> a)
+
+alphaInt32 :: Int32 -> Maybe (Alpha d)
+alphaInt32 a = bool Nothing (Just $ AlphaInt32_ a) (a >= 0)
+
+fromAlphaInt32 :: RealFrac d => Alpha d -> Int32
+fromAlphaInt32 = \case
+	AlphaWord8_ (fromIntegral -> a) ->
+		a `shiftL` 23 .|. a `shiftL` 15 .|.
+		a `shiftL` 7 .|. a `shiftR` 1
+	AlphaWord16_ (fromIntegral -> a) ->
+		a `shiftL` 15 .|. a `shiftR` 1
+	AlphaWord32_ a -> fromIntegral $ a `shiftR` 1
+	AlphaInt32_ a -> a
+	AlphaDouble_ a -> cDoubleToInt32 a
+
 {-# COMPLETE AlphaDouble #-}
 
 pattern AlphaDouble :: Fractional d => d -> (Alpha d)
@@ -61,6 +106,8 @@
 fromAlphaDouble = \case
 	AlphaWord8_ a -> word8ToCDouble a
 	AlphaWord16_ a -> word16ToCDouble a
+	AlphaWord32_ a -> word32ToCDouble a
+	AlphaInt32_ a -> int32ToCDouble a
 	AlphaDouble_ a -> a
 
 alphaDouble :: (Ord d, Num d) => d -> Maybe (Alpha d)
@@ -72,11 +119,15 @@
 alphaRealToFrac = \case
 	AlphaWord8_ a -> AlphaWord8_ a
 	AlphaWord16_ a -> AlphaWord16_ a
+	AlphaWord32_ a -> AlphaWord32_ a
+	AlphaInt32_ a -> AlphaInt32_ a
 	AlphaDouble_ a -> AlphaDouble_ $ realToFrac a
 
 data Rgb d
 	= RgbWord8_ Word8 Word8 Word8
 	| RgbWord16_ Word16 Word16 Word16
+	| RgbWord32_ Word32 Word32 Word32
+	| RgbInt32_ Int32 Int32 Int32
 	| RgbDouble_ d d d
 	deriving Show
 
@@ -93,6 +144,14 @@
 		fromIntegral $ r `shiftR` 8,
 		fromIntegral $ g `shiftR` 8,
 		fromIntegral $ b `shiftR` 8 )
+	RgbWord32_ r g b -> (
+		fromIntegral $ r `shiftR` 24,
+		fromIntegral $ g `shiftR` 24,
+		fromIntegral $ b `shiftR` 24 )
+	RgbInt32_ r g b -> (
+		fromIntegral $ r `shiftR` 23,
+		fromIntegral $ g `shiftR` 23,
+		fromIntegral $ b `shiftR` 23 )
 	RgbDouble_ r g b ->
 		let [r', g', b'] = cDoubleToWord8 <$> [r, g, b] in (r', g', b')
 
@@ -107,9 +166,70 @@
 	RgbWord8_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b) ->
 		(r `shiftL` 8 .|. r, g `shiftL` 8 .|. g, b `shiftL` 8 .|. b)
 	RgbWord16_ r g b -> (r, g, b)
+	RgbWord32_ r g b -> (
+		fromIntegral $ r `shiftR` 16,
+		fromIntegral $ g `shiftR` 16,
+		fromIntegral $ b `shiftR` 16 )
+	RgbInt32_ r g b -> (
+		fromIntegral $ r `shiftR` 15,
+		fromIntegral $ g `shiftR` 15,
+		fromIntegral $ b `shiftR` 15 )
 	RgbDouble_ r g b ->
 		let [r', g', b'] = cDoubleToWord16 <$> [r, g, b] in (r', g', b')
 
+{-# COMPLETE RgbWord32 #-}
+
+pattern RgbWord32 :: RealFrac d => Word32 -> Word32 -> Word32 -> Rgb d
+pattern RgbWord32 r g b <- (fromRgbWord32 -> (r, g, b))
+	where RgbWord32 = RgbWord32_
+
+fromRgbWord32 :: RealFrac d => Rgb d -> (Word32, Word32, Word32)
+fromRgbWord32 = \case
+	RgbWord8_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b) ->
+		(	r `shiftL` 24 .|. r `shiftL` 16 .|. r `shiftL` 8 .|. r,
+			g `shiftL` 24 .|. g `shiftL` 16 .|. g `shiftL` 8 .|. g,
+			b `shiftL` 24 .|. b `shiftL` 16 .|. b `shiftL` 8 .|. b )
+	RgbWord16_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b)
+		-> (	r `shiftL` 16 .|. r, g `shiftL` 16 .|. g,
+			b `shiftL` 16 .|. b )
+	RgbWord32_ r g b -> (r, g, b)
+	RgbInt32_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b) ->
+		(	r `shiftL` 1 .|. r `shiftR` 30,
+			g `shiftL` 1 .|. g `shiftR` 30,
+			b `shiftL` 1 .|. b `shiftR` 30 )
+	RgbDouble_ r g b ->
+		let [r', g', b'] = cDoubleToWord32 <$> [r, g, b] in (r', g', b')
+
+{-# COMPLETE RgbInt32 #-}
+
+pattern RgbInt32 :: RealFrac d => Int32 -> Int32 -> Int32 -> Rgb d
+pattern RgbInt32 r g b <- (fromRgbInt32 -> (r, g, b))
+
+rgbInt32 :: Int32 -> Int32 -> Int32 -> Maybe (Rgb d)
+rgbInt32 r g b
+	| r < 0 || g < 0 || b < 0 = Nothing
+	| otherwise = Just $ RgbInt32_ r g b
+
+fromRgbInt32 :: RealFrac d => Rgb d -> (Int32, Int32, Int32)
+fromRgbInt32 = \case
+	RgbWord8_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b) ->
+		(	r `shiftL` 23 .|. r `shiftL` 15 .|.
+			r `shiftL` 7 .|. r `shiftR` 1,
+			g `shiftL` 23 .|. g `shiftL` 15 .|.
+			g `shiftL` 7 .|. g `shiftR` 1,
+			b `shiftL` 23 .|. b `shiftL` 15 .|.
+			b `shiftL` 7 .|. b `shiftR` 1 )
+	RgbWord16_ (fromIntegral -> r) (fromIntegral -> g) (fromIntegral -> b) ->
+		(	r `shiftL` 15 .|. r `shiftR` 1,
+			g `shiftL` 15 .|. g `shiftR` 1,
+			b `shiftL` 15 .|. b `shiftR` 1 )
+	RgbWord32_ r g b -> (
+		fromIntegral $ r `shiftR` 1, fromIntegral $ g `shiftR` 1,
+		fromIntegral $ b `shiftR` 1 )
+	RgbInt32_ r g b -> (r, g, b)
+	RgbDouble_ r g b ->
+		let [r', g', b'] = cDoubleToInt32 <$> [r, g, b] in (r', g', b')
+
 {-# COMPLETE RgbDouble #-}
 
 pattern RgbDouble :: Fractional d => d -> d -> d -> (Rgb d)
@@ -121,6 +241,10 @@
 		let [r', g', b'] = word8ToCDouble <$> [r, g, b] in (r', g', b')
 	RgbWord16_ r g b ->
 		let [r', g', b'] = word16ToCDouble <$> [r, g, b] in (r', g', b')
+	RgbWord32_ r g b ->
+		let [r', g', b'] = word32ToCDouble <$> [r, g, b] in (r', g', b')
+	RgbInt32_ r g b ->
+		let [r', g', b'] = int32ToCDouble <$> [r, g, b] in (r', g', b')
 	RgbDouble_ r g b -> (r, g, b)
 
 rgbDouble :: (Ord d, Num d) => d -> d -> d -> Maybe (Rgb d)
@@ -132,12 +256,16 @@
 rgbRealToFrac = \case
 	RgbWord8_ r g b -> RgbWord8_ r g b
 	RgbWord16_ r g b -> RgbWord16_ r g b
+	RgbWord32_ r g b -> RgbWord32_ r g b
+	RgbInt32_ r g b -> RgbInt32_ r g b
 	RgbDouble_ r g b -> RgbDouble_ r' g' b'
 		where [r', g', b'] = realToFrac <$> [r, g, b]
 
 data Rgba d
 	= RgbaWord8_ Word8 Word8 Word8 Word8
 	| RgbaWord16_ Word16 Word16 Word16 Word16
+	| RgbaWord32_ Word32 Word32 Word32 Word32
+	| RgbaInt32_ Int32 Int32 Int32 Int32
 	| RgbaDouble_ d d d d
 	| RgbaPremultipliedWord8_ Word8 Word8 Word8 Word8
 	| RgbaPremultipliedWord16_ Word16 Word16 Word16 Word16
@@ -154,10 +282,14 @@
 fromRgbaWord8 = \case
 	RgbaWord8_ r g b a -> (r, g, b, a)
 	RgbaWord16_ r g b a -> (
-		fromIntegral $ r `shiftR` 8,
-		fromIntegral $ g `shiftR` 8,
-		fromIntegral $ b `shiftR` 8,
-		fromIntegral $ a `shiftR` 8 )
+		fromIntegral $ r `shiftR` 8, fromIntegral $ g `shiftR` 8,
+		fromIntegral $ b `shiftR` 8, fromIntegral $ a `shiftR` 8 )
+	RgbaWord32_ r g b a -> (
+		fromIntegral $ r `shiftR` 24, fromIntegral $ g `shiftR` 24,
+		fromIntegral $ b `shiftR` 24, fromIntegral $ a `shiftR` 24 )
+	RgbaInt32_ r g b a -> (
+		fromIntegral $ r `shiftR` 23, fromIntegral $ g `shiftR` 23,
+		fromIntegral $ b `shiftR` 23, fromIntegral $ a `shiftR` 23 )
 	RgbaDouble_ r g b a -> (r', g', b', a')
 		where [r', g', b', a'] = cDoubleToWord8 <$> [r, g, b, a]
 	RgbaPremultipliedWord8_ r g b a -> (r', g', b', a')
@@ -186,6 +318,12 @@
 		r `shiftL` 8 .|. r, g `shiftL` 8 .|. g,
 		b `shiftL` 8 .|. b, a `shiftL` 8 .|. a)
 	RgbaWord16_ r g b a -> (r, g, b, a)
+	RgbaWord32_ r g b a -> (
+		fromIntegral $ r `shiftR` 16, fromIntegral $ g `shiftR` 16,
+		fromIntegral $ b `shiftR` 16, fromIntegral $ a `shiftR` 16 )
+	RgbaInt32_ r g b a -> (
+		fromIntegral $ r `shiftR` 15, fromIntegral $ g `shiftR` 15,
+		fromIntegral $ b `shiftR` 15, fromIntegral $ a `shiftR` 15 )
 	RgbaDouble_ r g b a ->
 		let [r', g', b', a'] = cDoubleToWord16 <$> [r, g, b, a] in (r', g', b', a')
 	RgbaPremultipliedWord8_ r g b a -> (
@@ -199,6 +337,109 @@
 		where [r', g', b', a'] =
 			cDoubleToWord16 <$> unPremultipliedDouble (r, g, b, a)
 
+{-# COMPLETE RgbaWord32 #-}
+
+pattern RgbaWord32 :: RealFrac d =>
+	Word32 -> Word32 -> Word32 -> Word32 -> Rgba d
+pattern RgbaWord32 r g b a <- (fromRgbaWord32 -> (r, g, b, a))
+	where RgbaWord32 = RgbaWord32_
+
+fromRgbaWord32 :: RealFrac d => Rgba d -> (Word32, Word32, Word32, Word32)
+fromRgbaWord32 = \case
+	RgbaWord8_
+		(fromIntegral -> r) (fromIntegral -> g)
+		(fromIntegral -> b) (fromIntegral -> a) -> (
+		r `shiftL` 24 .|. r `shiftL` 16 .|. r `shiftL` 8 .|. r,
+		g `shiftL` 24 .|. g `shiftL` 16 .|. g `shiftL` 8 .|. g,
+		b `shiftL` 24 .|. b `shiftL` 16 .|. b `shiftL` 8 .|. b,
+		a `shiftL` 24 .|. a `shiftL` 16 .|. a `shiftL` 8 .|. a )
+	RgbaWord16_
+		(fromIntegral -> r) (fromIntegral -> g)
+		(fromIntegral -> b) (fromIntegral -> a) -> (
+		r `shiftL` 16 .|. r, g `shiftL` 16 .|. g,
+		b `shiftL` 16 .|. b, a `shiftL` 16 .|. a )
+	RgbaWord32_ r g b a -> (r, g, b, a)
+	RgbaInt32_
+		(fromIntegral -> r) (fromIntegral -> g)
+		(fromIntegral -> b) (fromIntegral -> a) -> (
+		r `shiftL` 1 .|. r `shiftR` 30, g `shiftL` 1 .|. g `shiftR` 30,
+		b `shiftL` 1 .|. b `shiftR` 30, a `shiftL` 1 .|. a `shiftR` 30 )
+	RgbaDouble_ r g b a -> let
+		[r', g', b', a'] = cDoubleToWord32 <$> [r, g, b, a] in
+		(r', g', b', a')
+	RgbaPremultipliedWord8_ r g b a -> (
+		r' `shiftL`  24 .|. r' `shiftL` 16 .|. r' `shiftL` 8 .|. r',
+		g' `shiftL`  24 .|. g' `shiftL` 16 .|. g' `shiftL` 8 .|. g',
+		b' `shiftL`  24 .|. b' `shiftL` 16 .|. b' `shiftL` 8 .|. b',
+		a' `shiftL`  24 .|. a' `shiftL` 16 .|. a' `shiftL` 8 .|. a' )
+		where [r', g', b', a'] =
+			fromIntegral <$> unPremultipliedWord8 (r, g, b, a)
+	RgbaPremultipliedWord16_ r g b a -> (
+		r' `shiftL` 16 .|. r', g' `shiftL` 16 .|. g',
+		b' `shiftL` 16 .|. b', a' `shiftL` 16 .|. a' )
+		where [r', g', b', a'] =
+			fromIntegral <$> unPremultipliedWord16 (r, g, b, a)
+	RgbaPremultipliedDouble_ r g b a -> (r', g', b', a')
+		where [r', g', b', a'] =
+			cDoubleToWord32 <$> unPremultipliedDouble (r, g, b, a)
+
+{-# COMPLETE RgbaInt32 #-}
+
+pattern RgbaInt32 :: RealFrac d => Int32 -> Int32 -> Int32 -> Int32 -> Rgba d
+pattern RgbaInt32 r g b a <- (fromRgbaInt32 -> (r, g, b, a))
+
+rgbaInt32 :: Int32 -> Int32 -> Int32 -> Int32 -> Maybe (Rgba d)
+rgbaInt32 r g b a
+	| r < 0 || g < 0 || b < 0 || a < 0 = Nothing
+	| otherwise = Just $ RgbaInt32_ r g b a
+
+fromRgbaInt32 :: RealFrac d => Rgba d -> (Int32, Int32, Int32, Int32)
+fromRgbaInt32 = \case
+	RgbaWord8_
+		(fromIntegral -> r) (fromIntegral -> g)
+		(fromIntegral -> b) (fromIntegral -> a) -> (
+		r `shiftL` 23 .|. r `shiftL` 15 .|.
+		r `shiftL` 7 .|. r `shiftR` 1,
+		g `shiftL` 23 .|. g `shiftL` 15 .|.
+		g `shiftL` 7 .|. g `shiftR` 1,
+		b `shiftL` 23 .|. b `shiftL` 15 .|.
+		b `shiftL` 7 .|. b `shiftR` 1,
+		a `shiftL` 23 .|. a `shiftL` 15 .|.
+		a `shiftL` 7 .|. a `shiftR` 1 )
+	RgbaWord16_
+		(fromIntegral -> r) (fromIntegral -> g)
+		(fromIntegral -> b) (fromIntegral -> a) -> (
+		r `shiftL` 15 .|. r `shiftR` 1, g `shiftL` 15 .|. g `shiftR` 1,
+		b `shiftL` 15 .|. b `shiftR` 1, a `shiftL` 15 .|. a `shiftR` 1 )
+	RgbaWord32_ r g b a -> (
+		fromIntegral $ r `shiftR` 1, fromIntegral $ g `shiftR` 1,
+		fromIntegral $ b `shiftR` 1, fromIntegral $ a `shiftR` 1 )
+	RgbaInt32_ r g b a -> (r, g, b, a)
+	RgbaDouble_ r g b a -> let
+		[r', g', b', a'] = cDoubleToInt32 <$> [r, g, b, a] in
+		(r', g', b', a')
+	RgbaPremultipliedWord8_ r g b a -> (
+		r' `shiftL` 23 .|. r' `shiftL` 15 .|.
+		r' `shiftL` 7 .|. r' `shiftR` 1,
+		g' `shiftL` 23 .|. g' `shiftL` 15 .|.
+		g' `shiftL` 7 .|. g' `shiftR` 1,
+		b' `shiftL` 23 .|. b' `shiftL` 15 .|.
+		b' `shiftL` 7 .|. b' `shiftR` 1,
+		a' `shiftL` 23 .|. a' `shiftL` 15 .|.
+		a' `shiftL` 7 .|. a' `shiftR` 1 )
+		where [r', g', b', a'] =
+			fromIntegral <$> unPremultipliedWord8 (r, g, b, a)
+	RgbaPremultipliedWord16_ r g b a -> (
+		r' `shiftL` 15 .|. r' `shiftR` 1,
+		g' `shiftL` 15 .|. g' `shiftR` 1,
+		b' `shiftL` 15 .|. b' `shiftR` 1,
+		a' `shiftL` 15 .|. a' `shiftR` 1 )
+		where [r', g', b', a'] =
+			fromIntegral <$> unPremultipliedWord16 (r, g, b, a)
+	RgbaPremultipliedDouble_ r g b a -> (r', g', b', a')
+		where [r', g', b', a'] =
+			cDoubleToInt32 <$> unPremultipliedDouble (r, g, b, a)
+
 {-# COMPLETE RgbaDouble #-}
 
 pattern RgbaDouble :: (Eq d, Fractional d) => d -> d -> d -> d -> Rgba d
@@ -210,6 +451,10 @@
 		where [r', g', b', a'] = word8ToCDouble <$> [r, g, b, a]
 	RgbaWord16_ r g b a -> (r', g', b', a')
 		where [r', g', b', a'] = word16ToCDouble <$> [r, g, b, a]
+	RgbaWord32_ r g b a -> (r', g', b', a')
+		where [r', g', b', a'] = word32ToCDouble <$> [r, g, b, a]
+	RgbaInt32_ r g b a -> (r', g', b', a')
+		where [r', g', b', a'] = int32ToCDouble <$> [r, g, b, a]
 	RgbaDouble_ r g b a -> (r, g, b, a)
 	RgbaPremultipliedWord8_ r g b a -> (r', g', b', a')
 		where [r', g', b', a'] =
@@ -230,6 +475,8 @@
 fromRgba = \case
 	RgbaWord8_ r g b a -> (RgbWord8_ r g b, AlphaWord8_ a)
 	RgbaWord16_ r g b a -> (RgbWord16_ r g b, AlphaWord16_ a)
+	RgbaWord32_ r g b a -> (RgbWord32_ r g b, AlphaWord32_ a)
+	RgbaInt32_ r g b a -> (RgbInt32_ r g b, AlphaInt32_ a)
 	RgbaDouble_ r g b a -> (RgbDouble_ r g b, AlphaDouble_ a)
 	RgbaPremultipliedWord8_ r g b a -> (RgbWord8_ r' g' b', AlphaWord8_ a')
 		where [r', g', b', a'] = unPremultipliedWord8 (r, g, b, a)
@@ -241,12 +488,16 @@
 toRgba :: RealFrac d => Rgb d -> Alpha d -> Rgba d
 toRgba (RgbWord8_ r g b) (AlphaWord8 a) = RgbaWord8 r g b a
 toRgba (RgbWord16_ r g b) (AlphaWord16 a) = RgbaWord16 r g b a
+toRgba (RgbWord32_ r g b) (AlphaWord32 a) = RgbaWord32 r g b a
+toRgba (RgbInt32_ r g b) (AlphaInt32 a) = RgbaInt32_ r g b a
 toRgba (RgbDouble_ r g b) (AlphaDouble a) = RgbaDouble_ r g b a
 
 rgbaRealToFrac :: (Real d, Fractional d') => Rgba d -> Rgba d'
 rgbaRealToFrac = \case
 	RgbaWord8_ r g b a -> RgbaWord8_ r g b a
 	RgbaWord16_ r g b a -> RgbaWord16_ r g b a
+	RgbaWord32_ r g b a -> RgbaWord32_ r g b a
+	RgbaInt32_ r g b a -> RgbaInt32_ r g b a
 	RgbaDouble_ r g b a -> RgbaDouble_ r' g' b' a'
 		where [r', g', b', a'] = realToFrac <$> [r, g, b, a]
 	RgbaPremultipliedWord8_ r g b a -> RgbaPremultipliedWord8_ r g b a
@@ -260,11 +511,23 @@
 cDoubleToWord16 :: RealFrac d => d -> Word16
 cDoubleToWord16 = round . (* 0xffff)
 
+cDoubleToWord32 :: RealFrac d => d -> Word32
+cDoubleToWord32 = round . (* 0xffffffff)
+
+cDoubleToInt32 :: RealFrac d => d -> Int32
+cDoubleToInt32 = round . (* 0x7fffffff)
+
 word8ToCDouble :: Fractional d => Word8 -> d
 word8ToCDouble = (/ 0xff) . fromIntegral
 
 word16ToCDouble :: Fractional d => Word16 -> d
 word16ToCDouble = (/ 0xffff) . fromIntegral
+
+word32ToCDouble :: Fractional d => Word32 -> d
+word32ToCDouble = (/ 0xffffffff) . fromIntegral
+
+int32ToCDouble :: Fractional d => Int32 -> d
+int32ToCDouble = (/ 0x7fffffff) . fromIntegral
 
 from0to1 :: (Ord d, Num d) => d -> Bool
 from0to1 n = 0 <= n && n <= 1
diff --git a/union-color.cabal b/union-color.cabal
--- a/union-color.cabal
+++ b/union-color.cabal
@@ -5,13 +5,15 @@
 -- see: https://github.com/sol/hpack
 
 name:           union-color
-version:        0.1.1.0
-description:    Please see the README on GitHub at <https://github.com/githubuser/union-color#readme>
-homepage:       https://github.com/githubuser/union-color#readme
-bug-reports:    https://github.com/githubuser/union-color/issues
-author:         Author name here
-maintainer:     example@example.com
-copyright:      2021 Author name here
+version:        0.1.2.0
+synopsis:       Unify verious color formats
+description:    Please see the README on GitHub at <https://github.com/YoshikuniJujo/union-color#readme>
+category:       data, graphics
+homepage:       https://github.com/YoshikuniJujo/union-color#readme
+bug-reports:    https://github.com/YoshikuniJujo/union-color/issues
+author:         Yoshikuni Jujo
+maintainer:     yoshikuni.jujo.pc@gmail.com
+copyright:      2022 Yoshikuni Jujo
 license:        BSD3
 license-file:   LICENSE
 build-type:     Simple
@@ -21,7 +23,7 @@
 
 source-repository head
   type: git
-  location: https://github.com/githubuser/union-color
+  location: https://github.com/YoshikuniJujo/union-color
 
 library
   exposed-modules: