diff --git a/gegl.cabal b/gegl.cabal
--- a/gegl.cabal
+++ b/gegl.cabal
@@ -2,7 +2,7 @@
 -- see http://haskell.org/cabal/users-guide/
 
 name:                gegl
-version:             0.0.0.4
+version:             0.0.0.5
 synopsis:            Haskell bindings to GEGL library
 description:         This package contains the Haskell bindings to the GEGL
                      library.
diff --git a/src/GEGL/Buffer.hs b/src/GEGL/Buffer.hs
--- a/src/GEGL/Buffer.hs
+++ b/src/GEGL/Buffer.hs
@@ -46,6 +46,9 @@
 import BABL.Format (PixelFormat, babl_format)
 import BABL.FFI.Format (BablFormatPtr(..))
 
+import System.Glib.GObject (objectUnref)
+
+import Foreign.ForeignPtr
 import Foreign.Storable (peek)
 import Foreign.C.String
 import Foreign.C.Types (CDouble(..), CInt(..))
@@ -64,13 +67,15 @@
   ptr <- case mrect of
     Just rect -> new rect
     Nothing   -> return nullPtr
-  val <- FFI.GeglBuffer <$> FFI.c_gegl_buffer_new ptr format
+  val <- FFI.GeglBuffer <$>
+    (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_new ptr format)
   free ptr
   return val
 
 -- | Creates a new 'GeglBuffer', which defaults to an empty buffer with the 'RGBAfloat' format.
 gegl_buffer_default_new :: IO FFI.GeglBuffer
-gegl_buffer_default_new = FFI.GeglBuffer <$> FFI.c_gegl_buffer_new nullPtr nullPtr
+gegl_buffer_default_new = FFI.GeglBuffer <$>
+  (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_new nullPtr nullPtr)
 
 -- | Create a new 'GeglBuffer' from a backend. If @Nothing@ is passed as geometry,
 --   The extent will be inherited from the backend
@@ -82,7 +87,8 @@
   rectPtr <- case mext of
     Just ext -> new ext
     Nothing  -> return nullPtr
-  buf <- FFI.GeglBuffer <$> FFI.c_gegl_buffer_new_for_backend rectPtr backend
+  buf <- FFI.GeglBuffer <$>
+    (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_new_for_backend rectPtr backend)
   free rectPtr
   return buf
 
@@ -94,7 +100,7 @@
   -> IO FFI.GeglBuffer -- ^ The buffer
 gegl_buffer_open fp = do
   cfp <- newCString fp
-  ret <- FFI.GeglBuffer <$> FFI.c_gegl_buffer_open cfp
+  ret <- FFI.GeglBuffer <$> (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_open cfp)
   free cfp
   return ret
 
@@ -104,10 +110,11 @@
   -> FilePath           -- Path where to save
   -> FFI.GeglRectangle  -- Region of interest to write
   -> IO ()
-gegl_buffer_save (FFI.GeglBuffer buf) fp roi = do
+gegl_buffer_save (FFI.GeglBuffer fbuf) fp roi = do
   croi <- new roi
   cfp  <- newCString fp
-  FFI.c_gegl_buffer_save buf cfp croi
+  withForeignPtr fbuf $ \buf ->
+    FFI.c_gegl_buffer_save buf cfp croi
   free croi
   free cfp
 
@@ -117,7 +124,7 @@
   -> IO FFI.GeglBuffer -- Resulting buffer
 gegl_buffer_load path = do
   cpath <- newCString path
-  ret <- FFI.GeglBuffer <$> FFI.c_gegl_buffer_load cpath
+  ret <- FFI.GeglBuffer <$> (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_load cpath)
   free cpath
   return ret
 
@@ -126,17 +133,19 @@
 gegl_buffer_flush
   :: FFI.GeglBuffer -- ^ Buffer to flush
   -> IO ()
