diff --git a/Graphics/Rendering/FreeType/Internal.hsc b/Graphics/Rendering/FreeType/Internal.hsc
--- a/Graphics/Rendering/FreeType/Internal.hsc
+++ b/Graphics/Rendering/FreeType/Internal.hsc
@@ -11,6 +11,15 @@
 import Graphics.Rendering.FreeType.Internal.Vector
 import Graphics.Rendering.FreeType.Internal.Glyph
 import Graphics.Rendering.FreeType.Internal.GlyphSlot
+import Graphics.Rendering.FreeType.Internal.OpenArgs
+import Graphics.Rendering.FreeType.Internal.SizeRequest
+import Graphics.Rendering.FreeType.Internal.CharMap
+import Graphics.Rendering.FreeType.Internal.Outline
+import Graphics.Rendering.FreeType.Internal.Memory
+import Graphics.Rendering.FreeType.Internal.BBox
+import Graphics.Rendering.FreeType.Internal.Bitmap
+import Graphics.Rendering.FreeType.Internal.RasterParams
+import Graphics.Rendering.FreeType.Internal.Size
 
 #include "ft2build.h"
 #include FT_FREETYPE_H
@@ -58,3 +67,164 @@
 foreign import ccall "FT_Glyph_To_Bitmap"
   ft_Glyph_To_Bitmap :: Ptr FT_Glyph  -> FT_Render_Mode
                      -> Ptr FT_Vector -> FT_Bool -> IO FT_Error
