diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,5 +1,13 @@
 [![Hackage](https://img.shields.io/hackage/v/disposable.svg)](https://hackage.haskell.org/package/disposable)
 [![Build Status](https://secure.travis-ci.org/louispan/disposable.png?branch=master)](http://travis-ci.org/louispan/disposable)
 
-SomeDisposable aloows storing different resource releasing actions togther in a container.
+Disposable allows storing different resource releasing actions togther in a container.
 This library is useful for queueing up GHCJS.Foreign.Callback together to be released after a new rendering frame.
+
+# Changelog
+
+* 1.0.0.0
+  - Breaking changes:
+    - Simplified by removing SomeDisposable GADT; Disposable is now a newtype, and the typeclass is called Dispose.
+    - The intention is no longer to create Disposable instances for everything.
+    - Disposable is only used to provide a safe wrapper around IO to ensure that it performs no other side effects.
diff --git a/disposable.cabal b/disposable.cabal
--- a/disposable.cabal
+++ b/disposable.cabal
@@ -1,7 +1,7 @@
 name:                disposable
-version:             0.2.0.4
+version:             1.0.0.0
 synopsis:            Allows storing different resource-releasing actions together.
-description:         SomeDisposable allows storing different resource releasing actions togther in a container.
+description:         Disposable allows storing different resource releasing actions togther in a container.
                      This library is useful for queueing up GHCJS.Foreign.Callback together to be released
                      after a new rendering frame.
 homepage:            https://github.com/louispan/disposable#readme
@@ -20,12 +20,12 @@
   hs-source-dirs:      src
   exposed-modules:     Control.Disposable
   build-depends:       base >= 4.7 && < 5
-                     , dlist >= 0.8 && < 0.9
+                     , stm >= 2.4.4.1
   default-language:    Haskell2010
   if impl(ghcjs)
       build-depends: ghcjs-base
   if !impl(ghcjs)
-      build-depends: ghcjs-base-stub >= 0.1.0.2 && < 1
+      build-depends: ghcjs-base-stub >= 0.1.0.2
 
 source-repository head
   type:     git
diff --git a/src/Control/Disposable.hs b/src/Control/Disposable.hs
--- a/src/Control/Disposable.hs
+++ b/src/Control/Disposable.hs
@@ -1,94 +1,51 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE RankNTypes #-}
-{-# LANGUAGE TypeOperators #-}
-
-module Control.Disposable where
+module Control.Disposable
+    ( Disposable -- constructor not exported
+    , runDisposable
+    , Dispose(..)
+    ) where
 
-import qualified Data.DList as D
-import Data.Foldable
+import Control.Concurrent
+import Control.Concurrent.STM
+import Control.Monad
+import Data.IORef
 import Data.Semigroup
-import qualified GHC.Generics as G
 import qualified GHCJS.Foreign.Callback as J
-import qualified GHCJS.Types as J
-
--- | A 'Disposable' is something with some resources to release
-class Disposable a where
-    dispose :: a -> IO ()
-
-instance Disposable (J.Callback a) where
-    dispose = J.releaseCallback
-
--- | Allows storing 'Disposable's in a heterogenous container
-data SomeDisposable where
-    DisposeNone :: SomeDisposable
-    Dispose :: forall a. Disposable a => a -> SomeDisposable
-    DisposeList :: forall a. Disposable a => [a] -> SomeDisposable
-
-instance Disposable SomeDisposable where
-    dispose DisposeNone = pure ()
-    dispose (Dispose a) = dispose a
-    dispose (DisposeList as) = traverse_ dispose as
-
--- | Allow generic deriving instances of things that can be made into 'SomeDisposable'
--- If a data type derives from Generic, and only contain instances of Disposing,
--- then it can also be made an instance of 'Disposing'.
--- Eg.
--- @
--- import Glazier.React as R
--- import GHCJS.Foreign.Callback as J
--- import GHC.Generics as G
---
--- data Plan = Plan
---     { _component :: R.ReactComponent
---     , _onRender :: J.Callback (J.JSVal -> IO J.JSVal)
---     ...
---     } deriving G.Generic
--- instance Disposing Plan
--- @
-class Disposing a where
-  disposing :: a -> SomeDisposable
-  default disposing :: (G.Generic a, GDisposing (G.Rep a)) => a -> SomeDisposable
-  disposing x = DisposeList . D.toList . gDisposing $ G.from x
-
-instance Disposing SomeDisposable where
-    disposing = id
+import qualified GHCJS.Foreign.Export as J
 
-instance Disposing (J.Callback a) where
-    disposing = Dispose
+-- | A wrapper around authorized IO actions.
+newtype Disposable = Disposable { runDisposable :: IO () }
 
-instance Disposing Int where
-    disposing _ = DisposeNone
+instance Semigroup Disposable where
+    (Disposable f) <> (Disposable g) = Disposable (f >> g)
 
-instance Disposing J.JSString where
-    disposing _ = DisposeNone
+instance Monoid Disposable where
+    mempty = Disposable (pure ())
+    mappend = (<>)
 
-instance Disposing J.JSVal where
-    disposing _ = DisposeNone
+-- | A 'Dispose' is something with some resources to release
+class Dispose a where
+    dispose :: a -> Disposable
 
-instance Disposing a => Disposing (D.DList a) where
-    disposing xs = DisposeList $ disposing <$> D.toList xs
+instance Dispose Disposable where
+    dispose = id
 
--- | Generic instance basically traverses the data type structure
--- and expects the values to be all instances of 'Disposing'
-class GDisposing f where
-    gDisposing :: f p -> D.DList SomeDisposable
+instance Dispose (J.Callback a) where
+    dispose = Disposable . J.releaseCallback
 
-instance GDisposing G.U1 where
-  gDisposing G.U1 = mempty
+instance Dispose (J.Export a) where
+    dispose = Disposable . J.releaseExport
 
-instance (GDisposing f, GDisposing g) => GDisposing (f G.:+: g) where
-  gDisposing (G.L1 x) = gDisposing x
-  gDisposing (G.R1 x) = gDisposing x
+instance Dispose a => Dispose (TVar a) where
+    dispose a = Disposable . join $ (runDisposable . dispose) <$> atomically (readTVar a)
 
-instance (GDisposing f, GDisposing g) => GDisposing (f G.:*: g) where
-  gDisposing (x G.:*: y) = (gDisposing x) <> (gDisposing y)
+instance Dispose a => Dispose (TMVar a) where
+    dispose a = Disposable . join $
+        (runDisposable . dispose) <$> atomically (readTMVar a)
 
-instance (Disposing c) => GDisposing (G.K1 i c) where
-  gDisposing (G.K1 x) = D.singleton $ disposing x
+instance Dispose a => Dispose (IORef a) where
+    dispose a = Disposable . join $
+        (runDisposable . dispose) <$> readIORef a
 
-instance (GDisposing f) => GDisposing (G.M1 i t f) where
-  gDisposing (G.M1 x) = gDisposing x
+instance Dispose a => Dispose (MVar a) where
+    dispose a = Disposable . join $
+        (runDisposable . dispose) <$> readMVar a