-gegl_buffer_flush (FFI.GeglBuffer buf) =
-  FFI.c_gegl_buffer_flush buf
+gegl_buffer_flush (FFI.GeglBuffer fbuf) =
+  withForeignPtr fbuf $ \buf ->
+    FFI.c_gegl_buffer_flush buf
 
 -- | Create a new sub 'GeglBuffer', that is a view on a larger buffer.
 gegl_buffer_create_sub_buffer
   :: FFI.GeglBuffer    -- ^ Parent buffer
   -> FFI.GeglRectangle -- ^ Coordinates of new buffer
   -> IO FFI.GeglBuffer -- ^ Child buffer
-gegl_buffer_create_sub_buffer (FFI.GeglBuffer buf) rect = do
+gegl_buffer_create_sub_buffer (FFI.GeglBuffer fbuf) rect = do
   crect <- new rect
-  ret <- FFI.GeglBuffer <$> FFI.c_gegl_buffer_create_sub_buffer buf crect
+  ret <- withForeignPtr fbuf $ \buf -> FFI.GeglBuffer <$>
+    (newForeignPtr objectUnref =<< FFI.c_gegl_buffer_create_sub_buffer buf crect)
   free crect
   return ret
 
@@ -144,8 +153,8 @@
 gegl_buffer_get_extent
   :: FFI.GeglBuffer       -- ^ The buffer
   -> IO FFI.GeglRectangle -- ^ active area
-gegl_buffer_get_extent (FFI.GeglBuffer buffer) = do
-  rectPtr <- FFI.c_gegl_buffer_get_extent buffer
+gegl_buffer_get_extent (FFI.GeglBuffer fbuffer) = do
+  rectPtr <- withForeignPtr fbuffer $ \buffer -> FFI.c_gegl_buffer_get_extent buffer
   rect <- peek rectPtr
   -- free rectPtr
   return rect
@@ -155,9 +164,9 @@
   :: FFI.GeglBuffer    -- ^ The buffer
   -> FFI.GeglRectangle -- ^ New extent of the buffer
   -> IO Bool           -- ^ Returns 'True' on success, otherwise 'False'
-gegl_buffer_set_extent (FFI.GeglBuffer buffer) rect = do
+gegl_buffer_set_extent (FFI.GeglBuffer fbuffer) rect = do
   ptr <- new rect
-  val <- FFI.c_gegl_buffer_set_extent buffer ptr
+  val <- withForeignPtr fbuffer $ \buffer -> FFI.c_gegl_buffer_set_extent buffer ptr
   free ptr
   return val
 
@@ -207,9 +216,10 @@
   -> FFI.GeglRectangle -- ^ Area of the buffer to fill
   -> FFI.GeglColor     -- ^ The colour to fill with
   -> IO ()
-gegl_buffer_set_color (FFI.GeglBuffer buffer) rect (FFI.GeglColor color) = do
+gegl_buffer_set_color (FFI.GeglBuffer fbuffer) rect (FFI.GeglColor color) = do
   rectPtr <- new rect
-  FFI.c_gegl_buffer_set_color buffer rectPtr color
+  withForeignPtr fbuffer $ \buffer ->
+    FFI.c_gegl_buffer_set_color buffer rectPtr color
   free rectPtr
 
 -- | Fill a region with a repeating pattern.
@@ -221,20 +231,22 @@
   -> Double            -- ^ Y offset
   -> IO ()
 gegl_buffer_set_pattern
-  (FFI.GeglBuffer buffer)
+  (FFI.GeglBuffer fbuffer)
   rect
-  (FFI.GeglBuffer pattern)
+  (FFI.GeglBuffer fpattern)
   xoff
   yoff
   = do
     rectPtr <- new rect
     let (cx, cy) = (CDouble xoff, CDouble yoff)
-    FFI.c_gegl_buffer_set_pattern
-      buffer
-      rectPtr
-      pattern
-      cx
-      cy
+    withForeignPtr fbuffer $ \buffer ->
+      withForeignPtr fpattern $ \pattern ->
+        FFI.c_gegl_buffer_set_pattern
+          buffer
+          rectPtr
+          pattern
+          cx
+          cy
     free rectPtr
 
 -- | Clear a provided rectangular region by setting all associated memory to 0.
