diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright Author name here (c) 2016
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * 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.
+
+    * Neither the name of Author name here nor the names of other
+      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
+OWNER 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.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/app/Main.hs b/app/Main.hs
new file mode 100644
--- /dev/null
+++ b/app/Main.hs
@@ -0,0 +1,6 @@
+module Main where
+
+import Pipes.Protolude
+
+main :: IO ()
+main = return ()
diff --git a/pipes-protolude.cabal b/pipes-protolude.cabal
new file mode 100644
--- /dev/null
+++ b/pipes-protolude.cabal
@@ -0,0 +1,67 @@
+name:                pipes-protolude
+version:             0.1.0.0
+synopsis:            Alternate Prelude for the pipes ecosystem
+description:         Please see README.md
+homepage:            https://github.com/mckeankylej/pipes-protolude#readme
+license:             BSD3
+license-file:        LICENSE
+author:              Kyle McKean
+maintainer:          mckean.kylej@gmail.com
+copyright:           2016 Kyle McKean
+category:            Pipes
+build-type:          Simple
+cabal-version:       >=1.10
+
+library
+  hs-source-dirs:      src
+  ghc-options:         -Wall
+  exposed-modules:     Pipes.Protolude
+                     , Pipes.Base
+                     , Pipes.Show
+                     , Pipes.Debug
+                     , Pipes.Data.Conversion
+                     , Pipes.Monad
+                     , Pipes.Transformers
+                     , Pipes.Temporary
+                     , Pipes.Ecosystem
+  build-depends:       base >= 4.7 && < 5
+                     , text-show >= 2.1.2 && < 3.0.1
+                     , deepseq >= 1.4
+                     , mtl >= 2.2
+                     , transformers >= 0.4
+                     , async
+                     , foldl >= 1.2.1
+                     , free >= 4.12
+                     , pipes >= 4.1.9
+                     , pipes-concurrency >= 2.0.6
+                     , pipes-extras >= 1.0.3
+                     , pipes-group >= 1.0.4
+                     , pipes-safe >= 2.2.4
+                     , exceptions >= 0.8.2.1
+                     , pipes-parse >= 3.0
+                     , pipes-text >= 0.0.2.3
+  default-language:    Haskell2010
+  default-extensions:  NoImplicitPrelude
+
+executable pipes-protolude-exe
+  hs-source-dirs:      app
+  main-is:             Main.hs
+  ghc-options:         -Wall -threaded -rtsopts -with-rtsopts=-N
+  build-depends:       base
+                     , pipes-protolude
+  default-language:    Haskell2010
+  default-extensions:  NoImplicitPrelude
+
+test-suite pipes-protolude-test
+  type:                exitcode-stdio-1.0
+  hs-source-dirs:      test
+  main-is:             Spec.hs
+  build-depends:       base
+                     , pipes-protolude
+  ghc-options:         -Wall -threaded -rtsopts -with-rtsopts=-N
+  default-language:    Haskell2010
+  default-extensions:  NoImplicitPrelude
+
+source-repository head
+  type:     git
+  location: https://github.com/mckeankylej/pipes-protolude
diff --git a/src/Pipes/Base.hs b/src/Pipes/Base.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Base.hs
@@ -0,0 +1,80 @@
+module Pipes.Base (
+  module X,
+  String,
+  FilePath
+  ) where
+
+-- Base Types --
+
+import Data.Int as X
+import Data.Bits as X
+import Data.Word as X
+import Data.Bool as X
+import Data.Char as X (Char,ord,chr)
+import Data.Maybe as X hiding (fromJust)
+import Data.Either as X
+import Data.Tuple as X
+
+import Data.Function as X (
+  const,
+  flip,
+  ($),
+  (&),
+  fix,
+  on)
+import Control.Category as X (
+  Category(..),
+  id,
+  (.))
+
+-- Type Classes --
+
+import Data.Eq as X
+import Data.Ord as X
+import Data.Monoid as X hiding (mconcat)
+import Data.Functor.Identity as X
+import Data.Functor as X (
+    Functor(..)
+  , ($>)
+  , void
+  )
+import Data.Bifunctor as X
+import Control.Applicative as X
+
+-- Deepseq --
+
+import Control.DeepSeq as X (
+    NFData(..)
+  , ($!!)
+  , deepseq
+  , force
+  )
+
+-- Base GHC types --
+
+import GHC.IO as X (IO)
+import GHC.Num as X
+import GHC.Real as X
+import GHC.Float as X
+import GHC.Show as X
+import GHC.Exts as X (
+    Constraint
+  , Ptr
+  , FunPtr
+  , the
+  )
+
+-- Generics
+import GHC.Generics as X (Generic(..))
+
+-- ST
+import Control.Monad.ST as X
+
+-- Concurrency and Parallelism
+-- import Control.Exception as X hiding (Handler)
+-- TODO: This doesnt opperate well with the pipes ecosystem does pipes-safe fill the need of this package?
+import Control.Concurrent as X hiding (yield)
+import Control.Concurrent.Async as X --TODO: Investigate if safe or nonsafe is needed
+
+type String = [Char] -- BANSHED UNLOVED HELL SPAWN
+type FilePath = String
diff --git a/src/Pipes/Data/Conversion.hs b/src/Pipes/Data/Conversion.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Data/Conversion.hs
@@ -0,0 +1,22 @@
+module Pipes.Data.Conversion where
+
+import Prelude (const)
+
+import Data.Maybe (Maybe(..),maybe)
+import Data.Either (Either(..),either)
+import Data.Monoid
+
+leftToMaybe :: Either l r -> Maybe l
+leftToMaybe = either Just (const Nothing)
+
+rightToMaybe :: Either l r -> Maybe r
+rightToMaybe = either (const Nothing) Just
+
+maybeToRight :: l -> Maybe r -> Either l r
+maybeToRight l = maybe (Left l) Right
+
+maybeToLeft :: r -> Maybe l -> Either l r
+maybeToLeft r = maybe (Right r) Left
+
+maybeToEither :: Monoid b => (a -> b) -> Maybe a -> b
+maybeToEither = maybe mempty
diff --git a/src/Pipes/Debug.hs b/src/Pipes/Debug.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Debug.hs
@@ -0,0 +1,38 @@
+module Pipes.Debug where
+
+import qualified Prelude as P
+
+import qualified Debug.Trace as T
+
+{-# WARNING undefined "'undefined' remains in code" #-}
+undefined :: a
+undefined = P.undefined
+
+{-# WARNING error "'error' remains in code" #-}
+error :: P.String -> a
+error = P.error
+
+{-# WARNING trace "'trace' remains in code" #-}
+trace :: P.String -> a -> a
+trace = T.trace
+
+{-# WARNING traceShow "'traceShow' remains in code" #-}
+traceShow :: P.Show a => a -> a
+traceShow a = T.trace (P.show a) a
+
+{-# WARNING traceShowM "'traceShowM' remains in code" #-}
+traceShowM :: (P.Show a, P.Monad m) => a -> m ()
+traceShowM a = T.traceM (P.show a)
+
+{-# WARNING traceM "'traceM' remains in code" #-}
+traceM :: P.Monad m => P.String -> m ()
+traceM = T.traceM
+
+{-# WARNING traceIO "'traceIO' remains in code" #-}
+traceIO :: P.String -> P.IO ()
+traceIO = T.traceIO
+
+{-# WARNING notImplemented "'notImplemented' remains in code" #-}
+notImplemented :: a
+notImplemented = P.error "Not implemented"
+
diff --git a/src/Pipes/Ecosystem.hs b/src/Pipes/Ecosystem.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Ecosystem.hs
@@ -0,0 +1,130 @@
+module Pipes.Ecosystem (
+  module X
+  ) where
+
+import Pipes as X
+import Pipes.Lift as X hiding (catchError)
+-- Import Pipes.Prelude banshing string based functions
+import Pipes.Prelude as X (
+  repeatM,
+  replicateM,
+  unfoldr,
+  drain,
+  map,
+  mapM,
+  sequence,
+  mapFoldable,
+  filter,
+  filterM,
+  take,
+  takeWhile,
+  takeWhile',
+  drop,
+  dropWhile,
+  concat,
+  chain,
+  seq,
+  loop,
+  zip,
+  zipWith,
+  tee
+                          )
+import Pipes.Concurrent as X hiding (
+  Unbounded,
+  Bounded,
+  Single,
+  Latest,
+  Newest,
+  New
+                                    )
+import Control.Foldl as X hiding (
+  fold,
+  foldM,
+  scan,
+  Handler, -- Not only does this conflict with execptions which are a needed
+          -- feature of a prelude I feel it doesnt have enough of a use case
+          -- to merit importing
+  handles,
+  HandlerM,
+  handlesM,
+  folded,
+  filtered
+                                 )
+
+import Pipes.Extras as X (
+  fold,
+  foldM,
+  scan,
+  scanM
+                         )
+
+import Pipes.Group as X
+
+import Control.Monad.Trans.Free as X
+
+import Pipes.Safe as X (
+  SafeT,
+  runSafeT,
+  runSafeP,
+  ReleaseKey,
+  MonadSafe(..),
+  onException,
+  finally,
+  bracket,
+  bracket_,
+  bracketOnError
+                       )
+import Control.Monad.Catch as X
+    ( MonadCatch(..)
+    , MonadThrow(..)
+    , MonadMask(..)
+    , mask_
+    , uninterruptibleMask_
+    , catchAll
+    , catchIOError
+    , catchJust
+    , catchIf
+    , Handler(..)
+    , catches
+    , handle
+    , handleAll
+    , handleIOError
+    , handleJust
+    , handleIf
+    , try
+    , tryJust
+    , Exception(..)
+    , SomeException
+    )
+
+import Pipes.Text as X hiding (
+  map,
+  concatMap,
+  take,
+  takeWhile,
+  filter,
+  scan,
+  toLazy, -- We dont like lazy text and bytestrings here in pipes world
+  toLazyM,
+  head,
+  last,
+  null,
+  length,
+  any,
+  all,
+  maximum,
+  minimum,
+  find,
+  index,
+  drop,
+  dropWhile,
+  groups,
+  groupsBy,
+  groupsBy',
+  chunksOf
+                              )
+import Pipes.Text.IO as X
+
+import Pipes.Text.Encoding as X
+
+import Pipes.Parse as X hiding (span,splitAt,groupBy,group)
diff --git a/src/Pipes/Monad.hs b/src/Pipes/Monad.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Monad.hs
@@ -0,0 +1,39 @@
+module Pipes.Monad (
+    Monad(..)
+  , MonadPlus(..)
+
+  , (=<<)
+  , (>=>)
+  , (<=<)
+  , forever
+
+  , join
+  , mfilter
+
+  , guard
+  , when
+  , unless
+
+  , liftM'
+  , liftM2'
+
+  , ap
+  , (<$!>)
+  ) where
+
+import Prelude (seq)
+-- import Pipes.Base (seq)
+
+import Control.Monad
+
+liftM' :: Monad m => (a -> b) -> m a -> m b
+liftM' = (<$!>)
+{-# INLINE liftM' #-}
+
+liftM2' :: (Monad m) => (a -> b -> c) -> m a -> m b -> m c
+liftM2' f a b = do
+  x <- a
+  y <- b
+  let z = f x y
+  z `seq` return z
+{-# INLINE liftM2' #-}
diff --git a/src/Pipes/Protolude.hs b/src/Pipes/Protolude.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Protolude.hs
@@ -0,0 +1,19 @@
+module Pipes.Protolude (
+  module X
+  ) where
+
+import Pipes.Ecosystem as X -- Where the magic happens
+
+import Pipes.Base as X
+
+import Pipes.Show as X
+
+import Pipes.Debug as X
+
+import Pipes.Data.Conversion as X
+
+import Pipes.Monad as X
+
+import Pipes.Transformers as X
+
+-- import Pipes.Temporary as X
diff --git a/src/Pipes/Show.hs b/src/Pipes/Show.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Show.hs
@@ -0,0 +1,12 @@
+module Pipes.Show (
+  module X,
+  print
+                  )where
+
+import TextShow as X
+import TextShow.Generic as X
+
+import Pipes
+
+print :: (MonadIO m,TextShow a) => Consumer a m r
+print = for cat (\a -> liftIO (printT a))
diff --git a/src/Pipes/Temporary.hs b/src/Pipes/Temporary.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Temporary.hs
@@ -0,0 +1,16 @@
+module Pipes.Temporary where
+
+import Prelude
+
+import Pipes
+import Pipes.Internal
+
+import Control.Monad.Except
+
+exceptP
+    :: Monad m
+    => Proxy a' a b' b m (Either e r)
+    -> Proxy a' a b' b (ExceptT e m) r
+exceptP p = do
+    x <- unsafeHoist lift p
+    lift $ ExceptT (return x)
diff --git a/src/Pipes/Transformers.hs b/src/Pipes/Transformers.hs
new file mode 100644
--- /dev/null
+++ b/src/Pipes/Transformers.hs
@@ -0,0 +1,88 @@
+module Pipes.Transformers (
+  module X
+  ) where
+
+import Control.Monad.Fix as X hiding (fix)
+import Control.Monad.Trans.Class as X
+import Control.Monad.IO.Class as X
+
+import Control.Monad.Except as X (
+  MonadError(..),
+  Except,
+  ExceptT(..),
+  runExcept,
+  runExceptT,
+  mapExcept,
+  mapExceptT,
+  withExcept,
+  withExceptT
+                                 )
+
+import Control.Monad.Trans.Maybe as X (
+  MaybeT(..),
+  mapMaybeT,
+  maybeToExceptT,
+  exceptToMaybeT
+                                      )
+
+import Control.Monad.Reader as X (
+  MonadReader(..),
+  asks,
+  Reader,
+  ReaderT(..),
+  runReader,
+  mapReader,
+  mapReaderT,
+  withReader,
+  withReaderT
+                                 )
+
+import Control.Monad.State.Strict as X (
+  MonadState(..),
+  State,
+  StateT,
+  modify,
+  modify',
+  gets,
+  runState,
+  runStateT,
+  evalState,
+  evalStateT,
+  execState,
+  execStateT,
+  mapState,
+  mapStateT,
+  withState,
+  withStateT
+                                       )
+
+import Control.Monad.Writer.Strict as X (
+  MonadWriter(..),
+  listens,
+  censor,
+  Writer,
+  WriterT,
+  runWriter,
+  runWriterT,
+  execWriter,
+  execWriterT,
+  mapWriter,
+  mapWriterT
+                                        )
+
+import Control.Monad.RWS.Strict as X (
+  RWS,
+  RWST(..),
+  rws,
+  runRWS,
+  runRWST,
+  evalRWS,
+  evalRWST,
+  execRWS,
+  execRWST,
+  mapRWS,
+  mapRWST,
+  withRWS,
+  withRWST
+                                     )
+
diff --git a/test/Spec.hs b/test/Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/Spec.hs
@@ -0,0 +1,2 @@
+main :: IO ()
+main = putStrLn "Test suite not yet implemented"