diff --git a/glazier-react.cabal b/glazier-react.cabal
--- a/glazier-react.cabal
+++ b/glazier-react.cabal
@@ -1,5 +1,5 @@
 name:                glazier-react
-version:             0.3.0.2
+version:             0.4.0.0
 synopsis:            ReactJS binding using Glazier and Pipes.Fluid
 description:         ReactJS binding using Glazier and Pipes.Fluid, which is
                      more functional and composable than Elm/Flux.
@@ -32,11 +32,11 @@
   build-depends:       base >= 4.7 && < 5
                      , containers >= 0.5 && < 0.6
                      , deepseq >= 1.4 && < 1.5
-                     , disposable >= 0.2.0.2 && < 1
+                     , disposable >= 0.2.0.3 && < 1
                      , dlist >= 0.8 && < 0.9
                      , free >= 4.12 && < 5
                      , glazier >= 0.10 && < 1
-                     , javascript-extras >= 0.2 && < 1
+                     , javascript-extras >= 0.2.0.2 && < 1
                      , lens >= 4 && < 5
                      , mmorph >= 1 && < 2
                      , mtl >= 2 && < 3
diff --git a/src/Glazier/React/Command.hs b/src/Glazier/React/Command.hs
--- a/src/Glazier/React/Command.hs
+++ b/src/Glazier/React/Command.hs
@@ -20,7 +20,7 @@
            -> (sm -> [JE.Property] -> J.JSVal -> cmd)
            -> m cmd
 basicRenderCmd frameNum componentRef fcmd = do
-    frameNum %= (\i -> (i `mod` maxBound) + 1)
+    frameNum %= (\i -> (i `mod` JE.maxSafeInteger) + 1)
     i <- JE.toJS <$> use frameNum
     r <- use componentRef
     sm <- get
diff --git a/src/Glazier/React/Maker.hs b/src/Glazier/React/Maker.hs
--- a/src/Glazier/React/Maker.hs
+++ b/src/Glazier/React/Maker.hs
@@ -41,6 +41,9 @@
     GetComponent
         :: (R.ReactComponent -> nxt)
         -> Maker act nxt
+    MkKey
+        :: (J.JSString -> nxt)
+        -> Maker act nxt
 
 instance Functor (Maker act) where
   fmap f (MkHandler handler g) = MkHandler handler (f . g)
@@ -48,6 +51,7 @@
   fmap f (MkRenderer ms render g) = MkRenderer ms render (f . g)
   fmap f (PutFrame frm dsn x) = PutFrame frm dsn (f x)
   fmap f (GetComponent g) = GetComponent (f . g)
+  fmap f (MkKey g) = MkKey (f . g)
 
 makeFree ''Maker
 
@@ -58,3 +62,4 @@
 mapAction _ (MkRenderer ms render g) = MkRenderer ms render g
 mapAction _ (PutFrame frm dsn x) = PutFrame frm dsn x
 mapAction _ (GetComponent g) = GetComponent g
+mapAction _ (MkKey g) = MkKey g
diff --git a/src/Glazier/React/Maker/Run.hs b/src/Glazier/React/Maker/Run.hs
--- a/src/Glazier/React/Maker/Run.hs
+++ b/src/Glazier/React/Maker/Run.hs
@@ -6,6 +6,7 @@
 import Control.Monad.Morph
 import Control.Monad.Trans.Maybe
 import Data.Foldable
+import qualified Data.JSString as JS
 import qualified GHCJS.Foreign.Callback as J
 import qualified GHCJS.Types as J
 import qualified Glazier as G
@@ -32,15 +33,22 @@
             acts <- handler evt
             traverse_ (\act -> lift $ atomically $ PC.send output act >>= guard) acts
 
-run :: R.ReactComponent -> PC.Output act -> R.Maker act (IO a) -> IO a
-run _ output (R.MkHandler handler g) = mkActionCallback output handler >>= g
+run :: MVar Int -> R.ReactComponent -> PC.Output act -> R.Maker act (IO a) -> IO a
+run _ _ output (R.MkHandler handler g) = mkActionCallback output handler >>= g
 
-run _ _ (R.MkEmptyFrame g) = newEmptyMVar >>= g
+run _ _ _ (R.MkEmptyFrame g) = newEmptyMVar >>= g
 
-run _ _ (R.MkRenderer ms render g) = J.syncCallback1' (onRender ms render') >>= g
+run _ _ _ (R.MkRenderer ms render g) = J.syncCallback1' (onRender ms render') >>= g
   where
     render' v = hoist (hoist generalize) (render v)
 
-run _ _ (R.PutFrame frm dsn g) = putMVar frm dsn >> g
+run _ _ _ (R.PutFrame frm dsn g) = putMVar frm dsn >> g
 
-run component _ (R.GetComponent g) = g component
+run _ component _ (R.GetComponent g) = g component
+
+run muid _ _ (R.MkKey g) = do
+    -- expects that muid is not empty!
+    uid <- readMVar muid
+    let uid' = (uid `mod` JE.maxSafeInteger) + 1
+    void $ swapMVar muid uid'
+    g (JS.pack . show $ uid')
diff --git a/src/Glazier/React/Model.hs b/src/Glazier/React/Model.hs
--- a/src/Glazier/React/Model.hs
+++ b/src/Glazier/React/Model.hs
@@ -59,7 +59,8 @@
     , _frame :: Frame mdl pln
     } deriving (G.Generic)
 