@@ -242,9 +254,10 @@
   :: FFI.GeglBuffer    -- ^ Target buffer
   -> FFI.GeglRectangle -- ^ Area to clear
   -> IO ()
-gegl_buffer_clear (FFI.GeglBuffer buf) rect = do
+gegl_buffer_clear (FFI.GeglBuffer fbuf) rect = do
   rectPtr <- new rect
-  FFI.c_gegl_buffer_clear buf rectPtr
+  withForeignPtr fbuf $ \buf ->
+    FFI.c_gegl_buffer_clear buf rectPtr
   free rectPtr
 
 -- | Fetch a rectangular linear buffer of pixel data from the 'GeglBuffer',
@@ -261,19 +274,20 @@
                              -- automatically from format
   -> GeglAbyssPolicy         -- Abyss policy
   -> IO ()
-gegl_buffer_get (FFI.GeglBuffer buf) mrect scale mformat dest stride ap = do
+gegl_buffer_get (FFI.GeglBuffer fbuf) mrect scale mformat dest stride ap = do
   rect <- case mrect of
     Just r -> new r
     Nothing -> return nullPtr
   let format = case mformat of
         Just (BablFormatPtr ptr) -> ptr
         Nothing -> nullPtr
-  FFI.c_gegl_buffer_get
-    buf
-    rect
-    (CDouble scale)
-    format
-    dest
-    (CInt $ fromIntegral stride)
-    (CInt $ fromIntegral $ fromEnum ap)
+  withForeignPtr fbuf $ \buf ->
+    FFI.c_gegl_buffer_get
+      buf
+      rect
+      (CDouble scale)
+      format
+      dest
+      (CInt $ fromIntegral stride)
+      (CInt $ fromIntegral $ fromEnum ap)
   free rect
diff --git a/src/GEGL/Buffer/BufferIterator.hs b/src/GEGL/Buffer/BufferIterator.hs
--- a/src/GEGL/Buffer/BufferIterator.hs
+++ b/src/GEGL/Buffer/BufferIterator.hs
@@ -21,6 +21,7 @@
 import qualified BABL.Format as BF
 import BABL.FFI.Format (BablFormatPtr(..))
 
+import Foreign.ForeignPtr
 import Foreign.Marshal.Utils (new)
 import Foreign.Ptr
 import Foreign.C.Types
@@ -54,16 +55,17 @@
   -> GeglAccessMode  -- ^ Access mode to pixel data
   -> GeglAbyssPolicy -- ^ Abyss policy for pixel data
   -> IO FFI.GeglBufferIterator
-gegl_buffer_iterator_new (GeglBuffer buf) roi format am ap = do
+gegl_buffer_iterator_new (GeglBuffer fbuf) roi format am ap = do
   roiPtr <- new roi
   (BablFormatPtr formatPtr) <- BF.babl_format format
-  FFI.GeglBufferIterator <$> FFI.c_gegl_buffer_iterator_new
-    buf
-    roiPtr
-    (CInt 0)
-    formatPtr
-    (marshal am)
-    (marshal ap)
+  withForeignPtr fbuf $ \buf ->
+    FFI.GeglBufferIterator <$> FFI.c_gegl_buffer_iterator_new
+      buf
+      roiPtr
+      (CInt 0)
+      formatPtr
+      (marshal am)
+      (marshal ap)
 
 -- | This function fills the 'FFI.GeglBufferIterator' with its appropriate data
 --   and returns 'True' as long as there is something to iterate over. Upon
diff --git a/src/GEGL/FFI/Buffer.hs b/src/GEGL/FFI/Buffer.hs
--- a/src/GEGL/FFI/Buffer.hs
+++ b/src/GEGL/FFI/Buffer.hs
@@ -23,6 +23,7 @@
 import Foreign.C.Types
 import Foreign.C.String
 import Foreign.Ptr
+import Foreign.ForeignPtr
 
 import GEGL.FFI.Rectangle (GeglRectangle)
 import GEGL.FFI.Color     (GeglColorDummy)
