diff --git a/Changelog.md b/Changelog.md
new file mode 100644
--- /dev/null
+++ b/Changelog.md
@@ -0,0 +1,3 @@
+## 0.1.0
+
+* Initial release
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2018, Composewell Technologies
+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 copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER 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/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,13 @@
+# compact-list
+
+[![Hackage](https://img.shields.io/hackage/v/compact-list.svg?style=flat)](https://hackage.haskell.org/package/compact-list)
+[![Build Status](https://travis-ci.org/composewell/compact-list.svg?branch=master)](https://travis-ci.org/composewell/compact-list)
+[![Windows Build status](https://ci.appveyor.com/api/projects/status/sndov45axamjt6bu?svg=true)](https://ci.appveyor.com/project/harendra-kumar/compact-list)
+
+If you hold on to a large data structure in garbage collected (GC) memory
+for relatively longer times it puts undue pressure on GC, unnecessarily
+increasing the work done by GC and also increasing the duration of GC
+pauses. A `CompactList` allows you to keep a large list in a Compact Region
+not touched by GC, thus avoiding any GC overhead.  This is essentially like
+a convenient in-memory append only file where you can write a list of
+Haskell values without having to marshall or serialize them.
diff --git a/compact-list.cabal b/compact-list.cabal
new file mode 100644
--- /dev/null
+++ b/compact-list.cabal
@@ -0,0 +1,51 @@
+name:               compact-list
+version:            0.1.0
+synopsis:           An append only list in a compact region
+description:
+ If you hold on to a large data structure in garbage collected (GC) memory
+ for relatively longer times it puts undue pressure on GC, unnecessarily
+ increasing the work done by GC and also increasing the duration of GC
+ pauses. A 'CompactList' allows you to keep a large list in a Compact Region
+ not touched by GC, thus avoiding any GC overhead.  This is essentially like
+ a convenient in-memory append only file where you can write a list of
+ Haskell values without having to marshall or serialize them.
+
+homepage:            https://github.com/composewell/compact-list
+bug-reports:         https://github.com/composewell/compact-list/issues
+license:             BSD3
+license-file:        LICENSE
+tested-with:         GHC==8.2.2, GHC==8.4.3
+author:              Harendra Kumar
+maintainer:          harendra.kumar@gmail.com
+copyright:           2018 Harendra Kumar
+category:            Data
+stability:           Experimental
+build-type:          Simple
+cabal-version:       >= 1.10
+
+extra-source-files:
+    Changelog.md
+    README.md
+    stack.yaml
+
+source-repository head
+    type: git
+    location: https://github.com/composewell/compact-list
+
+library
+    hs-source-dirs:    src
+    exposed-modules:   Data.CompactList
+    default-language: Haskell2010
+    ghc-options: -Wall
+    build-depends: base      >= 4.8   && < 5
+                 , ghc-prim  >= 0.2   && < 0.6
+
+test-suite test
+  type: exitcode-stdio-1.0
+  hs-source-dirs: test
+  main-is: Main.hs
+  build-depends:
+      compact-list
+    , base >= 4.8   && < 5
+  default-language: Haskell2010
+  ghc-options: -Wall -with-rtsopts "-s"
diff --git a/src/Data/CompactList.hs b/src/Data/CompactList.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/CompactList.hs
@@ -0,0 +1,75 @@
+-- |
+-- Module      : Data.CompactList
+-- Copyright   : (c) 2018 Composewell Technologies
+--               (c) 2001-14 GHC Project
+--
+-- License     : BSD3
+-- Maintainer  : harendra.kumar@gmail.com
+-- Stability   : experimental
+-- Portability : GHC
+--
+-- If you hold on to a large data structure in garbage collected (GC) memory
+-- for relatively longer times it puts undue pressure on GC, unnecessarily
+-- increasing the work done by GC and also increasing the duration of GC
+-- pauses. A 'CompactList' allows you to keep a large list in a Compact Region
+-- not touched by GC, thus avoiding any GC overhead.  This is essentially like
+-- a convenient in-memory append only file where you can write a list of
+-- Haskell values without having to marshall or serialize them.
+--
+-- A 'CompactList' is like a thread safe 'IORef' to a list in compact region.
+
+{-# LANGUAGE MagicHash #-}
+{-# LANGUAGE UnboxedTuples #-}
+
+module Data.CompactList
+    ( CompactList
+    , newCompactList
+    , consCompactList
+    , readCompactList
+    ) where
+
+import Control.Concurrent.MVar (MVar, newMVar, withMVar)
+import GHC.IO (stToIO)
+import GHC.Prim
+       (Compact#, compactAdd#, compactNew#, int2Word#, RealWorld, State#)
+import GHC.ST (ST(ST))
+import GHC.STRef (STRef, newSTRef, readSTRef, writeSTRef)
+import GHC.Types (Int(I#), IO(IO))
+
+-- | A list with values of type @a@ living in a compact (non-GC) region.
+data CompactList a = CompactList Compact# (STRef RealWorld [a]) (MVar ())
+
+mkCompactList
+  :: Compact# -> [a] -> State# RealWorld -> (# State# RealWorld, CompactList a #)
+mkCompactList compact# as s =
+  case unST (newSTRef as) s of { (# s0, ref #) ->
+      case unIO (newMVar ()) s0 of { (# s1, lock #) ->
+      (# s1, CompactList compact# ref lock #) } }
+ where
+  unST (ST a) = a
+  unIO (IO a) = a
+
+compactSized :: Int -> [a] -> IO (CompactList a)
+compactSized (I# size) a = IO $ \s0 ->
+  case compactNew# (int2Word# size) s0 of { (# s1, compact# #) ->
+  case compactAdd# compact# a s1 of { (# s2, pk #) ->
+  mkCompactList compact# pk s2 }}
+
+-- | Make a new compact list from a list.
+newCompactList :: [a] -> IO (CompactList a)
+newCompactList = compactSized 31268
+
+-- | Retrieve the compact list from the compact region.
+readCompactList :: CompactList a -> IO [a]
+readCompactList (CompactList _ ref _) = stToIO (readSTRef ref)
+
+-- | Add an element at the head of the compact list. The modification is thread
+-- safe.
+consCompactList :: CompactList a -> a -> IO ()
+consCompactList (CompactList compact# ref lock) x =
+    withMVar lock $ \_ -> IO $ \s ->
+        case unST (readSTRef ref) s of { (# s1, xs #) ->
+            case compactAdd# compact# (x : xs) s1 of { (# s2, ys #) ->
+              unST (writeSTRef ref ys) s2 }}
+     where
+      unST (ST a) = a
diff --git a/stack.yaml b/stack.yaml
new file mode 100644
--- /dev/null
+++ b/stack.yaml
@@ -0,0 +1,3 @@
+resolver: lts-12.5
+packages:
+- '.'
diff --git a/test/Main.hs b/test/Main.hs
new file mode 100644
--- /dev/null
+++ b/test/Main.hs
@@ -0,0 +1,10 @@
+import Data.CompactList
+import Control.Monad (replicateM, void)
+
+main :: IO ()
+main = do
+    ref <- newCompactList []
+    void $ replicateM 1000000 $ do
+        consCompactList ref ()
+        return ()
+    readCompactList ref >>= print . length