--- Undecidableinstances!
+-- | Undecidableinstances!
+-- But this is safe because Design is definitely smaller than SuperModel
 instance CD.Disposing (Design mdl pln) => CD.Disposing (SuperModel mdl pln) where
     disposing s = CD.disposing $ s ^. design
 
diff --git a/src/Glazier/React/Widget.hs b/src/Glazier/React/Widget.hs
--- a/src/Glazier/React/Widget.hs
+++ b/src/Glazier/React/Widget.hs
@@ -1,6 +1,5 @@
-{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FunctionalDependencies #-}
+{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -16,42 +15,68 @@
 import qualified Glazier.React.Markup as R
 import qualified Glazier.React.Model as R
 
-class (CD.Disposing (ModelOf w)
-      , CD.Disposing (PlanOf w)) => IsWidget w where
-    -- | The pure model for state and rendering
-    type CommandOf w :: *
-    type ActionOf w :: *
-    type ModelOf w :: *
-    type PlanOf w :: *
-    mkPlan :: w -> R.Frame (ModelOf w) (PlanOf w) -> F (R.Maker (ActionOf w)) (PlanOf w)
-    window :: w -> G.WindowT (R.Design (ModelOf w) (PlanOf w)) (R.ReactMlT Identity) ()
-    gadget :: w -> G.GadgetT (ActionOf w) (R.SuperModel (ModelOf w) (PlanOf w)) Identity (D.DList (CommandOf w))
+type family CommandOf w where
+    CommandOf (Widget c a m p) = c
 
+type family ActionOf w where
+    ActionOf (Widget c a m p) = a
+
+type family ModelOf w where
+    ModelOf (Widget c a m p) = m
+
+type family PlanOf w where
+    PlanOf (Widget c a m p) = p
+
+-- | Undecidable instances! But this is safe because 'ModelOf w' and 'PlanOf w'
+-- is guaranteed to be smaller than closed type family 'DesignOf w'.
 type family DesignOf w where
     DesignOf w = R.Design (ModelOf w) (PlanOf w)
 
+-- | Undecidable instances! But this is safe because 'ModelOf w' and 'PlanOf w'
+-- is guaranteed to be smaller than closed type family 'FrameOf w'.
 type family FrameOf w where
     FrameOf w = R.Frame (ModelOf w) (PlanOf w)
 
+-- | Undecidable instances! But this is safe because 'ModelOf w' and 'PlanOf w'
+-- is guaranteed to be smaller than closed type family 'SuperModelOf w'.
 type family SuperModelOf w where
     SuperModelOf w = R.SuperModel (ModelOf w) (PlanOf w)
 
--- | Contains everything you need to make the model,
+-- | Record of functions for a widget. Contains everything you need to make the model,
 -- render, and run the event processing.
 data Widget c a m p = Widget
     (R.Frame m p -> F (R.Maker a) p)
     (G.WindowT (R.Design m p) (R.ReactMlT Identity) ())
     (G.GadgetT a (R.SuperModel m p) Identity (D.DList c))
 
-instance (CD.Disposing m, CD.Disposing p) =>
-         IsWidget (Widget c a m p) where
-    type CommandOf (Widget c a m p) = c
-    type ActionOf (Widget c a m p) = a
-    type ModelOf (Widget c a m p) = m
-    type PlanOf (Widget c a m p) = p
+-- | This typeclass is convenient as it carries the 'Disposing Model' and 'Disposing Plan' constraints
+-- and allows treating 'Widget c a m p' as a type 'w'
+class (CD.Disposing (ModelOf w)
+      , CD.Disposing (PlanOf w)) => IsWidget w where
+    mkPlan :: w -> R.Frame (ModelOf w) (PlanOf w) -> F (R.Maker (ActionOf w)) (PlanOf w)
+    window :: w -> G.WindowT (R.Design (ModelOf w) (PlanOf w)) (R.ReactMlT Identity) ()
+    gadget :: w -> G.GadgetT (ActionOf w) (R.SuperModel (ModelOf w) (PlanOf w)) Identity (D.DList (CommandOf w))
+
+instance (CD.Disposing m, CD.Disposing p) => IsWidget (Widget c a m p) where
     mkPlan (Widget f _ _) = f
     window (Widget _ f _) = f
     gadget (Widget _ _ f) = f
+
+-- data Widget c a m p where
+--     Widget :: (CD.Disposing m, CD.Disposing p) =>
+--         (R.Frame m p -> F (R.Maker a) p)
+--         -> G.WindowT (R.Design m p) (R.ReactMlT Identity) ()
+--         -> G.GadgetT a (R.SuperModel m p) Identity (D.DList c)
+--         -> Widget c a m p
+
+-- mkPlan :: Widget c a m p -> R.Frame m p -> F (R.Maker a) p
+-- mkPlan (Widget f _ _) = f
+
+-- window :: Widget c a m p -> G.WindowT (R.Design m p) (R.ReactMlT Identity) ()
+-- window (Widget _ f _) = f
+
+-- gadget :: Widget c a m p -> G.GadgetT a (R.SuperModel m p) Identity (D.DList c)
+-- gadget (Widget _ _ f) = f
 
 mkSuperModel :: IsWidget w => w -> ModelOf w -> F (R.Maker (ActionOf w)) (R.SuperModel (ModelOf w) (PlanOf w))
 mkSuperModel w mdl = do