+
+foreign import ccall "FT_Library_Version"
+  ft_Library_Version :: FT_Library -> Ptr FT_Int
+                     -> Ptr FT_Int -> Ptr FT_Int -> IO ()
+
+-- | This is just here for completeness,
+-- TrueType hinting is no longer patented
+foreign import ccall "FT_Face_CheckTrueTypePatents"
+  ft_Face_CheckTrueTypePatents :: FT_Face -> IO FT_Bool
+
+-- | This is just here for completeness,
+-- TrueType hinting is no longer patented.
+foreign import ccall "FT_Face_SetUnpatentedHinting"
+  ft_Face_SetUnpatentedHinting :: FT_Face -> FT_Bool -> IO FT_Bool
+
+foreign import ccall "FT_New_Memory_Face"
+  ft_New_Memory_Face :: FT_Library -> FT_Bytes -> FT_Long
+                     -> FT_Long -> Ptr FT_Face -> IO FT_Error
+
+foreign import ccall "FT_Open_Face"
+  ft_Open_Face :: FT_Library -> Ptr FT_Open_Args
+               -> FT_Long -> Ptr FT_Face -> IO FT_Error
+
+foreign import ccall "FT_Attach_File"
+  ft_Attach_File :: FT_Face -> CString -> IO FT_Error
+
+foreign import ccall "FT_Attach_Stream"
+  ft_Attach_Stream :: FT_Face -> Ptr FT_Open_Args -> IO FT_Error
+
+foreign import ccall "FT_Reference_Face"
+  ft_Reference_Face :: FT_Face -> IO FT_Error
+
+foreign import ccall "FT_Select_Size"
+  ft_Select_Size :: FT_Face -> FT_Int -> IO FT_Error
+
+foreign import ccall "FT_Request_Size"
+  ft_Request_Size :: FT_Face -> FT_Size_Request -> IO FT_Error
+
+foreign import ccall "FT_Render_Glyph"
+  ft_Render_Glyph :: FT_GlyphSlot -> FT_Render_Mode -> IO FT_Error
+
+foreign import ccall "FT_Get_Kerning"
+  ft_Get_Kerning :: FT_Face -> FT_UInt -> FT_UInt -> FT_UInt
+                 -> Ptr FT_Vector -> IO FT_Error
+
+foreign import ccall "FT_Get_Track_Kerning"
+  ft_Get_Track_Kerning :: FT_Face -> FT_Fixed -> FT_Int
+                       -> Ptr FT_Fixed -> IO FT_Error
+
+foreign import ccall "FT_Get_Glyph_Name"
+  ft_Get_Glyph_Name :: FT_Face -> FT_UInt -> FT_Pointer
+                    -> FT_UInt -> IO FT_Error
+
+foreign import ccall "FT_Get_Postscript_Name"
+  ft_Get_Postscript_Name :: FT_Face -> IO CString
+
+foreign import ccall "FT_Select_Charmap"
+  ft_Select_Charmap :: FT_Face -> FT_Encoding -> IO FT_Error
+
+foreign import ccall "FT_Set_Charmap"
+  ft_Set_Charmap :: FT_Face -> FT_CharMap -> IO FT_Error
+
+foreign import ccall "FT_Get_Charmap_Index"
+  ft_Get_Charmap_Index :: FT_CharMap -> IO FT_Int
+
+foreign import ccall "FT_Get_First_Char"
+  ft_Get_First_Char :: FT_Face -> Ptr FT_UInt -> IO FT_ULong 
+
+foreign import ccall "FT_Get_Next_Char"
+  ft_Get_Next_Char :: FT_Face -> FT_ULong -> Ptr FT_UInt -> IO FT_ULong
+
+foreign import ccall "FT_Get_Name_Index"
+  ft_Get_Name_Index :: FT_Face -> CString -> IO FT_UInt
+
+foreign import ccall "FT_Get_SubGlyph_Info"
+  ft_Get_SubGlyph_Info :: FT_GlyphSlot -> FT_UInt
+                       -> Ptr FT_Int -> Ptr FT_UInt
+                       -> Ptr FT_Int -> Ptr FT_Int
+                       -> Ptr FT_Matrix -> IO FT_Error
+
+foreign import ccall "FT_Get_FSType_Flags"
+  ft_Get_FSType_Flags :: FT_Face -> IO FT_UShort
+
+foreign import ccall "FT_Face_GetCharVariantIndex"
+  ft_Face_GetCharVariantIndex :: FT_Face -> FT_ULong -> FT_ULong -> IO FT_UInt
+
+foreign import ccall "FT_Face_GetCharVariantIsDefault"
+  ft_Face_GetCharVariantIsDefault :: FT_Face -> FT_ULong
+                                  -> FT_ULong -> IO FT_Int
+
+foreign import ccall "FT_Face_GetVariantSelectors"
+  ft_Face_GetVariantSelectors :: FT_Face -> IO (Ptr FT_UInt32)
+
+foreign import ccall "FT_Face_GetVariantsOfChar"
+  ft_Face_GetVariantsOfChar :: FT_Face -> FT_ULong -> IO (Ptr FT_UInt32)
+
+foreign import ccall "FT_Face_GetCharsOfVariant"
+  ft_Face_GetCharsOfVariant :: FT_Face -> FT_ULong -> IO (Ptr FT_UInt32)
+
+foreign import ccall "FT_Outline_New"
+  ft_Outline_New :: FT_Library -> FT_UInt -> FT_Int
+                 -> Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_New_Internal"
+  ft_Outline_New_Internal :: FT_Memory -> FT_UInt -> FT_Int
+                          -> Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_Done"
+  ft_Outline_Done :: FT_Library -> Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_Done_Internal"
+  ft_Outline_Done_Internal :: FT_Memory -> Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_Copy"
+  ft_Outline_Copy :: Ptr FT_Outline -> Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_Translate"
+  ft_Outline_Translate :: Ptr FT_Outline -> FT_Pos -> FT_Pos -> IO ()
+
+foreign import ccall "FT_Outline_Transform"
+  ft_Outline_Transform :: Ptr FT_Outline -> Ptr FT_Matrix -> IO ()
+
+foreign import ccall "FT_Outline_Embolden"
+  ft_Outline_Embolden :: Ptr FT_Outline -> FT_Pos -> IO FT_Error
+
+foreign import ccall "FT_Outline_Reverse"
+  ft_Outline_Reverse :: Ptr FT_Outline -> IO ()
+
+foreign import ccall "FT_Outline_Check"
+  ft_Outline_Check :: Ptr FT_Outline -> IO FT_Error
+
+foreign import ccall "FT_Outline_Get_BBox"
+  ft_Outline_Get_BBox :: Ptr FT_Outline -> Ptr FT_BBox -> IO FT_Error
+
+foreign import ccall "FT_Outline_Decompose"
+  ft_Outline_Decompose :: Ptr FT_Outline -> Ptr FT_Outline_Funcs
+                       -> Ptr a -> IO FT_Error
+
+foreign import ccall "FT_Outline_Get_CBox"
+  ft_Outline_Get_CBox :: Ptr FT_Outline -> Ptr FT_BBox -> IO ()
+
+foreign import ccall "FT_Outline_Get_Bitmap"
+  ft_Outline_Get_Bitmap :: FT_Library -> Ptr FT_Outline
+                        -> Ptr FT_Bitmap -> IO FT_Error
+
+foreign import ccall "FT_Outline_Render"
+  ft_Outline_Render :: FT_Library -> Ptr FT_Outline
+                    -> Ptr FT_Raster_Params -> IO FT_Error
+
+foreign import ccall "FT_Outline_Get_Orientation"
+  ft_Outline_Get_Orientation :: Ptr FT_Outline -> IO FT_Orientation
+
+foreign import ccall "FT_New_Size"
+  ft_New_Size :: FT_Face -> Ptr FT_Size -> IO FT_Error
+
+foreign import ccall "FT_Done_Size"
+  ft_Done_Size :: FT_Size -> IO FT_Error
+
+foreign import ccall "FT_Activate_Size"
+  ft_Activate_Size :: FT_Size -> IO FT_Error
+
diff --git a/Graphics/Rendering/FreeType/Internal/BBox.hsc b/Graphics/Rendering/FreeType/Internal/BBox.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/BBox.hsc
@@ -0,0 +1,46 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BBox
+( FT_BBox(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_BBox = FT_BBox
+  { xMin :: FT_Pos
+  , yMin :: FT_Pos
+  , xMax :: FT_Pos
+  , yMax :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_BBox where
+  sizeOf    _ = #size FT_BBox
+  alignment _ = #alignment FT_BBox
+  peek ptr = do
+    xMin' <- (#peek FT_BBox, xMin) ptr
+    yMin' <- (#peek FT_BBox, yMin) ptr
+    xMax' <- (#peek FT_BBox, xMax) ptr
+    yMax' <- (#peek FT_BBox, yMax) ptr
+    return $ FT_BBox
+      { xMin = xMin'
+      , yMin = yMin'
+      , xMax = xMax'
+      , yMax = yMax'
+      }
+  poke ptr val = do
+    (#poke FT_BBox, xMin) ptr (xMin val)
+    (#poke FT_BBox, yMin) ptr (yMin val)
+    (#poke FT_BBox, xMax) ptr (xMax val)
+    (#poke FT_BBox, yMax) ptr (yMax val)
+
diff --git a/Graphics/Rendering/FreeType/Internal/BitmapGlyph.hsc b/Graphics/Rendering/FreeType/Internal/BitmapGlyph.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/BitmapGlyph.hsc
@@ -0,0 +1,36 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BitmapGlyph
+( FT_BitmapGlyph
+, root
+, left
+, top
+, bitmap
+, cast
+) where
+
+import Foreign
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+#include "freetype/ftglyph.h"
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.Bitmap
+import Graphics.Rendering.FreeType.Internal.Glyph
+
+newtype FT_BitmapGlyph = FT_BitmapGlyph FT_Glyph
+
+root :: FT_BitmapGlyph -> FT_Glyph
+root (FT_BitmapGlyph ptr) = ptr
+
+left :: FT_BitmapGlyph -> Ptr FT_Int
+left (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, left) ptr
+
+top :: FT_BitmapGlyph -> Ptr FT_Int
+top (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, top) ptr
+
+bitmap :: FT_BitmapGlyph -> Ptr FT_Bitmap
+bitmap (FT_BitmapGlyph ptr) = (#ptr struct FT_BitmapGlyphRec_, bitmap) ptr
+
+cast :: FT_Glyph -> FT_BitmapGlyph
+cast = FT_BitmapGlyph
diff --git a/Graphics/Rendering/FreeType/Internal/BitmapSize.hsc b/Graphics/Rendering/FreeType/Internal/BitmapSize.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/BitmapSize.hsc
@@ -0,0 +1,41 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.BitmapSize
+( FT_Bitmap_Size(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Bitmap_Size = FT_Bitmap_Size
+  { height :: FT_Short
+  , width  :: FT_Short
+  , size   :: FT_Pos
+  , x_ppem :: FT_Pos
+  , y_ppem :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Bitmap_Size where
+  sizeOf   _  = #size FT_Bitmap_Size
+  alignment _ = #alignment FT_Bitmap_Size
+  peek ptr = do
+    height' <- (#peek FT_Bitmap_Size, height) ptr
+    width'  <- (#peek FT_Bitmap_Size, width) ptr
+    size'   <- (#peek FT_Bitmap_Size, size) ptr
+    x_ppem' <- (#peek FT_Bitmap_Size, x_ppem) ptr
+    y_ppem' <- (#peek FT_Bitmap_Size, y_ppem) ptr
+    return $ FT_Bitmap_Size
+      { height = height'
+      , width = width'
+      , size = size'
+      , x_ppem = x_ppem'
+      , y_ppem = y_ppem'
+      }
diff --git a/Graphics/Rendering/FreeType/Internal/CharMap.hsc b/Graphics/Rendering/FreeType/Internal/CharMap.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/CharMap.hsc
@@ -0,0 +1,35 @@
+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.CharMap
+( FT_CharMapRec
+, FT_CharMap
+, face
+, encoding
+, platform_id
+, encoding_id
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.FaceType
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_CharMapRec
+type FT_CharMap = Ptr FT_CharMapRec
+
+face :: FT_CharMap -> Ptr FT_Face
+face = #ptr FT_CharMapRec, face
+
+encoding :: FT_CharMap -> Ptr FT_Encoding
+encoding = #ptr FT_CharMapRec, encoding
+
+platform_id :: FT_CharMap -> Ptr FT_UShort
+platform_id = #ptr FT_CharMapRec, platform_id
+
+encoding_id :: FT_CharMap -> Ptr FT_UShort
+encoding_id = #ptr FT_CharMapRec, encoding_id
diff --git a/Graphics/Rendering/FreeType/Internal/Driver.hs b/Graphics/Rendering/FreeType/Internal/Driver.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Driver.hs
@@ -0,0 +1,10 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Driver
+( FT_DriverRec_
+, FT_Driver
+) where
+
+import Foreign
+
+data FT_DriverRec_
+type FT_Driver = Ptr FT_DriverRec_
diff --git a/Graphics/Rendering/FreeType/Internal/Face.hsc b/Graphics/Rendering/FreeType/Internal/Face.hsc
--- a/Graphics/Rendering/FreeType/Internal/Face.hsc
+++ b/Graphics/Rendering/FreeType/Internal/Face.hsc
@@ -1,45 +1,177 @@
-{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+{-# LANGUAGE ForeignFunctionInterface #-}
 module Graphics.Rendering.FreeType.Internal.Face
 ( FT_FaceRec_
 , FT_Face
 , num_faces
+, face_index
+, face_flags
+, style_flags
 , num_glyphs
-, glyph
+, family_name
+, style_name
+, num_fixed_sizes
+, available_sizes
+, num_charmaps
+, charmaps
+, generic
+, bbox
+, units_per_EM
+, ascender
+, descender
+, height
+, max_advance_width
+, max_advance_height
+, underline_position
 , underline_thickness
+, glyph
+, size
+, charmap
+, ft_HAS_HORIZONTAL
+, ft_HAS_VERTICAL
+, ft_HAS_KERNING
+, ft_IS_SCALABLE
+, ft_IS_SFNT
+, ft_IS_FIXED_WIDTH
+, ft_HAS_FIXED_SIZES
+, ft_HAS_FAST_GLYPHS
+, ft_HAS_GLYPH_NAMES
+, ft_HAS_MULTIPLE_MASTERS
+, ft_IS_CID_KEYED
+, ft_IS_TRICKY
+, ft_STYLE_FLAG_ITALIC
+, ft_STYLE_FLAG_BOLD
 ) where
 
 import Foreign
-import Foreign.Storable
+import Foreign.C.String
 
+import Graphics.Rendering.FreeType.Internal.FaceType
 import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import qualified Graphics.Rendering.FreeType.Internal.Generic as G
 import qualified Graphics.Rendering.FreeType.Internal.GlyphSlot as GS
-
-#include <stddef.h>
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+import qualified Graphics.Rendering.FreeType.Internal.Size as S
+import qualified Graphics.Rendering.FreeType.Internal.BitmapSize as BS
+import qualified Graphics.Rendering.FreeType.Internal.CharMap as CM
+import qualified Graphics.Rendering.FreeType.Internal.BBox as BB
 
 #include "ft2build.h"
 #include FT_FREETYPE_H
 
-#include "internal/ftobjs.h"
+num_faces :: FT_Face -> Ptr FT_Long
+num_faces = #ptr struct FT_FaceRec_, num_faces
 
-data FT_FaceRec_
-type FT_Face = Ptr FT_FaceRec_
+face_index :: FT_Face -> Ptr FT_Long
+face_index = #ptr struct FT_FaceRec_, face_index
 
-instance Storable FT_FaceRec_ where
-  sizeOf _    = #size struct FT_FaceRec_
-  alignment _ = #alignment struct FT_FaceRec_
-  peek = error "peek not implemented for FT_FaceRec_"
-  poke = error "poke not implemented for FT_FaceRec_"
+face_flags :: FT_Face -> Ptr FT_Long
+face_flags = #ptr struct FT_FaceRec_, face_flags
 
-num_faces :: FT_Face -> Ptr FT_Long
-num_faces = #ptr struct FT_FaceRec_, num_faces
+style_flags :: FT_Face -> Ptr FT_Long
+style_flags = #ptr struct FT_FaceRec_, style_flags
 
 num_glyphs :: FT_Face -> Ptr FT_Long
 num_glyphs = #ptr struct FT_FaceRec_, num_glyphs
 
-glyph :: FT_Face -> Ptr GS.FT_GlyphSlot
-glyph = #ptr struct FT_FaceRec_, glyph
+family_name :: FT_Face -> Ptr CString
+family_name = #ptr struct FT_FaceRec_, family_name
 
+style_name :: FT_Face -> Ptr CString
+style_name = #ptr struct FT_FaceRec_, style_name
+
+num_fixed_sizes :: FT_Face -> Ptr FT_Int
+num_fixed_sizes = #ptr struct FT_FaceRec_, num_fixed_sizes
+
+available_sizes :: FT_Face -> Ptr (Ptr BS.FT_Bitmap_Size)
+available_sizes = #ptr struct FT_FaceRec_, available_sizes
+
+num_charmaps :: FT_Face -> Ptr FT_Int
+num_charmaps = #ptr struct FT_FaceRec_, num_charmaps
+
+charmaps :: FT_Face -> Ptr (Ptr CM.FT_CharMap)
+charmaps = #ptr struct FT_FaceRec_, charmaps
+
+generic :: FT_Face -> Ptr G.FT_Generic
+generic = #ptr struct FT_FaceRec_, generic
+
+bbox :: FT_Face -> Ptr BB.FT_BBox
+bbox = #ptr struct FT_FaceRec_, bbox
+
+units_per_EM :: FT_Face -> Ptr FT_UShort
+units_per_EM = #ptr struct FT_FaceRec_, units_per_EM
+
+ascender :: FT_Face -> Ptr FT_Short
+ascender = #ptr struct FT_FaceRec_, ascender
+
+descender :: FT_Face -> Ptr FT_Short
+descender = #ptr struct FT_FaceRec_, descender
+
+height :: FT_Face -> Ptr FT_Short
+height = #ptr struct FT_FaceRec_, height
+
+max_advance_width :: FT_Face -> Ptr FT_Short
+max_advance_width = #ptr struct FT_FaceRec_, max_advance_width
+
+max_advance_height :: FT_Face -> Ptr FT_Short
+max_advance_height = #ptr struct FT_FaceRec_, max_advance_height
+
+underline_position :: FT_Face -> Ptr FT_Short
+underline_position = #ptr struct FT_FaceRec_, underline_position
+
 underline_thickness :: FT_Face -> Ptr FT_Short
 underline_thickness = #ptr struct FT_FaceRec_, underline_thickness
 
+glyph :: FT_Face -> Ptr GS.FT_GlyphSlot
+glyph = #ptr struct FT_FaceRec_, glyph
+
+size :: FT_Face -> Ptr S.FT_Size
+size = #ptr struct FT_FaceRec_, size
+
+charmap :: FT_Face -> Ptr CM.FT_CharMap
+charmap = #ptr struct FT_FaceRec_, charmap
+
+ft_HAS :: FT_FACE_FLAG -> FT_Face -> IO Bool
+ft_HAS flag face = do
+  f <- peek $ face_flags face
+  return $ 0 /= (f .&. fromIntegral flag)
+
+ft_HAS_HORIZONTAL :: FT_Face -> IO Bool
+ft_HAS_HORIZONTAL = ft_HAS ft_FACE_FLAG_HORIZONTAL
+
+ft_HAS_VERTICAL :: FT_Face -> IO Bool
+ft_HAS_VERTICAL = ft_HAS ft_FACE_FLAG_VERTICAL
+
+ft_HAS_KERNING :: FT_Face -> IO Bool
+ft_HAS_KERNING = ft_HAS ft_FACE_FLAG_KERNING
+
+ft_IS_SCALABLE :: FT_Face -> IO Bool
+ft_IS_SCALABLE = ft_HAS ft_FACE_FLAG_SCALABLE
+
+ft_IS_SFNT :: FT_Face -> IO Bool
+ft_IS_SFNT = ft_HAS ft_FACE_FLAG_SFNT
+
+ft_IS_FIXED_WIDTH :: FT_Face -> IO Bool
+ft_IS_FIXED_WIDTH = ft_HAS ft_FACE_FLAG_FIXED_WIDTH
+
+ft_HAS_FIXED_SIZES :: FT_Face -> IO Bool
+ft_HAS_FIXED_SIZES = ft_HAS ft_FACE_FLAG_FIXED_SIZES
+
+ft_HAS_FAST_GLYPHS :: FT_Face -> IO Bool
+ft_HAS_FAST_GLYPHS = ft_HAS ft_FACE_FLAG_FAST_GLYPHS
+
+ft_HAS_GLYPH_NAMES :: FT_Face -> IO Bool
+ft_HAS_GLYPH_NAMES = ft_HAS ft_FACE_FLAG_GLYPH_NAMES
+
+ft_HAS_MULTIPLE_MASTERS :: FT_Face -> IO Bool
+ft_HAS_MULTIPLE_MASTERS = ft_HAS ft_FACE_FLAG_MULTIPLE_MASTERS
+
+ft_IS_CID_KEYED :: FT_Face -> IO Bool
+ft_IS_CID_KEYED = ft_HAS ft_FACE_FLAG_CID_KEYED
+
+ft_IS_TRICKY :: FT_Face -> IO Bool
+ft_IS_TRICKY = ft_HAS ft_FACE_FLAG_TRICKY
+
+ft_STYLE_FLAG_ITALIC :: FT_Long
+ft_STYLE_FLAG_ITALIC = #const FT_STYLE_FLAG_ITALIC
+
+ft_STYLE_FLAG_BOLD :: FT_Long
+ft_STYLE_FLAG_BOLD = #const FT_STYLE_FLAG_BOLD 
diff --git a/Graphics/Rendering/FreeType/Internal/FaceType.hs b/Graphics/Rendering/FreeType/Internal/FaceType.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/FaceType.hs
@@ -0,0 +1,10 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.FaceType
+( FT_FaceRec_
+, FT_Face
+) where
+
+import Foreign
+
+data FT_FaceRec_
+type FT_Face = Ptr FT_FaceRec_
diff --git a/Graphics/Rendering/FreeType/Internal/Generic.hsc b/Graphics/Rendering/FreeType/Internal/Generic.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Generic.hsc
@@ -0,0 +1,37 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Generic
+( FT_Generic(..)
+, FT_Generic_Finalizer
+) where
+
+import Foreign
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Generic_Finalizer = FunPtr (Ptr () -> IO ())
+
+data FT_Generic = FT_Generic
+  { data_ :: Ptr ()
+  , finalizer :: FT_Generic_Finalizer
+  }
+
+instance Storable FT_Generic where
+  sizeOf    _ = #size FT_Generic
+  alignment _ = #alignment FT_Generic
+  -- Is peek/poke defined correctly given that data is a void*
+  -- and finalizer is a function pointer?
+  peek ptr = do
+    data_'     <- (#peek FT_Generic, data) ptr
+    finalizer' <- (#peek FT_Generic, finalizer) ptr
+    return $ FT_Generic
+      { data_ = data_'
+      , finalizer = finalizer'
+      }
+  poke ptr val = do
+    (#poke FT_Generic, data) ptr (data_ val)
+    (#poke FT_Generic, finalizer) ptr (finalizer val) 
diff --git a/Graphics/Rendering/FreeType/Internal/Glyph.hsc b/Graphics/Rendering/FreeType/Internal/Glyph.hsc
--- a/Graphics/Rendering/FreeType/Internal/Glyph.hsc
+++ b/Graphics/Rendering/FreeType/Internal/Glyph.hsc
@@ -3,14 +3,14 @@
 ( FT_GlyphRec_
 , FT_Glyph
 , library
+, format
 , advance
 ) where
 
 import Foreign
-import Foreign.Storable
 
--- import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
-import qualified Graphics.Rendering.FreeType.Internal.Library as Lib
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import qualified Graphics.Rendering.FreeType.Internal.Library as L
 import qualified Graphics.Rendering.FreeType.Internal.Vector  as V
 
 #include <stddef.h>
@@ -24,19 +24,11 @@
 data FT_GlyphRec_
 type FT_Glyph = Ptr FT_GlyphRec_
 
-instance Storable FT_GlyphRec_ where
-  sizeOf    _  = #size struct FT_GlyphRec_
-  alignment _  = #alignment struct FT_GlyphRec_
-  peek = error "peek not implemented for FT_GlyphRec_"
-  poke = error "peek not implemented for FT_GlyphRec_"
-
-library :: FT_Glyph -> Ptr Lib.FT_Library
+library :: FT_Glyph -> Ptr L.FT_Library
 library = #ptr struct FT_GlyphRec_, library
 
-{- TODO: implement FT_Glyph_Format
 format :: FT_Glyph -> Ptr FT_Glyph_Format
 format = #ptr struct FT_GlyphRec_, format
--}
 
 advance :: FT_Glyph -> Ptr V.FT_Vector
 advance = #ptr struct FT_GlyphRec_, advance
diff --git a/Graphics/Rendering/FreeType/Internal/GlyphMetrics.hsc b/Graphics/Rendering/FreeType/Internal/GlyphMetrics.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/GlyphMetrics.hsc
@@ -0,0 +1,59 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.GlyphMetrics
+( FT_Glyph_Metrics(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Glyph_Metrics = FT_Glyph_Metrics
+  { width        :: FT_Pos
+  , height       :: FT_Pos
+  , horiBearingX :: FT_Pos
+  , horiBearingY :: FT_Pos
+  , horiAdvance  :: FT_Pos
+  , vertBearingX :: FT_Pos
+  , vertBearingY :: FT_Pos
+  , vertAdvance  :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Glyph_Metrics where
+  sizeOf    _ = #size FT_Glyph_Metrics
+  alignment _ = #alignment FT_Glyph_Metrics
+  peek ptr = do
+    width'  <- (#peek FT_Glyph_Metrics, width) ptr
+    height' <- (#peek FT_Glyph_Metrics, height) ptr
+    horiBearingX' <- (#peek FT_Glyph_Metrics, horiBearingX) ptr
+    horiBearingY' <- (#peek FT_Glyph_Metrics, horiBearingY) ptr
+    horiAdvance'  <- (#peek FT_Glyph_Metrics, horiAdvance) ptr
+    vertBearingX' <- (#peek FT_Glyph_Metrics, vertBearingX) ptr
+    vertBearingY' <- (#peek FT_Glyph_Metrics, vertBearingY) ptr
+    vertAdvance'  <- (#peek FT_Glyph_Metrics, vertAdvance) ptr
+    return $ FT_Glyph_Metrics
+      { width = width'
+      , height = height'
+      , horiBearingX = horiBearingX'
+      , horiBearingY = horiBearingY'
+      , horiAdvance  = horiAdvance'
+      , vertBearingX = vertBearingX'
+      , vertBearingY = vertBearingY'
+      , vertAdvance  = vertAdvance'
+      }
+  poke ptr val = do
+    (#poke FT_Glyph_Metrics, width) ptr (width val)
+    (#poke FT_Glyph_Metrics, height) ptr (height val)
+    (#poke FT_Glyph_Metrics, horiBearingX) ptr (horiBearingX val)
+    (#poke FT_Glyph_Metrics, horiBearingY) ptr (horiBearingY val)
+    (#poke FT_Glyph_Metrics, horiAdvance) ptr (horiAdvance val)
+    (#poke FT_Glyph_Metrics, vertBearingX) ptr (vertBearingX val)
+    (#poke FT_Glyph_Metrics, vertBearingY) ptr (vertBearingY val)
+    (#poke FT_Glyph_Metrics, vertAdvance) ptr (vertAdvance val)
diff --git a/Graphics/Rendering/FreeType/Internal/GlyphSlot.hsc b/Graphics/Rendering/FreeType/Internal/GlyphSlot.hsc
--- a/Graphics/Rendering/FreeType/Internal/GlyphSlot.hsc
+++ b/Graphics/Rendering/FreeType/Internal/GlyphSlot.hsc
@@ -3,48 +3,99 @@
 ( FT_GlyphSlotRec_
 , FT_GlyphSlot
 , library
+, face
+, next
+, generic
+, metrics
+, linearHoriAdvance
+, linearVertAdvance
 , advance
+, format
 , bitmap
 , bitmap_top
 , bitmap_left
+, outline
+, num_subglyphs
+, subglyphs
+, control_data
+, control_len
+, lsb_delta
+, rsb_delta
 ) where
 
 import Foreign
-import Foreign.Storable
+import Foreign.C.Types
 
 import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
-import qualified Graphics.Rendering.FreeType.Internal.Library as Lib
+import qualified Graphics.Rendering.FreeType.Internal.Generic as G
+import qualified Graphics.Rendering.FreeType.Internal.Library as L
+import qualified Graphics.Rendering.FreeType.Internal.FaceType as F
 import qualified Graphics.Rendering.FreeType.Internal.Vector  as V
 import qualified Graphics.Rendering.FreeType.Internal.Bitmap as B
-
-#include <stddef.h>
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+import qualified Graphics.Rendering.FreeType.Internal.SubGlyph as SG
+import qualified Graphics.Rendering.FreeType.Internal.GlyphMetrics as GM
+import qualified Graphics.Rendering.FreeType.Internal.Outline as O
 
 #include "ft2build.h"
 #include FT_FREETYPE_H
 
-#include "internal/ftobjs.h"
-
 data FT_GlyphSlotRec_
 type FT_GlyphSlot = Ptr FT_GlyphSlotRec_
 
-instance Storable FT_GlyphSlotRec_ where
-  sizeOf _    = #size struct FT_GlyphSlotRec_
-  alignment _ = #alignment struct FT_GlyphSlotRec_
-  peek = error "peek not implemented for FT_GlyphSlotRec_"
-  poke = error "poke not implemented for FT_GlyphSlotRec_"
+library :: FT_GlyphSlot -> Ptr L.FT_Library
+library = #ptr struct FT_GlyphSlotRec_, library
 
-library :: FT_GlyphSlot -> Lib.FT_Library
-library = (#ptr struct FT_GlyphSlotRec_, library)
+face :: FT_GlyphSlot -> Ptr F.FT_Face
+face = #ptr struct FT_GlyphSlotRec_, face
 
+next :: FT_GlyphSlot -> Ptr FT_GlyphSlot
+next = #ptr struct FT_GlyphSlotRec_, next
+
+generic :: FT_GlyphSlot -> Ptr G.FT_Generic
+generic = #ptr struct FT_GlyphSlotRec_, generic
+
+metrics :: FT_GlyphSlot -> Ptr GM.FT_Glyph_Metrics
+metrics = #ptr struct FT_GlyphSlotRec_, metrics
+
+linearHoriAdvance :: FT_GlyphSlot -> Ptr FT_Fixed
+linearHoriAdvance = #ptr struct FT_GlyphSlotRec_, linearHoriAdvance
+
+linearVertAdvance :: FT_GlyphSlot -> Ptr FT_Fixed
+linearVertAdvance = #ptr struct FT_GlyphSlotRec_, linearVertAdvance
+
 advance :: FT_GlyphSlot -> Ptr V.FT_Vector
-advance = (#ptr struct FT_GlyphSlotRec_, advance)
+advance = #ptr struct FT_GlyphSlotRec_, advance
 
+format :: FT_GlyphSlot -> Ptr FT_Glyph_Format
+format = #ptr struct FT_GlyphSlotRec_, format
+
 bitmap :: FT_GlyphSlot -> Ptr B.FT_Bitmap
-bitmap = (#ptr struct FT_GlyphSlotRec_, bitmap)
+bitmap = #ptr struct FT_GlyphSlotRec_, bitmap
 
 bitmap_left :: FT_GlyphSlot -> Ptr FT_Int
-bitmap_left = (#ptr struct FT_GlyphSlotRec_, bitmap_left)
+bitmap_left = #ptr struct FT_GlyphSlotRec_, bitmap_left
 
 bitmap_top :: FT_GlyphSlot -> Ptr FT_Int
-bitmap_top = (#ptr struct FT_GlyphSlotRec_, bitmap_top)
+bitmap_top = #ptr struct FT_GlyphSlotRec_, bitmap_top
+
+outline :: FT_GlyphSlot -> Ptr O.FT_Outline
+outline = #ptr struct FT_GlyphSlotRec_, outline
+
+num_subglyphs :: FT_GlyphSlot -> Ptr FT_UInt
+num_subglyphs = #ptr struct FT_GlyphSlotRec_, num_subglyphs
+
+subglyphs :: FT_GlyphSlot -> Ptr SG.FT_SubGlyph
+subglyphs = #ptr struct FT_GlyphSlotRec_, subglyphs
+
+control_data :: FT_GlyphSlot -> Ptr a
+control_data = #ptr struct FT_GlyphSlotRec_, control_data
+
+control_len :: FT_GlyphSlot -> Ptr CLong
+control_len = #ptr struct FT_GlyphSlotRec_, control_len
+
+lsb_delta :: FT_GlyphSlot -> Ptr FT_Pos
+lsb_delta = #ptr struct FT_GlyphSlotRec_, lsb_delta
+
+rsb_delta :: FT_GlyphSlot -> Ptr FT_Pos
+rsb_delta = #ptr struct FT_GlyphSlotRec_, rsb_delta
+
diff --git a/Graphics/Rendering/FreeType/Internal/Library.hs b/Graphics/Rendering/FreeType/Internal/Library.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Library.hs
@@ -0,0 +1,11 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Library
+( FT_LibraryRec_
+, FT_Library
+) where
+
+import Foreign
+
+data FT_LibraryRec_
+type FT_Library = Ptr FT_LibraryRec_
+
diff --git a/Graphics/Rendering/FreeType/Internal/Library.hsc b/Graphics/Rendering/FreeType/Internal/Library.hsc
deleted file mode 100644
--- a/Graphics/Rendering/FreeType/Internal/Library.hsc
+++ /dev/null
@@ -1,26 +0,0 @@
-{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
-module Graphics.Rendering.FreeType.Internal.Library
-( FT_LibraryRec_
-, FT_Library
-) where
-
-import Foreign
-import Foreign.Storable
-
-#include <stddef.h>
-#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
-
-#include "ft2build.h"
-#include FT_FREETYPE_H
-
-#include "internal/ftobjs.h"
-
-data FT_LibraryRec_
-type FT_Library = Ptr FT_LibraryRec_
-
-instance Storable FT_LibraryRec_ where
-  sizeOf _    = #size struct FT_LibraryRec_
-  alignment _ = #alignment struct FT_LibraryRec_
-  peek = error "peek not implemented for FT_LibraryRec_"
-  poke = error "poke not implemented for FT_LibraryRec_"
-
diff --git a/Graphics/Rendering/FreeType/Internal/Memory.hsc b/Graphics/Rendering/FreeType/Internal/Memory.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Memory.hsc
@@ -0,0 +1,49 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Memory
+( FT_MemoryRec(..)
+, FT_Memory
+) where
+
+import Foreign hiding (free, realloc)
+import Foreign.C.Types
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Alloc_Func   = FunPtr (FT_Memory -> CLong -> IO (Ptr ()))
+type FT_Free_Func    = FunPtr (FT_Memory -> Ptr () -> IO ())
+type FT_Realloc_Func = FunPtr
+  (FT_Memory -> CLong -> CLong -> Ptr () -> IO (Ptr ()))
+                     
+
+type FT_Memory = Ptr FT_MemoryRec
+data FT_MemoryRec = FT_MemoryRec
+  { user    :: Ptr ()
+  , alloc   :: FT_Alloc_Func
+  , free    :: FT_Free_Func
+  , realloc :: FT_Realloc_Func
+  }
+
+instance Storable FT_MemoryRec where
+  sizeOf    _ = #size struct FT_MemoryRec_
+  alignment _ = #alignment struct FT_MemoryRec_
+  peek ptr = do
+    user'    <- (#peek struct FT_MemoryRec_, user) ptr
+    alloc'   <- (#peek struct FT_MemoryRec_, alloc) ptr
+    free'    <- (#peek struct FT_MemoryRec_, free) ptr
+    realloc'  <- (#peek struct FT_MemoryRec_, realloc) ptr
+    return $ FT_MemoryRec
+      { user = user'
+      , alloc = alloc'
+      , free = free'
+      , realloc = realloc'
+      }
+  poke ptr val = do
+    (#poke struct FT_MemoryRec_, user) ptr (user val)
+    (#poke struct FT_MemoryRec_, alloc) ptr (alloc val)
+    (#poke struct FT_MemoryRec_, free) ptr (free val)
+    (#poke struct FT_MemoryRec_, realloc) ptr (realloc val)
diff --git a/Graphics/Rendering/FreeType/Internal/Module.hs b/Graphics/Rendering/FreeType/Internal/Module.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Module.hs
@@ -0,0 +1,11 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Module
+( FT_ModuleRec_
+, FT_Module
+) where
+
+import Foreign
+
+data FT_ModuleRec_
+type FT_Module = Ptr FT_ModuleRec_
+
diff --git a/Graphics/Rendering/FreeType/Internal/OpenArgs.hsc b/Graphics/Rendering/FreeType/Internal/OpenArgs.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/OpenArgs.hsc
@@ -0,0 +1,53 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.OpenArgs
+( FT_Open_Args(..)
+) where
+
+import Foreign
+import Foreign.C.String
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+import Graphics.Rendering.FreeType.Internal.Stream
+import Graphics.Rendering.FreeType.Internal.Module
+import Graphics.Rendering.FreeType.Internal.Parameter
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Open_Args = FT_Open_Args
+  { flags       :: FT_UInt
+  , memory_base :: FT_Bytes
+  , memory_size :: FT_Long
+  , pathname    :: CString
+  , stream      :: FT_Stream
+  , driver      :: FT_Module
+  , num_params  :: FT_Int
+  , params      :: Ptr FT_Parameter
+  }
+
+instance Storable FT_Open_Args where
+  sizeOf    _ = #size FT_Open_Args
+  alignment _ = #alignment FT_Open_Args
+  peek ptr = do
+    flags'       <- (#peek FT_Open_Args, flags) ptr
+    memory_base' <- (#peek FT_Open_Args, memory_base) ptr
+    memory_size' <- (#peek FT_Open_Args, memory_size) ptr
+    pathname'    <- (#peek FT_Open_Args, pathname) ptr
+    stream'      <- (#peek FT_Open_Args, stream) ptr
+    driver'      <- (#peek FT_Open_Args, driver) ptr
+    num_params'  <- (#peek FT_Open_Args, num_params) ptr
+    params'      <- (#peek FT_Open_Args, params) ptr
+    return $ FT_Open_Args
+      { flags = flags'
+      , memory_base = memory_base'
+      , memory_size = memory_size'
+      , pathname = pathname'
+      , stream = stream'
+      , driver = driver'
+      , num_params = num_params'
+      , params = params'
+      }
diff --git a/Graphics/Rendering/FreeType/Internal/Outline.hsc b/Graphics/Rendering/FreeType/Internal/Outline.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Outline.hsc
@@ -0,0 +1,108 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Outline
+( FT_Outline(..)
+, FT_Outline_MoveToFunc
+, FT_Outline_LineToFunc
+, FT_Outline_ConicToFunc
+, FT_Outline_CubicToFunc
+, FT_Outline_Funcs(..)
+) where
+
+import Foreign hiding (shift)
+import Foreign.C.Types
+import Foreign.C.String
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.Vector
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Outline = FT_Outline
+  { n_contours :: CShort
+  , n_points   :: CShort
+  , points     :: Ptr FT_Vector
+  , tags       :: CString
+  , contours   :: Ptr CShort
+  , flags      :: FT_OUTLINE_FLAGS
+  }
+
+instance Storable FT_Outline where
+  sizeOf    _ = #size FT_Outline
+  alignment _ = #alignment FT_Outline
+  peek ptr = do
+    n_contours' <- (#peek FT_Outline, n_contours) ptr
+    n_points'   <- (#peek FT_Outline, n_points)   ptr
+    points'     <- (#peek FT_Outline, points)     ptr
+    tags'       <- (#peek FT_Outline, tags)       ptr
+    contours'   <- (#peek FT_Outline, contours)   ptr
+    flags'      <- (#peek FT_Outline, flags)      ptr
+    return $ FT_Outline
+      { n_contours = n_contours'
+      , n_points   = n_points'
+      , points     = points'
+      , tags       = tags'
+      , contours   = contours'
+      , flags      = flags'
+      }
+  poke ptr val = do
+    (#poke FT_Outline, n_contours) ptr (n_contours val)
+    (#poke FT_Outline, n_points)   ptr (n_points   val)
+    (#poke FT_Outline, points)     ptr (points     val)
+    (#poke FT_Outline, tags)       ptr (tags       val)
+    (#poke FT_Outline, contours)   ptr (contours   val)
+    (#poke FT_Outline, flags)      ptr (flags      val)
+
+type FT_Outline_MoveToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_LineToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_ConicToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr FT_Vector -> Ptr () -> IO CInt)
+
+type FT_Outline_CubicToFunc = FunPtr
+  (Ptr FT_Vector -> Ptr FT_Vector -> Ptr FT_Vector -> Ptr () -> IO CInt)
+
+data FT_Outline_Funcs = FT_Outline_Funcs
+  { move_to  :: FT_Outline_MoveToFunc
+  , line_to  :: FT_Outline_LineToFunc
+  , conic_to :: FT_Outline_ConicToFunc
+  , cubic_to :: FT_Outline_CubicToFunc
+  , shift    :: CInt
+  , delta    :: FT_Pos
+  }
+
+instance Storable FT_Outline_Funcs where
+  sizeOf    _ = #size FT_Outline_Funcs
+  alignment _ = #alignment FT_Outline_Funcs
+  peek ptr = do
+    move_to'  <- (#peek FT_Outline_Funcs, move_to) ptr
+    line_to'  <- (#peek FT_Outline_Funcs, line_to) ptr
+    conic_to' <- (#peek FT_Outline_Funcs, conic_to) ptr
+    cubic_to' <- (#peek FT_Outline_Funcs, cubic_to) ptr
+    shift'    <- (#peek FT_Outline_Funcs, shift) ptr
+    delta'    <- (#peek FT_Outline_Funcs, delta) ptr
+    return $ FT_Outline_Funcs
+      { move_to  = move_to'
+      , line_to  = line_to'
+      , conic_to = conic_to'
+      , cubic_to = cubic_to'
+      , shift    = shift'
+      , delta    = delta'
+      }
+  poke ptr val = do
+    (#poke FT_Outline_Funcs, move_to) ptr (move_to val)
+    (#poke FT_Outline_Funcs, line_to) ptr (line_to val)
+    (#poke FT_Outline_Funcs, conic_to) ptr (conic_to val)
+    (#poke FT_Outline_Funcs, cubic_to) ptr (cubic_to val)
+    (#poke FT_Outline_Funcs, shift) ptr (shift val)
+    (#poke FT_Outline_Funcs, delta) ptr (delta val)
+
diff --git a/Graphics/Rendering/FreeType/Internal/OutlineGlyph.hsc b/Graphics/Rendering/FreeType/Internal/OutlineGlyph.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/OutlineGlyph.hsc
@@ -0,0 +1,28 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.OutlineGlyph
+( FT_OutlineGlyph
+, root
+, outline
+, cast
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.Glyph
+import Graphics.Rendering.FreeType.Internal.Outline
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftglyph.h"
+
+newtype FT_OutlineGlyph = FT_OutlineGlyph FT_Glyph
+
+root :: FT_OutlineGlyph -> FT_Glyph
+root (FT_OutlineGlyph ptr) = ptr
+
+outline :: FT_OutlineGlyph -> Ptr FT_Outline
+outline (FT_OutlineGlyph ptr) = (#ptr struct FT_OutlineGlyphRec_, outline) ptr
+
+cast :: FT_Glyph -> FT_OutlineGlyph
+cast = FT_OutlineGlyph
diff --git a/Graphics/Rendering/FreeType/Internal/Parameter.hsc b/Graphics/Rendering/FreeType/Internal/Parameter.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Parameter.hsc
@@ -0,0 +1,34 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Parameter
+( FT_Parameter(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Parameter = FT_Parameter
+  { tag   :: FT_ULong
+  , data_ :: FT_Pointer
+  }
+
+instance Storable FT_Parameter where
+  sizeOf    _ = #size FT_Parameter
+  alignment _ = #alignment FT_Parameter
+  peek ptr = do
+    tag'   <- (#peek FT_Parameter, tag) ptr
+    data_' <- (#peek FT_Parameter, data) ptr
+    return $ FT_Parameter
+      { tag = tag'
+      , data_ = data_'
+      }
+  poke ptr val = do
+    (#poke FT_Parameter, tag) ptr (tag val)
+    (#poke FT_Parameter, data) ptr (data_ val)
diff --git a/Graphics/Rendering/FreeType/Internal/PrimitiveTypes.hsc b/Graphics/Rendering/FreeType/Internal/PrimitiveTypes.hsc
--- a/Graphics/Rendering/FreeType/Internal/PrimitiveTypes.hsc
+++ b/Graphics/Rendering/FreeType/Internal/PrimitiveTypes.hsc
@@ -1,4 +1,5 @@
 {-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 module Graphics.Rendering.FreeType.Internal.PrimitiveTypes where
 
 import Foreign
@@ -9,6 +10,8 @@
 #include "ft2build.h"
 #include FT_FREETYPE_H
 
+#include "freetype/ftoutln.h"
+
 ft_LOAD_DEFAULT :: FT_Int32
 ft_LOAD_DEFAULT = #const FT_LOAD_DEFAULT
 ft_LOAD_NO_SCALE :: FT_Int32
@@ -60,8 +63,10 @@
 type FT_F26Dot6 = CLong
 type FT_Fixed   = CLong
 type FT_Pos     = CLong
+type FT_Pointer = Ptr ()
 
 newtype FT_Render_Mode = FT_Render_Mode CUInt
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
 
 #{enum FT_Render_Mode, FT_Render_Mode,
   ft_RENDER_MODE_NORMAL = FT_RENDER_MODE_NORMAL,
@@ -69,4 +74,167 @@
   ft_RENDER_MODE_MONO   = FT_RENDER_MODE_MONO,
   ft_RENDER_MODE_LCD    = FT_RENDER_MODE_LCD,
   ft_RENDER_MODE_LCD_V  = FT_RENDER_MODE_LCD_V
+}
+
+fREETYPE_MAJOR :: FT_Int
+fREETYPE_MAJOR = #const FREETYPE_MAJOR
+fREETYPE_MINOR :: FT_Int
+fREETYPE_MINOR = #const FREETYPE_MINOR
+fREETYPE_PATCH :: FT_Int
+fREETYPE_PATCH = #const FREETYPE_PATCH
+
+newtype FT_Encoding = FT_Encoding FT_UInt32
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_Encoding, FT_Encoding,
+  ft_ENCODING_NONE           = FT_ENCODING_NONE,
+  ft_ENCODING_MS_SYMBOL      = FT_ENCODING_MS_SYMBOL,
+  ft_ENCODING_UNICODE        = FT_ENCODING_UNICODE,
+  ft_ENCODING_SJIS           = FT_ENCODING_SJIS,
+  ft_ENCODING_GB2312         = FT_ENCODING_GB2312,
+  ft_ENCODING_BIG5           = FT_ENCODING_BIG5,
+  ft_ENCODING_WANSUNG        = FT_ENCODING_WANSUNG,
+  ft_ENCODING_JOHAB          = FT_ENCODING_JOHAB,
+  ft_ENCODING_MS_SJIS        = FT_ENCODING_MS_SJIS,
+  ft_ENCODING_MS_GB2312      = FT_ENCODING_MS_GB2312,
+  ft_ENCODING_MS_BIG5        = FT_ENCODING_MS_BIG5,
+  ft_ENCODING_MS_WANSUNG     = FT_ENCODING_MS_WANSUNG,
+  ft_ENCODING_MS_JOHAB       = FT_ENCODING_MS_JOHAB,
+  ft_ENCODING_ADOBE_STANDARD = FT_ENCODING_ADOBE_STANDARD,
+  ft_ENCODING_ADOBE_EXPERT   = FT_ENCODING_ADOBE_EXPERT,
+  ft_ENCODING_ADOBE_CUSTOM   = FT_ENCODING_ADOBE_CUSTOM,
+  ft_ENCODING_ADOBE_LATIN_1  = FT_ENCODING_ADOBE_LATIN_1,
+  ft_ENCODING_OLD_LATIN_2    = FT_ENCODING_OLD_LATIN_2,
+  ft_ENCODING_APPLE_ROMAN    = FT_ENCODING_APPLE_ROMAN
+}
+
+newtype FT_FACE_FLAG = FT_FACE_FLAG FT_Int
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_FACE_FLAG, FT_FACE_FLAG,
+  ft_FACE_FLAG_SCALABLE = FT_FACE_FLAG_SCALABLE,
+  ft_FACE_FLAG_FIXED_SIZES = FT_FACE_FLAG_FIXED_SIZES,
+  ft_FACE_FLAG_FIXED_WIDTH = FT_FACE_FLAG_FIXED_WIDTH,
+  ft_FACE_FLAG_SFNT = FT_FACE_FLAG_SFNT,
+  ft_FACE_FLAG_HORIZONTAL = FT_FACE_FLAG_HORIZONTAL,
+  ft_FACE_FLAG_VERTICAL = FT_FACE_FLAG_VERTICAL,
+  ft_FACE_FLAG_KERNING = FT_FACE_FLAG_KERNING,
+  ft_FACE_FLAG_FAST_GLYPHS = FT_FACE_FLAG_FAST_GLYPHS,
+  ft_FACE_FLAG_MULTIPLE_MASTERS = FT_FACE_FLAG_MULTIPLE_MASTERS,
+  ft_FACE_FLAG_GLYPH_NAMES = FT_FACE_FLAG_GLYPH_NAMES,
+  ft_FACE_FLAG_EXTERNAL_STREAM = FT_FACE_FLAG_EXTERNAL_STREAM,
+  ft_FACE_FLAG_HINTER = FT_FACE_FLAG_HINTER,
+  ft_FACE_FLAG_CID_KEYED = FT_FACE_FLAG_CID_KEYED,
+  ft_FACE_FLAG_TRICKY = FT_FACE_FLAG_TRICKY
+}
+
+newtype FT_OPEN = FT_OPEN FT_UInt
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_OPEN, FT_OPEN,
+  ft_OPEN_MEMORY   = FT_OPEN_MEMORY,
+  ft_OPEN_STREAM   = FT_OPEN_STREAM,
+  ft_OPEN_PATHNAME = FT_OPEN_PATHNAME,
+  ft_OPEN_DRIVER   = FT_OPEN_DRIVER,
+  ft_OPEN_PARAMS   = FT_OPEN_PARAMS
+}
+
+newtype FT_Size_Request_Type = FT_Size_Request_Type FT_UInt
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_Size_Request_Type, FT_Size_Request_Type,
+  ft_SIZE_REQUEST_TYPE_NOMINAL  = FT_SIZE_REQUEST_TYPE_NOMINAL,
+  ft_SIZE_REQUEST_TYPE_REAL_DIM = FT_SIZE_REQUEST_TYPE_REAL_DIM,
+  ft_SIZE_REQUEST_TYPE_BBOX     = FT_SIZE_REQUEST_TYPE_BBOX,
+  ft_SIZE_REQUEST_TYPE_CELL     = FT_SIZE_REQUEST_TYPE_CELL,
+  ft_SIZE_REQUEST_TYPE_SCALES   = FT_SIZE_REQUEST_TYPE_SCALES
+}
+
+ft_LOAD_TARGET_NORMAL :: FT_UInt32
+ft_LOAD_TARGET_NORMAL = #const FT_LOAD_TARGET_NORMAL  
+ft_LOAD_TARGET_LIGHT :: FT_UInt32
+ft_LOAD_TARGET_LIGHT = #const FT_LOAD_TARGET_LIGHT
+ft_LOAD_TARGET_MONO :: FT_UInt32
+ft_LOAD_TARGET_MONO = #const FT_LOAD_TARGET_MONO
+ft_LOAD_TARGET_LCD :: FT_UInt32
+ft_LOAD_TARGET_LCD = #const FT_LOAD_TARGET_LCD
+ft_LOAD_TARGET_LCD_V :: FT_UInt32
+ft_LOAD_TARGET_LCD_V = #const FT_LOAD_TARGET_LCD_V
+
+newtype FT_Kerning_Mode = FT_Kerning_Mode FT_UInt32
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_Kerning_Mode, FT_Kerning_Mode,
+  ft_KERNING_DEFAULT  = FT_KERNING_DEFAULT,
+  ft_KERNING_UNFITTED = FT_KERNING_UNFITTED,
+  ft_KERNING_UNSCALED = FT_KERNING_UNSCALED
+}
+
+newtype FT_SUBGLYPH_FLAG = FT_SUBGLYPH_FLAG FT_UInt
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_SUBGLYPH_FLAG, FT_SUBGLYPH_FLAG,
+  ft_SUBGLYPH_FLAG_ARGS_ARE_WORDS = FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS,
+  ft_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES,
+  ft_SUBGLYPH_FLAG_ROUND_XY_TO_GRID = FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID,
+  ft_SUBGLYPH_FLAG_SCALE = FT_SUBGLYPH_FLAG_SCALE,
+  ft_SUBGLYPH_FLAG_XY_SCALE = FT_SUBGLYPH_FLAG_XY_SCALE,
+  ft_SUBGLYPH_FLAG_2X2 = FT_SUBGLYPH_FLAG_2X2,
+  ft_SUBGLYPH_FLAG_USE_MY_METRICS = FT_SUBGLYPH_FLAG_USE_MY_METRICS
+}
+
+ft_FSTYPE_INSTALLABLE_EMBEDDING :: FT_UShort
+ft_FSTYPE_INSTALLABLE_EMBEDDING =
+  #const FT_FSTYPE_INSTALLABLE_EMBEDDING
+ft_FSTYPE_RESTRICTED_LICENSE_EMBEDDING :: FT_UShort
+ft_FSTYPE_RESTRICTED_LICENSE_EMBEDDING =
+  #const FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING
+ft_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING :: FT_UShort
+ft_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING =
+  #const FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING
+ft_FSTYPE_EDITABLE_EMBEDDING :: FT_UShort
+ft_FSTYPE_EDITABLE_EMBEDDING =
+  #const FT_FSTYPE_EDITABLE_EMBEDDING
+ft_FSTYPE_NO_SUBSETTING :: FT_UShort
+ft_FSTYPE_NO_SUBSETTING =
+  #const FT_FSTYPE_NO_SUBSETTING
+ft_FSTYPE_BITMAP_EMBEDDING_ONLY :: FT_UShort
+ft_FSTYPE_BITMAP_EMBEDDING_ONLY =
+  #const FT_FSTYPE_BITMAP_EMBEDDING_ONLY
+
+newtype FT_Glyph_Format = FT_Glyph_Format FT_UInt32
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_Glyph_Format, FT_Glyph_Format,
+  ft_GLYPH_FORMAT_NONE = FT_GLYPH_FORMAT_NONE,
+  ft_GLYPH_FORMAT_COMPOSITE = FT_GLYPH_FORMAT_COMPOSITE,
+  ft_GLYPH_FORMAT_BITMAP = FT_GLYPH_FORMAT_BITMAP,
+  ft_GLYPH_FORMAT_OUTLINE = FT_GLYPH_FORMAT_OUTLINE,
+  ft_GLYPH_FORMAT_PLOTTER = FT_GLYPH_FORMAT_PLOTTER
+}
+
+newtype FT_OUTLINE_FLAGS = FT_OUTLINE_FLAGS FT_UInt32
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_OUTLINE_FLAGS, FT_OUTLINE_FLAGS,
+  ft_OUTLINE_NONE = FT_OUTLINE_NONE,
+  ft_OUTLINE_OWNER = FT_OUTLINE_OWNER,
+  ft_OUTLINE_EVEN_ODD_FILL = FT_OUTLINE_EVEN_ODD_FILL,
+  ft_OUTLINE_REVERSE_FILL = FT_OUTLINE_REVERSE_FILL,
+  ft_OUTLINE_IGNORE_DROPOUTS = FT_OUTLINE_IGNORE_DROPOUTS,
+  ft_OUTLINE_SMART_DROPOUTS = FT_OUTLINE_SMART_DROPOUTS,
+  ft_OUTLINE_INCLUDE_STUBS = FT_OUTLINE_INCLUDE_STUBS,
+  ft_OUTLINE_HIGH_PRECISION = FT_OUTLINE_HIGH_PRECISION,
+  ft_OUTLINE_SINGLE_PASS = FT_OUTLINE_SINGLE_PASS
+}
+
+newtype FT_Orientation = FT_Orientation FT_UInt
+  deriving (Eq, Show, Real, Ord, Enum, Num, Integral, Storable)
+
+#{enum FT_Orientation, FT_Orientation,
+  ft_ORIENTATION_TRUETYPE = FT_ORIENTATION_TRUETYPE,
+  ft_ORIENTATION_POSTSCRIPT = FT_ORIENTATION_POSTSCRIPT,
+  ft_ORIENTATION_FILL_RIGHT = FT_ORIENTATION_FILL_RIGHT,
+  ft_ORIENTATION_FILL_LEFT = FT_ORIENTATION_FILL_LEFT,
+  ft_ORIENTATION_NONE = FT_ORIENTATION_NONE
 }
diff --git a/Graphics/Rendering/FreeType/Internal/RasterParams.hsc b/Graphics/Rendering/FreeType/Internal/RasterParams.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/RasterParams.hsc
@@ -0,0 +1,85 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.RasterParams
+( FT_Raster_Params
+, FT_SpanFunc
+, FT_Raster_BitTest_Func
+, FT_Raster_BitSet_Func
+, target
+, source
+, flags
+, gray_spans
+, user
+, clip_box
+) where
+
+import Foreign
+import Foreign.C.Types
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.BBox
+import Graphics.Rendering.FreeType.Internal.Bitmap
+import Graphics.Rendering.FreeType.Internal.Span
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Raster_Params = FT_Raster_Params
+  { target      :: Ptr FT_Bitmap
+  , source      :: Ptr ()
+  , flags       :: CInt
+  , gray_spans  :: FT_SpanFunc
+  , black_spans :: FT_SpanFunc            -- doesn't work according to FT docs
+  , bit_test    :: FT_Raster_BitTest_Func -- doesn't work according to FT docs
+  , bit_set     :: FT_Raster_BitSet_Func  -- doesn't work according to FT docs
+  , user        :: Ptr ()
+  , clip_box    :: FT_BBox
+  }
+
+instance Storable FT_Raster_Params where
+  sizeOf    _ = #size FT_Raster_Params
+  alignment _ = #alignment FT_Raster_Params
+  peek ptr = do
+    target'      <- (#peek FT_Raster_Params, target) ptr
+    source'      <- (#peek FT_Raster_Params, source) ptr
+    flags'       <- (#peek FT_Raster_Params, flags) ptr
+    gray_spans'  <- (#peek FT_Raster_Params, gray_spans) ptr
+    black_spans' <- (#peek FT_Raster_Params, black_spans) ptr
+    bit_test'    <- (#peek FT_Raster_Params, bit_test) ptr
+    bit_set'     <- (#peek FT_Raster_Params, bit_set) ptr
+    user'        <- (#peek FT_Raster_Params, user) ptr
+    clip_box'    <- (#peek FT_Raster_Params, clip_box) ptr
+    return $ FT_Raster_Params
+      { target = target'
+      , source = source'
+      , flags = flags'
+      , gray_spans = gray_spans'
+      , black_spans = black_spans'
+      , bit_test = bit_test'
+      , bit_set = bit_set'
+      , user = user'
+      , clip_box = clip_box'
+      }
+  poke ptr val = do
+    (#poke FT_Raster_Params, target) ptr (target val)
+    (#poke FT_Raster_Params, source) ptr (source val)
+    (#poke FT_Raster_Params, flags) ptr (flags val)
+    (#poke FT_Raster_Params, gray_spans) ptr (gray_spans val)
+    (#poke FT_Raster_Params, black_spans) ptr (black_spans val)
+    (#poke FT_Raster_Params, bit_test) ptr (bit_test val)
+    (#poke FT_Raster_Params, bit_set) ptr (bit_set val)
+    (#poke FT_Raster_Params, user) ptr (user val)
+    (#poke FT_Raster_Params, clip_box) ptr (clip_box val)
+
+type FT_SpanFunc = FunPtr
+  (CInt -> CInt -> Ptr FT_Span -> Ptr () -> IO ())
+
+type FT_Raster_BitTest_Func = FunPtr
+  (CInt -> CInt -> Ptr () -> IO CInt)
+
+type FT_Raster_BitSet_Func = FunPtr
+  (CInt -> CInt -> Ptr () -> IO ())
diff --git a/Graphics/Rendering/FreeType/Internal/Renderer.hs b/Graphics/Rendering/FreeType/Internal/Renderer.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Renderer.hs
@@ -0,0 +1,11 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Renderer
+( FT_RendererRec_
+, FT_Renderer
+) where
+
+import Foreign
+
+data FT_RendererRec_
+type FT_Renderer = Ptr FT_RendererRec_
+
diff --git a/Graphics/Rendering/FreeType/Internal/Size.hsc b/Graphics/Rendering/FreeType/Internal/Size.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Size.hsc
@@ -0,0 +1,35 @@
+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Size
+( FT_SizeRec_
+, FT_Size
+, face
+, generic
+, metrics
+) where
+
+import Foreign
+
+import Graphics.Rendering.FreeType.Internal.FaceType
+import Graphics.Rendering.FreeType.Internal.SizeMetrics
+import Graphics.Rendering.FreeType.Internal.Generic
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "internal/ftobjs.h"
+
+data FT_SizeRec_
+type FT_Size = Ptr FT_SizeRec_
+
+face :: FT_Size -> Ptr FT_Face
+face = #ptr struct FT_SizeRec_, face
+
+generic :: FT_Size -> Ptr FT_Generic
+generic = #ptr struct FT_SizeRec_, generic
+
+metrics :: FT_Size -> Ptr FT_Size_Metrics
+metrics = #ptr struct FT_SizeRec_, metrics
+
diff --git a/Graphics/Rendering/FreeType/Internal/SizeMetrics.hsc b/Graphics/Rendering/FreeType/Internal/SizeMetrics.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/SizeMetrics.hsc
@@ -0,0 +1,59 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.SizeMetrics
+( FT_Size_Metrics(..)
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+data FT_Size_Metrics = FT_Size_Metrics
+  { x_ppem      :: FT_UShort
+  , y_ppem      :: FT_UShort
+  , x_scale     :: FT_Fixed
+  , y_scale     :: FT_Fixed
+  , ascender    :: FT_Pos
+  , descender   :: FT_Pos
+  , height      :: FT_Pos
+  , max_advance :: FT_Pos
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Size_Metrics where
+  sizeOf    _ = #size FT_Size_Metrics
+  alignment _ = #alignment FT_Size_Metrics
+  peek ptr = do
+    x_ppem'      <- (#peek FT_Size_Metrics, x_ppem) ptr
+    y_ppem'      <- (#peek FT_Size_Metrics, y_ppem) ptr
+    x_scale'     <- (#peek FT_Size_Metrics, x_scale) ptr
+    y_scale'     <- (#peek FT_Size_Metrics, y_scale) ptr
+    ascender'    <- (#peek FT_Size_Metrics, ascender) ptr
+    descender'   <- (#peek FT_Size_Metrics, descender) ptr
+    height'      <- (#peek FT_Size_Metrics, height) ptr
+    max_advance' <- (#peek FT_Size_Metrics, max_advance) ptr
+    return $ FT_Size_Metrics
+      { x_ppem = x_ppem'
+      , y_ppem = y_ppem'
+      , x_scale = x_scale'
+      , y_scale = y_scale'
+      , ascender = ascender'
+      , descender = descender'
+      , height = height'
+      , max_advance = max_advance'
+      }
+  poke ptr val = do
+    (#poke FT_Size_Metrics, x_ppem) ptr (x_ppem val)
+    (#poke FT_Size_Metrics, y_ppem) ptr (y_ppem val)
+    (#poke FT_Size_Metrics, x_scale) ptr (x_scale val)
+    (#poke FT_Size_Metrics, y_scale) ptr (y_scale val)
+    (#poke FT_Size_Metrics, ascender) ptr (ascender val)
+    (#poke FT_Size_Metrics, descender) ptr (descender val)
+    (#poke FT_Size_Metrics, height) ptr (height val)
+    (#poke FT_Size_Metrics, max_advance) ptr (max_advance val)
diff --git a/Graphics/Rendering/FreeType/Internal/SizeRequest.hsc b/Graphics/Rendering/FreeType/Internal/SizeRequest.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/SizeRequest.hsc
@@ -0,0 +1,48 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.SizeRequest
+( FT_Size_RequestRec(..)
+, FT_Size_Request
+) where
+
+import Foreign
+import Foreign.Storable
+
+import Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+type FT_Size_Request = Ptr FT_Size_RequestRec
+
+data FT_Size_RequestRec = FT_Size_RequestRec
+  { type_  :: FT_Size_Request_Type
+  , width  :: FT_Long
+  , height :: FT_Long
+  , horiResolution :: FT_UInt
+  , vertResolution :: FT_UInt
+  }
+
+instance Storable FT_Size_RequestRec where
+  sizeOf    _ = #size FT_Size_RequestRec
+  alignment _ = #alignment FT_Size_RequestRec
+  peek ptr = do
+    type_'          <- (#peek FT_Size_RequestRec, type) ptr
+    width'          <- (#peek FT_Size_RequestRec, width) ptr
+    height'         <- (#peek FT_Size_RequestRec, height) ptr
+    horiResolution' <- (#peek FT_Size_RequestRec, horiResolution) ptr
+    vertResolution' <- (#peek FT_Size_RequestRec, vertResolution) ptr
+    return $ FT_Size_RequestRec
+      { type_ = type_'
+      , width = width'
+      , height = height'
+      , horiResolution = horiResolution'
+      , vertResolution = vertResolution'
+      }
+  poke ptr val = do
+    (#poke FT_Size_RequestRec, type) ptr (type_ val)
+    (#poke FT_Size_RequestRec, height) ptr (height val)
+    (#poke FT_Size_RequestRec, horiResolution) ptr (horiResolution val)
+    (#poke FT_Size_RequestRec, vertResolution) ptr (vertResolution val)
diff --git a/Graphics/Rendering/FreeType/Internal/Span.hsc b/Graphics/Rendering/FreeType/Internal/Span.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Span.hsc
@@ -0,0 +1,41 @@
+{-# LANGUAGE ForeignFunctionInterface #-}
+module Graphics.Rendering.FreeType.Internal.Span
+( FT_Span(..)
+) where
+
+import Foreign
+import Foreign.C.Types
+import Foreign.Storable
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftimage.h"
+
+data FT_Span = FT_Span
+  { x        :: CShort
+  , len      :: CUShort
+  , coverage :: CUChar
+  }
+  deriving (Read, Show, Eq)
+
+instance Storable FT_Span where
+  sizeOf    _ = #size FT_Span
+  alignment _ = #alignment FT_Span
+  peek ptr = do
+    x'        <- (#peek FT_Span, x) ptr
+    len'      <- (#peek FT_Span, len) ptr
+    coverage' <- (#peek FT_Span, coverage) ptr
+    return $ FT_Span
+      { x = x'
+      , len = len'
+      , coverage = coverage'
+      }
+  poke ptr val = do
+    (#poke FT_Span, x) ptr (x val)
+    (#poke FT_Span, len) ptr (len val)
+    (#poke FT_Span, coverage) ptr (coverage val)
+
diff --git a/Graphics/Rendering/FreeType/Internal/Stream.hsc b/Graphics/Rendering/FreeType/Internal/Stream.hsc
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/Stream.hsc
@@ -0,0 +1,71 @@
+{-# LANGUAGE ForeignFunctionInterface, EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.Stream
+( FT_StreamRec_
+, FT_Stream
+, FT_StreamDesc
+, FT_Stream_IoFunc
+, FT_Stream_CloseFunc
+, base
+, size
+, pos
+, descriptor
+, read
+, close
+, memory
+, cursor
+, limit
+) where
+
+import Prelude hiding (read)
+
+import Foreign
+import Foreign.C.Types
+
+import Graphics.Rendering.FreeType.Internal.Memory
+
+#include <stddef.h>
+#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)
+
+#include "ft2build.h"
+#include FT_FREETYPE_H
+
+#include "freetype/ftsystem.h"
+
+-- We don't have FILE* in Haskell, so we cheat and only
+-- consider the long part of the FT_StreamDesc union...
+type FT_StreamDesc = CLong
+
+type FT_Stream_IoFunc = FunPtr
+  (FT_Stream -> CULong -> Ptr CUChar -> CULong -> IO CULong)
+
+type FT_Stream_CloseFunc = FunPtr (FT_Stream -> IO ())
+
+data FT_StreamRec_
+type FT_Stream = Ptr FT_StreamRec_
+
+base :: FT_Stream -> Ptr (Ptr CUChar)
+base = #ptr struct FT_StreamRec_, base
+
+size :: FT_Stream -> Ptr CULong
+size = #ptr struct FT_StreamRec_, size
+
+pos :: FT_Stream -> Ptr CULong
+pos = #ptr struct FT_StreamRec_, pos 
+
+descriptor :: FT_Stream -> Ptr FT_StreamDesc
+descriptor = #ptr struct FT_StreamRec_, descriptor
+
+read :: FT_Stream -> Ptr FT_Stream_IoFunc
+read = #ptr struct FT_StreamRec_, read
+
+close :: FT_Stream -> Ptr FT_Stream_CloseFunc
+close = #ptr struct FT_StreamRec_, close
+
+memory :: FT_Stream -> Ptr FT_Memory
+memory = #ptr struct FT_StreamRec_, memory
+
+cursor :: FT_Stream -> Ptr (Ptr CUChar)
+cursor = #ptr struct FT_StreamRec_, cursor
+
+limit :: FT_Stream -> Ptr (Ptr CUChar)
+limit = #ptr struct FT_StreamRec_, limit
diff --git a/Graphics/Rendering/FreeType/Internal/SubGlyph.hs b/Graphics/Rendering/FreeType/Internal/SubGlyph.hs
new file mode 100644
--- /dev/null
+++ b/Graphics/Rendering/FreeType/Internal/SubGlyph.hs
@@ -0,0 +1,10 @@
+{-# LANGUAGE EmptyDataDecls #-}
+module Graphics.Rendering.FreeType.Internal.SubGlyph
+( FT_SubGlyphRec_
+, FT_SubGlyph
+) where
+
+import Foreign
+
+data FT_SubGlyphRec_
+type FT_SubGlyph = Ptr FT_SubGlyphRec_
diff --git a/freetype2.cabal b/freetype2.cabal
--- a/freetype2.cabal
+++ b/freetype2.cabal
@@ -1,5 +1,5 @@
 Name:                freetype2
-Version:             0.0.1
+Version:             0.1.0
 Synopsis:            Haskell binding for FreeType 2 library
 Description:         Wrapper around FreeType 2 library.  Relevant
                      exerpts from the FreeType 2 website:
@@ -156,14 +156,36 @@
 Library
   -- Modules exported by the library.
   Exposed-modules: Graphics.Rendering.FreeType.Internal
+                   Graphics.Rendering.FreeType.Internal.BBox
                    Graphics.Rendering.FreeType.Internal.Bitmap
+                   Graphics.Rendering.FreeType.Internal.BitmapGlyph
+                   Graphics.Rendering.FreeType.Internal.BitmapSize
+                   Graphics.Rendering.FreeType.Internal.CharMap
+                   Graphics.Rendering.FreeType.Internal.Driver
                    Graphics.Rendering.FreeType.Internal.Face
+                   Graphics.Rendering.FreeType.Internal.FaceType
+                   Graphics.Rendering.FreeType.Internal.Generic
+                   Graphics.Rendering.FreeType.Internal.Glyph
+                   Graphics.Rendering.FreeType.Internal.GlyphMetrics
                    Graphics.Rendering.FreeType.Internal.GlyphSlot
                    Graphics.Rendering.FreeType.Internal.Library
                    Graphics.Rendering.FreeType.Internal.Matrix
+                   Graphics.Rendering.FreeType.Internal.Memory
+                   Graphics.Rendering.FreeType.Internal.Module
+                   Graphics.Rendering.FreeType.Internal.OpenArgs
+                   Graphics.Rendering.FreeType.Internal.Outline
+                   Graphics.Rendering.FreeType.Internal.OutlineGlyph
+                   Graphics.Rendering.FreeType.Internal.Parameter
                    Graphics.Rendering.FreeType.Internal.PrimitiveTypes
+                   Graphics.Rendering.FreeType.Internal.RasterParams
+                   Graphics.Rendering.FreeType.Internal.Renderer
+                   Graphics.Rendering.FreeType.Internal.Size
+                   Graphics.Rendering.FreeType.Internal.SizeMetrics
+                   Graphics.Rendering.FreeType.Internal.SizeRequest
+                   Graphics.Rendering.FreeType.Internal.Stream
+                   Graphics.Rendering.FreeType.Internal.Span
+                   Graphics.Rendering.FreeType.Internal.SubGlyph
                    Graphics.Rendering.FreeType.Internal.Vector
-                   Graphics.Rendering.FreeType.Internal.Glyph
 
   -- Packages needed in order to build this package.
   Build-depends: base > 3 && < 5