diff --git a/NEWS b/NEWS
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,8 @@
+# Version 0.5.0.0
+
+ * Removed `Control.Proxy.TCP.Sync` and `Control.Proxy.TCP.Safe.Sync`.
+
+
 # Version 0.4.0.1
 
 * FIX: `acceptFork` now properly closes the connection socket, even in
diff --git a/pipes-network.cabal b/pipes-network.cabal
--- a/pipes-network.cabal
+++ b/pipes-network.cabal
@@ -1,5 +1,5 @@
 name:               pipes-network
-version:            0.4.0.2
+version:            0.5.0.0
 license:            BSD3
 license-file:       LICENSE
 copyright:          Copyright (c) Renzo Carbonara 2012-2013, Paolo Capriotti 2012-2012.
@@ -46,9 +46,7 @@
         transformers   (>=0.2 && <0.4)
     exposed-modules:
         Control.Proxy.TCP
-        Control.Proxy.TCP.Sync
         Control.Proxy.TCP.Safe
-        Control.Proxy.TCP.Safe.Sync
     other-modules:
         Control.Proxy.Network.Internal
     ghc-options: -Wall -fno-warn-unused-do-bind
diff --git a/src/Control/Proxy/TCP/Safe/Sync.hs b/src/Control/Proxy/TCP/Safe/Sync.hs
deleted file mode 100644
--- a/src/Control/Proxy/TCP/Safe/Sync.hs
+++ /dev/null
@@ -1,127 +0,0 @@
--- | This module exports 'P.Proxy's that allow implementing synchronous RPC-like
--- communication with a remote end by using a simple protocol on their
--- downstream interface.
---
--- As opposed to the similar proxies found in "Control.Proxy.TCP.Sync",
--- these use the exception handling facilities provided by 'P.ExceptionP'.
---
--- You may prefer the more general proxies from
--- "Control.Proxy.TCP.Safe".
-
-module Control.Proxy.TCP.Safe.Sync (
-  -- * Socket proxies
-  socketSyncServer,
-  socketSyncProxy,
-  -- * RPC support
-  syncDelimit,
-  -- * Protocol
-  Request(..),
-  Response(..),
-  ) where
-
-import qualified Control.Proxy                    as P
-import           Control.Proxy.TCP.Sync           (Request(..), Response(..),
-                                                   syncDelimit)
-import           Control.Proxy.Network.Internal
-import qualified Control.Proxy.Safe               as P
-import qualified Data.ByteString                  as B
-import           Data.Monoid
-import qualified Network.Socket                   as NS
-import           System.Timeout                   (timeout)
-
-
--- | 'P.Server' able to send and receive bytes through a 'NS.Socket'.
---
--- If downstream requests @'Send' bytes@, then such @bytes@ are sent to the
--- remote end and then this proxy responds 'Sent' downstream.
---
--- If downstream requests @'Receive' num@, then at most @num@ bytes are received
--- from the remote end. This proxy then responds downstream such received
--- bytes as @'Received' bytes@. Less than the specified maximum number of bytes
--- might be received at once.
---
--- If an optional timeout is given and interactions with the remote end
--- take more time that such timeout, then throw a 'Timeout' exception in
--- the 'P.ExceptionP' proxy transformer.
---
--- This proxy returns if EOF is received or the remote end closes its side of
--- the connection while we are trying to read from it.
-socketSyncServer
-  :: P.Proxy p
-  => Maybe Int          -- ^Optional timeout in microseconds (1/10^6 seconds).
-  -> NS.Socket          -- ^Connected socket.
-  -> Request B.ByteString
-  -> P.Server (P.ExceptionP p) (Request B.ByteString) Response P.SafeIO ()
-socketSyncServer Nothing sock = loop where
-    loop (Send bs) = do
-        P.tryIO (send sock bs)
-        P.respond Sent >>= loop
-    loop (Receive nbytes) = do
-        mbs <- P.tryIO (recv sock nbytes)
-        case mbs of
-          Just bs -> P.respond (Received bs) >>= loop
-          Nothing -> return ()
-socketSyncServer (Just wait) sock = loop where
-    loop (Send bs) = do
-        m <- P.tryIO (timeout wait (send sock bs))
-        case m of
-          Just () -> P.respond Sent >>= loop
-          Nothing -> P.throw ex
-    loop (Receive nbytes) = do
-        mmbs <- P.tryIO (timeout wait (recv sock nbytes))
-        case mmbs of
-          Just (Just bs) -> P.respond (Received bs) >>= loop
-          Just Nothing   -> return ()
-          Nothing        -> P.throw ex
-    ex = Timeout $ "socketSyncServer: " <> show wait <> " microseconds."
-{-# INLINABLE socketSyncServer #-}
-
--- | 'P.Proxy' able to send and receive bytes through a 'NS.Socket'.
---
--- If downstream requests @'Send' a'@, then such @a'@ request is forwarded
--- upstream, which in return responds a 'B.ByteString' that this proxy sends to
--- the remote end. After sending to the remote end, this proxy responds 'Sent'
--- downstream.
---
--- If downstream requests @'Receive' num@, then at most @num@ bytes are received
--- from the remote end. This proxy then responds downstream such received
--- bytes as @'Received' bytes@. Less than the specified maximum number of bytes
--- might be received at once.
---
--- If an optional timeout is given and interactions with the remote end
--- take more time that such timeout, then throw a 'Timeout' exception in
--- the 'P.ExceptionP' proxy transformer.
---
--- This proxy returns if EOF is received or the remote end closes its side of
--- the connection while we are trying to read from it.
-socketSyncProxy
-  :: P.Proxy p
-  => Maybe Int          -- ^Optional timeout in microseconds (1/10^6 seconds).
-  -> NS.Socket          -- ^Connected socket.
-  -> Request a'
-  -> (P.ExceptionP p) a' B.ByteString (Request a') Response P.SafeIO ()
-socketSyncProxy Nothing sock = loop where
-    loop (Send a') = do
-        P.tryIO . send sock =<< P.request a'
-        P.respond Sent >>= loop
-    loop (Receive nbytes) = do
-        mbs <- P.tryIO (recv sock nbytes)
-        case mbs of
-          Just bs -> P.respond (Received bs) >>= loop
-          Nothing -> return ()
-socketSyncProxy (Just wait) sock = loop where
-    loop (Send a') = do
-        m <- P.tryIO . timeout wait . send sock =<< P.request a'
-        case m of
-          Just () -> P.respond Sent >>= loop
-          Nothing -> P.throw ex
-    loop (Receive nbytes) = do
-        mmbs <- P.tryIO (timeout wait (recv sock nbytes))
-        case mmbs of
-          Just (Just bs) -> P.respond (Received bs) >>= loop
-          Just Nothing   -> return ()
-          Nothing        -> P.throw ex
-    ex = Timeout $ "socketSyncProxy: " <> show wait <> " microseconds."
-{-# INLINABLE socketSyncProxy #-}
-
-
diff --git a/src/Control/Proxy/TCP/Sync.hs b/src/Control/Proxy/TCP/Sync.hs
deleted file mode 100644
--- a/src/Control/Proxy/TCP/Sync.hs
+++ /dev/null
@@ -1,208 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-
--- | This module exports 'P.Proxy's that allow implementing synchronous RPC-like
--- communication with a remote end by using a simple protocol on their
--- downstream interface.
---
--- As opposed to the similar proxies found in
--- "Control.Proxy.TCP.Safe.Sync", these don't use the exception handling
--- facilities provided by 'P.ExceptionP'.
---
--- You may prefer the more general and efficient proxies from
--- "Control.Proxy.TCP".
-
-module Control.Proxy.TCP.Sync (
-  -- * Socket proxies
-  socketSyncServer,
-  socketSyncProxy,
-  -- ** Timeouts
-  -- $timeouts
-  socketSyncServerTimeout,
-  socketSyncProxyTimeout,
-  -- * RPC support
-  syncDelimit,
-  -- * Protocol types
-  Request(..),
-  Response(..),
-  ) where
-
-import           Control.Monad.Trans.Class
-import qualified Control.Proxy                    as P
-import           Control.Proxy.Network.Internal
-import qualified Control.Proxy.Trans.Either       as PE
-import qualified Data.ByteString.Char8            as B
-import           Data.Monoid
-import qualified Network.Socket                   as NS
-import           System.Timeout                   (timeout)
-
-
--- | A request made to one of the @socketSync*@ proxies.
-data Request t = Send t | Receive Int
-  deriving (Eq, Read, Show)
-
--- | A response received from one of the @socketSync*@ proxies.
-data Response = Sent | Received B.ByteString
-  deriving (Eq, Read, Show)
-
---------------------------------------------------------------------------------
-
--- | 'P.Server' able to send and receive bytes through a 'NS.Socket'.
---
--- If downstream requests @'Send' bytes@, then such @bytes@ are sent to the
--- remote end and then this proxy responds 'Sent' downstream.
---
--- If downstream requests @'Receive' num@, then at most @num@ bytes are received
--- from the remote end. This proxy then responds downstream such received
--- bytes as @'Received' bytes@. Less than the specified maximum number of bytes
--- might be received at once.
---
--- This proxy returns if EOF is received or the remote end closes its side of
--- the connection while we are trying to read from it.
-socketSyncServer
-  :: P.Proxy p
-  => NS.Socket          -- ^Connected socket.
-  -> Request B.ByteString
-  -> P.Server p (Request B.ByteString) Response IO ()
-socketSyncServer sock = P.runIdentityK loop where
-    loop (Send bs) = do
-        lift (send sock bs)
-        P.respond Sent >>= loop
-    loop (Receive nbytes) = do
-        mbs <- lift (recv sock nbytes)
-        case mbs of
-          Just bs -> P.respond (Received bs) >>= loop
-          Nothing -> return ()
-{-# INLINABLE socketSyncServer #-}
-
--- | 'P.Proxy' able to send and receive bytes through a 'NS.Socket'.
---
--- If downstream requests @'Send' a'@, then such @a'@ request is forwarded
--- upstream, which in return responds a 'B.ByteString' that this proxy sends to
--- the remote end. After sending to the remote end, this proxy responds 'Sent'
--- downstream.
---
--- If downstream requests @'Receive' num@, then at most @num@ bytes are received
--- from the remote end. This proxy then responds downstream such received
--- bytes as @'Received' bytes@. Less than the specified maximum number of bytes
--- might be received at once.
---
--- This proxy returns if EOF is received or the remote end closes its side of
--- the connection while we are trying to read from it.
-socketSyncProxy
-  :: P.Proxy p
-  => NS.Socket          -- ^Connected socket.
-  -> Request a'
-  -> p a' B.ByteString (Request a') Response IO ()
-socketSyncProxy sock = P.runIdentityK loop where
-    loop (Send a') = do
-        lift . send sock =<< P.request a'
-        P.respond Sent >>= loop
-    loop (Receive nbytes) = do
-        mbs <- lift (recv sock nbytes)
-        case mbs of
-          Just bs -> P.respond (Received bs) >>= loop
-          Nothing -> return ()
-{-# INLINABLE socketSyncProxy #-}
-
---------------------------------------------------------------------------------
-
--- $timeouts
---
--- These proxies behave like the similarly named ones above, except support for
--- timing out the interaction with the remote end is added.
-
--- | Like 'socketSyncServer', except it throws a 'Timeout' exception in the
--- 'PE.EitherP' proxy transformer if interacting with the remote end takes
--- more time than specified.
-socketSyncServerTimeout
-  :: P.Proxy p
-  => Int                -- ^Timeout in microseconds (1/10^6 seconds).
-  -> NS.Socket          -- ^Connected socket.
-  -> Request B.ByteString
-  -> P.Server (PE.EitherP Timeout p) (Request B.ByteString) Response IO ()
-socketSyncServerTimeout wait sock = loop where
-    loop (Send bs) = do
-        m <- lift (timeout wait (send sock bs))
-        case m of
-          Just () -> P.respond Sent >>= loop
-          Nothing -> PE.throw ex
-    loop (Receive nbytes) = do
-        mmbs <- lift (timeout wait (recv sock nbytes))
-        case mmbs of
-          Just (Just bs) -> P.respond (Received bs) >>= loop
-          Just Nothing   -> return ()
-          Nothing        -> PE.throw ex
-    ex = Timeout $ "socketSyncServerTimeout: " <> show wait <> " microseconds."
-{-# INLINABLE socketSyncServerTimeout #-}
-
--- | Like 'socketSyncProxy', except it throws a 'Timeout' exception in the
--- 'PE.EitherP' proxy transformer if interacting with the remote end takes
--- more time than specified.
-socketSyncProxyTimeout
-  :: P.Proxy p
-  => Int                -- ^Timeout in microseconds (1/10^6 seconds).
-  -> NS.Socket          -- ^Connected socket.
-  -> Request a'
-  -> (PE.EitherP Timeout p) a' B.ByteString (Request a') Response IO ()
-socketSyncProxyTimeout wait sock = loop where
-    loop (Send a') = do
-        m <- lift . timeout wait . send sock =<< P.request a'
-        case m of
-          Just () -> P.respond Sent >>= loop
-          Nothing -> PE.throw ex
-    loop (Receive nbytes) = do
-        mmbs <- lift (timeout wait (recv sock nbytes))
-        case mmbs of
-          Just (Just bs) -> P.respond (Received bs) >>= loop
-          Just Nothing   -> return ()
-          Nothing        -> PE.throw ex
-    ex = Timeout $ "socketSyncProxyTimeout: " <> show wait <> " microseconds."
-{-# INLINABLE socketSyncProxyTimeout #-}
-
---------------------------------------------------------------------------------
-
--- | When used together with one of the @socketSync*@ proxies upstream, this
--- proxy sends a single 'B.ByteString' to the remote end and then repeatedly
--- receives bytes from the remote end until the given delimiter is found.
--- Finally, a single 'B.ByteString' up to the given delimiter (inclusive) is
--- sent downstream and then the whole process is repeated.
---
--- This proxy works cooperatively with any @socketSync*@ proxy immediately
--- upstream, so read their documentation to understand the purpose of the
--- @b'@ value received from downstream.
---
--- For example, if you'd like to convert a 'NS.Socket' into an synchronous
--- line-oriented RPC client implemented as a 'P.Server' in which RPC calls are
--- received via the downstream interface and RPC responses are sent downstream,
--- then you could use this proxy as:
---
--- > socketSyncServer ... >-> syncDelimit 4096 "\r\n"
---
--- Otherwise, if you'd like to convert a 'NS.Socket' into an synchronous
--- line-oriented RPC client implemented as a 'P.Proxy' in which RPC calls are
--- received via the upstream interface and RPC responses are sent downstream,
--- then you could use this proxy as:
---
--- > socketSyncProxy ... >-> syncDelimit 4096 "\r\n"
-syncDelimit
-  :: (Monad m, P.Proxy p)
-  => Int                -- ^Maximum number of bytes to receive at once.
-  -> B.ByteString       -- ^Delimiting bytes.
-  -> b'-> p (Request b') Response b' B.ByteString m r
-syncDelimit nbytes delim b' =
-    -- XXX this implementation might be inefficient.
-    P.runIdentityP $ use =<< more mempty (Send b')
-  where
-    more buf req = do
-      a <- P.request req
-      case a of
-        Received bs -> return (buf <> bs)
-        Sent        -> more buf (Receive nbytes)
-    use buf = do
-      let (pre,suf) = B.breakSubstring delim buf
-      case B.length suf of
-        0 -> use =<< more buf (Receive nbytes)
-        _ -> do b'2 <- P.respond (pre <> delim)
-                use =<< more (B.drop (B.length delim) suf) (Send b'2)
-{-# INLINABLE syncDelimit #-}
-