@@ -30,7 +31,7 @@
 import BABL.FFI.Format (BablFormatDummy)
 
 -- | Pointer holding a buffer. Never peek or poke it.
-type GeglBufferDummy = Ptr ()
+type GeglBufferDummy = ForeignPtr ()
 -- | Outward representation of the buffer.
 data GeglBuffer = GeglBuffer GeglBufferDummy
 
@@ -39,25 +40,25 @@
   c_gegl_buffer_new
     :: Ptr GeglRectangle  -- ^ Buffer geometry
     -> BablFormatDummy  -- ^ Color format
-    -> IO GeglBufferDummy -- ^ New buffer
+    -> IO (Ptr()) -- ^ New buffer
 
 -- | Interface to the @gegl_buffer_new_for_backend@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_new_for_backend"
   c_gegl_buffer_new_for_backend
     :: Ptr GeglRectangle  -- ^ Buffer geometry
     -> Ptr a              -- ^ The backend
-    -> IO GeglBufferDummy -- ^ New buffer
+    -> IO (Ptr()) -- ^ New buffer
 
 -- | Interace to the @gegl_buffer_open@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_open"
   c_gegl_buffer_open
     :: CString            -- Path to buffer on disc
-    -> IO GeglBufferDummy -- The buffer
+    -> IO (Ptr ()) -- The buffer
 
 -- | Interface to the @gegl_buffer_save@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_save"
   c_gegl_buffer_save
-    :: GeglBufferDummy
+    :: Ptr ()
     -> CString
     -> Ptr GeglRectangle
     -> IO ()
@@ -66,38 +67,38 @@
 foreign import ccall unsafe "gegl.h gegl_buffer_load"
   c_gegl_buffer_load
     :: CString
-    -> IO GeglBufferDummy
+    -> IO (Ptr ())
 
 -- | Interface to the @gegl_buffer_flush@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_flush"
   c_gegl_buffer_flush
-    :: GeglBufferDummy
+    :: Ptr ()
     -> IO ()
 
 -- | Interface to the @gegl_buffer_create_sub_buffer@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_create_sub_buffer"
   c_gegl_buffer_create_sub_buffer
-    :: GeglBufferDummy
+    :: Ptr ()
     -> Ptr GeglRectangle
-    -> IO GeglBufferDummy
+    -> IO (Ptr ())
 
 -- | Interface to the @gegl_buffer_get_extent@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_get_extent"
   c_gegl_buffer_get_extent
-    :: GeglBufferDummy
+    :: Ptr ()
     -> IO (Ptr GeglRectangle)
 
 -- | Interface to the @gegl_buffer_set_extent@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_set_extent"
   c_gegl_buffer_set_extent
-    :: GeglBufferDummy   -- ^ A buffer
+    :: Ptr ()   -- ^ A buffer
     -> Ptr GeglRectangle -- ^ Geometry
     -> IO Bool           -- ^ Returns True on success
 
 -- | Interface to the @gegl_buffer_set_color@ funciton in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_set_color"
   c_gegl_buffer_set_color
-    :: GeglBufferDummy   -- ^ The buffer
+    :: Ptr ()   -- ^ The buffer
     -> Ptr GeglRectangle -- ^ Rectangular region to fill
     -> GeglColorDummy    -- ^ The colour to fill with.
     -> IO ()
@@ -105,9 +106,9 @@
 -- | Interface to the @gegl_bufer_set_pattern@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_set_pattern"
   c_gegl_buffer_set_pattern
-    :: GeglBufferDummy   -- ^ The target buffer
+    :: Ptr ()   -- ^ The target buffer
     -> Ptr GeglRectangle -- ^ rectangular region to fill
-    -> GeglBufferDummy   -- ^ A buffer to be repeated as pattern
+    -> (Ptr())   -- ^ A buffer to be repeated as pattern
     -> CDouble           -- ^ X offset
     -> CDouble           -- ^ Y offset
     -> IO ()
@@ -115,14 +116,14 @@
 -- | Interface to the @gegl_buffer_clear@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_clear"
   c_gegl_buffer_clear
