diff --git a/gooey.cabal b/gooey.cabal
--- a/gooey.cabal
+++ b/gooey.cabal
@@ -10,7 +10,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             0.0.0.0
+version:             0.1.0.0
 
 -- A short (one-line) description of the package.
 synopsis:            Graphical user interfaces that are renderable,
@@ -63,9 +63,8 @@
   -- Other library packages from which modules are imported.
   build-depends:       base >=4.8 && <4.9,
                        varying >= 0.1.4 && < 0.2,
-                       renderable >= 0.0.0.2,
-                       transformers >= 0.4 && < 0.5,
-                       hashable >= 1.2 && < 1.3
+                       renderable >= 0.1.0.0,
+                       transformers >= 0.4 && < 0.5
 
   -- Directories containing source files.
   hs-source-dirs:      src
diff --git a/src/Control/GUI.hs b/src/Control/GUI.hs
--- a/src/Control/GUI.hs
+++ b/src/Control/GUI.hs
@@ -13,6 +13,8 @@
 
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 module Control.GUI (
     -- * Definition
     UX(..),
@@ -30,8 +32,8 @@
 
 import Control.Varying
 import Control.Monad.IO.Class
+import Control.Arrow (first)
 import Data.Renderable
-import Data.Hashable
 import Data.Monoid
 
 --------------------------------------------------------------------------------
@@ -46,7 +48,7 @@
 
 -- | A UX is a functor by applying a function to the contained event's value.
 instance Functor (UX a) where
-    fmap f (UX a b) = UX a $ (fmap f b)
+    fmap f (UX a b) = UX a $ fmap f b
 
 -- | A UX is an applicative if its left datatype is a monoid. It replies to
 -- 'pure' with an empty left value while the right value is the argument
@@ -59,12 +61,7 @@
 -- | A UX is renderable if its left value is also renderable. It inherits all
 -- Renderable type variables from its left value and simply renders that
 -- value.
-instance Renderable a => Renderable (UX a b) where
-    type RenderMonad (UX a b) = RenderMonad a
-    type RenderRsrc (UX a b) = RenderRsrc a
-    type RenderTfrm (UX a b) = RenderTfrm a
-    nameOf (UX ui _) = nameOf ui
-    cache rz rs (UX ui _) = cache rz rs ui
+instance Composite a m r t => Composite (UX a b) m r t where
     composite (UX ui _) = composite ui
 
 -- | A GUI is a UX that varies over some domain. What this means is that a
@@ -122,7 +119,7 @@
 -- | Creates a new GUI displaying an interface that eventually produces a value.
 -- The type used to represent the user interface must have a 'Decomposable'
 -- instance, that way the resulting GUI\'s discrete values can be rendered.
-gui :: (Monad m, Decomposable a m r t)
+gui :: (Monad m, Composite a m r t)
     => Var m i a
     -- ^ The stream of a changing user interface.
     -> Var m i (Event b)
@@ -132,11 +129,11 @@
     -> (a -> b -> c)
     -- ^ The merging function that combines the interface's final value with the
     -- value produced by the event stream.
-    -> GUI m i [Element m r t] c
+    -> GUI m i [(t, Element m r t)] c
 gui v ve f = GUI $ Var $ \i -> do
     (a, v')  <- runVar v i
     (e, ve') <- runVar ve i
-    let ui = decompose a
+    let ui = composite a
     case e of
         NoEvent -> return (UX ui NoEvent, runGUI $ gui v' ve' f)
         Event b -> return (UX ui (Event $ f a b), pure $ UX [] $ Event $ f a b)
@@ -148,18 +145,19 @@
 -- same domain it\'s possible to tween GUIs.
 --------------------------------------------------------------------------------
 -- | Transforms a GUI.
-transformGUI :: (Monad m, Monad (RenderMonad t), Show t, Show (RenderTfrm t),
-                 Hashable t, Hashable (RenderTfrm t), Monoid (RenderTfrm t),
-                 Renderable t)
-             => Var m i (RenderTfrm t)
-             -- ^ The stream of a changing transformation.
-             -> GUI m i t b
-             -- ^ The GUI to transform.
-             -> GUI m i [Element (RenderMonad t) (RenderRsrc t) (RenderTfrm t)] b
+--transformGUI :: (Monad m, Monoid t, Composite a m r t)
+--             => Var m i t
+--             -- ^ The stream of a changing transformation.
+--             -> GUI m i a b
+--             -- ^ The GUI to transform.
+--             -> GUI m i a b
+transformGUI :: (Monad m, Monoid t)
+             => Var m i t -> GUI m i [(t, d)] b -> GUI m i [(t, d)] b
 transformGUI vt g = GUI $ Var $ \i -> do
     (UX ui e, v) <- runVar (runGUI g) i
     (t, vt') <- runVar vt i
-    return (UX [Element (t,ui)] e, runGUI $ transformGUI vt' $ GUI v)
+    let ui' = map (first (mappend t)) ui
+    return (UX ui' e, runGUI $ transformGUI vt' $ GUI v)
 --------------------------------------------------------------------------------
 -- $combination
 -- Combining two GUIs creates a new GUI.