diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
--- /dev/null
+++ b/CHANGELOG
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright 2012 Russell O'Connor
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the author nor the names of his contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/Setup.lhs b/Setup.lhs
new file mode 100644
--- /dev/null
+++ b/Setup.lhs
@@ -0,0 +1,4 @@
+#! /usr/bin/env runhaskell
+ 
+> import Distribution.Simple
+> main = defaultMain
diff --git a/lens-family.cabal b/lens-family.cabal
new file mode 100644
--- /dev/null
+++ b/lens-family.cabal
@@ -0,0 +1,49 @@
+name:               lens-family
+category:           Data
+version:            0.0.0
+license:            BSD3
+cabal-version:      >= 1.6
+license-file:       LICENSE
+author:             Russell O'Connor
+maintainer:         Russell O'Connor <roconnor@theorem.ca>
+stability:          expermimental
+copyright:          Copyright (C) 2012 Russell O'Connor
+synopsis:           Lens Families
+description:        Lens Families
+build-type:         Simple
+extra-source-files: CHANGELOG
+description:        This package provide optimal first class functional references
+                    In addition to the usual operations of getting, setting and composition, plus integration with monad state, lens families provide some unique features:
+                    .
+                    * Polymorphic updating
+                    .
+                    * Cast projection functions to read-only lenses
+                    .
+                    * Cast semantic editor combinators to modify-only lenses
+
+source-repository head
+  type:     darcs
+  location: http://r6.ca/lens-family
+  
+library
+  extensions:       Rank2Types
+  build-depends:
+    base                 >= 4       && < 5,
+    containers           >= 0.3     && < 0.5,
+    transformers         >= 0.2.0   && < 0.4,
+    mtl                  >= 2.0.1   && < 2.2,
+    lens-family-core     >= 0.0.0   && < 0.1
+
+  exposed-modules:
+    Lens.Family2.Unchecked
+    Lens.Family2
+    Lens.Family2.Stock
+    Lens.Family2.State.Lazy
+    Lens.Family2.State.Strict
+    Lens.Family2.State
+
+  ghc-options:      -Wall
+
+  hs-source-dirs:
+                    src
+
diff --git a/src/Lens/Family2.hs b/src/Lens/Family2.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2.hs
@@ -0,0 +1,5 @@
+module Lens.Family2
+  ( module Lens.Family
+  ) where
+
+import Lens.Family
diff --git a/src/Lens/Family2/State.hs b/src/Lens/Family2/State.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2/State.hs
@@ -0,0 +1,5 @@
+module Lens.Family2.State
+  ( module Lens.Family2.State.Lazy
+  ) where
+
+import Lens.Family2.State.Lazy
diff --git a/src/Lens/Family2/State/Lazy.hs b/src/Lens/Family2/State/Lazy.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2/State/Lazy.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE Rank2Types #-}
+-- | Lenses allow you to use fields of the state of a state monad as if they were variables in an imperative language.
+-- 'access' is used to retrieve the value of a variable, and '~=' and '%=' allow you to set and modify a variable.
+-- C-style compound assignments are also provided.
+module Lens.Family2.State.Lazy
+  ( focus
+  , access
+  , (%=)
+  , (~=)
+  , (%%=)
+  -- * Compound Assignments
+  , (+=), (-=), (*=)
+  , (//=)
+  , (&&=), (||=)
+  ) where
+
+import Control.Monad (liftM)
+import Control.Monad.State.Lazy (MonadState, StateT(..), get, modify, state)
+import Lens.Family (Getter, Setter, (^.), (^%=))
+import qualified Lens.Family.State.Lazy as LFS
+import Lens.Family2.Stock (Lens)
+
+-- | Lift a stateful operation on a field to a stateful operation on the whole state.
+-- This is a good way to call a \"subroutine\" that only needs access to part of the state.
+focus :: Monad m => Lens a b -> StateT b m c -> StateT a m c
+focus l = LFS.focus l
+
+-- | Retrieve a field of the state
+access :: MonadState a m => Getter a b -> m b
+access l = (^. l) `liftM` get
+
+infix 4 %=
+
+-- | Modify a field of the state
+(%=) :: MonadState a m => Setter a b -> (b -> b) -> m ()
+l %= f = modify (l ^%= f)
+
+infix 4 ~=
+
+-- | Set a field of the state
+(~=) :: MonadState a m => Setter a b -> b -> m ()
+l ~= v = l %= const v
+
+infix 4 %%=
+
+-- | Modify a field of the state while returning another value
+(%%=) :: MonadState a m => Lens a b -> (b -> (c, b)) -> m c
+l %%= f = state (l f)
+
+infixr 4 +=, -=, *=
+
+(+=), (-=), (*=) :: (MonadState a m, Num b) => Setter a b -> b -> m ()
+f += b = f %= (+ b)
+f -= b = f %= subtract b
+f *= b = f %= (* b)
+
+infixr 4 //=
+
+(//=) :: (MonadState a m, Fractional b) => Setter a b -> b -> m ()
+f //= b = f %= (/ b)
+
+infixr 4 &&=, ||=
+
+(&&=), (||=) :: MonadState a m => Setter a Bool -> Bool -> m ()
+f &&= b = f %= (&& b)
+f ||= b = f %= (|| b)
diff --git a/src/Lens/Family2/State/Strict.hs b/src/Lens/Family2/State/Strict.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2/State/Strict.hs
@@ -0,0 +1,66 @@
+{-# LANGUAGE Rank2Types #-}
+-- | Lenses allow you to use fields of the state of a state monad as if they were variables in an imperative language.
+-- 'access' is used to retrieve the value of a variable, and '~=' and '%=' allow you to set and modify a variable.
+-- C-style compound assignments are also provided.
+module Lens.Family2.State.Strict
+  ( focus
+  , access
+  , (%=)
+  , (~=)
+  , (%%=)
+  -- * Compound Assignments
+  , (+=), (-=), (*=)
+  , (//=)
+  , (&&=), (||=)
+  ) where
+
+import Control.Monad (liftM)
+import Control.Monad.State.Strict (MonadState, StateT(..), get, modify, state)
+import Lens.Family (Getter, Setter, (^.), (^%=))
+import qualified Lens.Family.State.Strict as LFS
+import Lens.Family2.Stock (Lens)
+
+-- | Lift a stateful operation on a field to a stateful operation on the whole state.
+-- This is a good way to call a \"subroutine\" that only needs access to part of the state.
+focus :: Monad m => Lens a b -> StateT b m c -> StateT a m c
+focus l = LFS.focus l
+
+-- | Retrieve a field of the state
+access :: MonadState a m => Getter a b -> m b
+access l = (^. l) `liftM` get
+
+infix 4 %=
+
+-- | Modify a field of the state
+(%=) :: MonadState a m => Setter a b -> (b -> b) -> m ()
+l %= f = modify (l ^%= f)
+
+infix 4 ~=
+
+-- | Set a field of the state
+(~=) :: MonadState a m => Setter a b -> b -> m ()
+l ~= v = l %= const v
+
+infix 4 %%=
+
+-- | Modify a field of the state while returning another value
+(%%=) :: MonadState a m => Lens a b -> (b -> (c, b)) -> m c
+l %%= f = state (l f)
+
+infixr 4 +=, -=, *=
+
+(+=), (-=), (*=) :: (MonadState a m, Num b) => Setter a b -> b -> m ()
+f += b = f %= (+ b)
+f -= b = f %= subtract b
+f *= b = f %= (* b)
+
+infixr 4 //=
+
+(//=) :: (MonadState a m, Fractional b) => Setter a b -> b -> m ()
+f //= b = f %= (/ b)
+
+infixr 4 &&=, ||=
+
+(&&=), (||=) :: MonadState a m => Setter a Bool -> Bool -> m ()
+f &&= b = f %= (&& b)
+f ||= b = f %= (|| b)
diff --git a/src/Lens/Family2/Stock.hs b/src/Lens/Family2/Stock.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2/Stock.hs
@@ -0,0 +1,56 @@
+{-# LANGUAGE Rank2Types #-}
+-- | This module contains lenses for common structures in Haskell.
+-- It also contains the lens combinators 'mergeL' and '***'.
+module Lens.Family2.Stock
+  ( -- * Lens Combinators
+    Stock.mergeL
+  , (***)
+  -- * Stock Lenses
+  , fstL, sndL
+  , funL
+  , mapL, intMapL
+  , setL, intSetL
+  -- * Types
+  , LensFamily, Lens
+  ) where
+
+import Lens.Family2.Unchecked (LensFamily, Lens, mkLens)
+import qualified Lens.Family.Stock as Stock
+import Lens.Family ((^.), (^=))
+import qualified Data.Map as Map
+import qualified Data.IntMap as IntMap
+import qualified Data.Set as Set
+import qualified Data.IntSet as IntSet
+
+-- I suspect there is a more clever way to define this function.
+-- | Given two lens families, make a new lens on their product.
+(***) :: LensFamily a1 a1' b1 b1' -> LensFamily a2 a2' b2 b2' -> LensFamily (a1, a2) (a1', a2') (b1, b2) (b1', b2')
+(***) l1 l2 f (a1, a2) = (\(v'1, v'2) -> (l1 ^= v'1 $ a1, l2 ^= v'2 $ a2)) `fmap` f (a1 ^. l1, a2 ^. l2)
+
+-- | Lens on the first element of a pair.
+fstL :: LensFamily (a, b) (a', b) a a'
+fstL = Stock.fstL
+
+-- | Lens on the second element of a pair.
+sndL :: LensFamily (a, b) (a, b') b b'
+sndL = Stock.sndL
+
+-- | Lens on a given point of a function.
+funL :: (Eq k) => k -> Lens (k -> v) v
+funL = Stock.funL
+
+-- | Lens on a given point of a 'Map.Map'.
+mapL :: (Ord k) => k -> Lens (Map.Map k v) (Maybe v)
+mapL = Stock.mapL
+
+-- | Lens on a given point of a 'IntMap.IntMap'.
+intMapL :: Int -> Lens (IntMap.IntMap v) (Maybe v)
+intMapL = Stock.intMapL
+
+-- | Lens on a given point of a 'Set.Set'.
+setL :: (Ord k) => k -> Lens (Set.Set k) Bool
+setL = Stock.setL
+
+-- | Lens on a given point of a 'IntSet.IntSet'.
+intSetL :: Int -> Lens IntSet.IntSet Bool
+intSetL = Stock.intSetL
diff --git a/src/Lens/Family2/Unchecked.hs b/src/Lens/Family2/Unchecked.hs
new file mode 100644
--- /dev/null
+++ b/src/Lens/Family2/Unchecked.hs
@@ -0,0 +1,72 @@
+{-# LANGUAGE Rank2Types #-}
+-- | /Caution/: Improper use of this module can lead to unexpected behaviour if the preconditions of the functions are not met.
+-- 
+-- A lens family is created by separating a substructure from the rest of its structure by a functor.
+-- How to create a lens family is best illustrated by the common example of a field of a record:
+--
+-- > data MyRecord a = MyRecord { _myA :: a, _myB :: Int }
+-- >
+-- > -- The use of type variables a and a' allow for polymorphic updates.
+-- > myA :: LensFamily (MyRecord a) (MyRecord a') a a'
+-- > myA f (MyRecord a b) = (\a' -> MyRecord a' b) `fmap` (f a)
+-- >
+-- > -- The field _myB is monomorphic, so we can use a plain Lens type.
+-- > -- However, the structure of the function is exactly the same as for LensFamily.
+-- > myB :: Lens (MyRecord a) Int
+-- > myB f (MyRecord a b) = (\b' -> MyRecord a b') `fmap` (f b)
+--
+-- By following this template you can safely build your own lenses.
+-- To use this template, you do not need anything from this module other than the type synonyms 'LensFamily' and 'Lens', and even they are optional.
+-- See the @lens-family-th@ package to generate this code using Template Haskell.
+--
+-- You can build lenses for more than just fields of records.
+-- Any value @lens :: LensFamily a a' b b'@ is well-defined when it satisfies the two van Laarhoven lens laws:
+--
+-- * @lens Identity === Identity@
+--
+-- * @
+-- lens (composeCoalgebroid f g) === composeCoalgebroid (lens f) (lens g)
+--  where
+--   composeCoalgebroid :: (Functor f, Functor g) => (b -> f c) -> (a -> g b) -> a -> (Compose g f) c
+--   composeCoalgebroid f g a = Compose $ f \`fmap\` g a === id
+-- @
+--
+-- The functions 'mkLens' and 'mkIsoLens' can also be used to construct lenses.
+-- The resulting lenses will be well-defined so long as their preconditions are satisfied.
+module Lens.Family2.Unchecked
+  ( mkLens
+  , mkIsoLens
+  -- * Types
+  , LensFamily, Lens
+  ) where
+
+import qualified Lens.Family.Unchecked as LF
+
+type LensFamily a a' b b' = forall f. Functor f => LF.LensFamily f a a' b b'
+type Lens a b = LensFamily a a b b
+
+-- | Build a lens from a @getter@ and @setter@ families.
+--
+-- /Caution/: In order for the generated lens family to be well-defined, you must ensure that the three lens laws hold:
+-- 
+-- * @getter (setter a b) === b@
+--
+-- * @setter a (getter a) === a@
+--
+-- * @setter (setter a b1) b2) === setter a b2@
+mkLens :: (a -> b) -- ^ getter
+       -> (a -> b' -> a') -- ^ setter
+       -> LensFamily a a' b b'
+mkLens = LF.mkLens
+
+-- | Build a lens from isomorphism families.
+--
+-- /Caution/: In order for the generated lens family to be well-defined, you must ensure that the two isomorphism laws hold:
+-- 
+-- * @yin . yang === id@
+--
+-- * @yang . yin === id@
+mkIsoLens :: (a -> b) -- ^ yin
+          -> (b' -> a') -- ^ yang
+          -> LensFamily a a' b b'
+mkIsoLens = LF.mkIsoLens