-    :: GeglBufferDummy   -- ^ The target buffer
+    :: Ptr ()   -- ^ The target buffer
     -> Ptr GeglRectangle -- ^ Region to clear
     -> IO ()
 
 -- | Interface to the @gegl_bufer_get@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_get"
   c_gegl_buffer_get
-    :: GeglBufferDummy   -- ^ Buffer to retrieve data from
+    :: Ptr ()   -- ^ Buffer to retrieve data from
     -> Ptr GeglRectangle -- ^ Coordinates to retrieve from
     -> CDouble           -- ^ Sampling scale
     -> BablFormatDummy   -- ^ 'BablFormat' to store the data in
diff --git a/src/GEGL/FFI/Buffer/BufferIterator.hs b/src/GEGL/FFI/Buffer/BufferIterator.hs
--- a/src/GEGL/FFI/Buffer/BufferIterator.hs
+++ b/src/GEGL/FFI/Buffer/BufferIterator.hs
@@ -54,7 +54,7 @@
 -- | Interface the the @gegl_buffer_iterator_new@ function in C.
 foreign import ccall unsafe "gegl.h gegl_buffer_iterator_new"
   c_gegl_buffer_iterator_new
-    :: GeglBufferDummy   -- ^ Buffer to draw data from
+    :: Ptr ()            -- ^ Buffer to draw data from
     -> Ptr GeglRectangle -- ^ Rectangle to iterate over
     -> CInt              -- ^ Representation of level
     -> BablFormatDummy   -- ^ Format to process the buffer data in
diff --git a/src/GEGL/Node.hs b/src/GEGL/Node.hs
--- a/src/GEGL/Node.hs
+++ b/src/GEGL/Node.hs
@@ -28,7 +28,7 @@
 -- | Creates a new GEGL node graph that can contain further processing nodes.
 gegl_node_new :: IO FFI.GeglNode -- ^ A new top level 'FFI.GeglNode'
 -- gegl_node_new = FFI.GeglNode <$> (newForeignPtr objectUnref =<< FFI.c_gegl_node_new)
-gegl_node_new = FFI.GeglNode <$> (newForeignPtr_ =<< FFI.c_gegl_node_new)
+gegl_node_new = FFI.GeglNode <$> (newForeignPtr objectUnref =<< FFI.c_gegl_node_new)
 
 -- | Creates a new processing node that performs the specified operation.
 gegl_node_new_child
@@ -73,8 +73,9 @@
         PropertyFormat f -> do
           (B.BablFormatPtr ptr) <- B.babl_format f
           FFI.gegl_node_set_single_ptr node cname ptr
-        PropertyBuffer (FFI.GeglBuffer ptr) ->
-          FFI.gegl_node_set_single_ptr node cname ptr
+        PropertyBuffer (FFI.GeglBuffer fptr) ->
+          withForeignPtr fptr $ \ptr ->
+            FFI.gegl_node_set_single_ptr node cname ptr
         PropertyPointer ptr ->
           FFI.gegl_node_set_single_ptr node cname ptr
         _ ->
@@ -88,5 +89,5 @@
   :: FFI.GeglNode
   -> IO ()
 gegl_node_drop (FFI.GeglNode node) = do
-  addForeignPtrFinalizer objectUnref node
+  -- addForeignPtrFinalizer objectUnref node
   finalizeForeignPtr node
diff --git a/src/GEGL/Rectangle.hs b/src/GEGL/Rectangle.hs
--- a/src/GEGL/Rectangle.hs
+++ b/src/GEGL/Rectangle.hs
@@ -14,7 +14,7 @@
 -- | Calculates the intersection of two rectangles.
 gegl_rectangle_intersect
   :: FFI.GeglRectangle            -- ^ A rectangle
-  -> FFI.GeglRectangle            -- ^ A rectnagle
+  -> FFI.GeglRectangle            -- ^ A rectangle
   -> IO (Maybe FFI.GeglRectangle) -- ^ Returns a 'FFI.GeglRectangle' if
                                   --   rectangles intersect, otherwise 'Nothing'
 gegl_rectangle_intersect a b = do