diff --git a/heist.cabal b/heist.cabal
--- a/heist.cabal
+++ b/heist.cabal
@@ -1,5 +1,5 @@
 name:           heist
-version:        0.10.2
+version:        0.10.2.1
 synopsis:       An Haskell template system supporting both HTML5 and XML.
 description:
     Heist is a powerful template system that supports both HTML5 and XML.
diff --git a/src/Heist/Common.hs b/src/Heist/Common.hs
--- a/src/Heist/Common.hs
+++ b/src/Heist/Common.hs
@@ -81,17 +81,11 @@
         go !subDL = (gobbleText >>= go . append subDL)
                     <|> (AP.endOfInput *> finish subDL)
                     <|> (do
-                            res <- escSequence
-                            dl' <- finish subDL
-                            loop $! append dl' res)
-                    <|> (do
                             idp <- identParser
                             dl' <- finish subDL
                             loop $! append dl' idp)
 
-    gobbleText = AP.takeWhile1 (AP.notInClass "\\$")
-
-    escSequence = AP.char '\\' *> (Escaped <$> AP.anyChar)
+    gobbleText = AP.takeWhile1 (AP.notInClass "$")
 
     identParser = AP.char '$' *> (ident <|> return (Literal "$"))
     ident = (AP.char '{' *> (Ident <$> AP.takeWhile (/='}')) <* AP.string "}")
diff --git a/src/Heist/Compiled/Internal.hs b/src/Heist/Compiled/Internal.hs
--- a/src/Heist/Compiled/Internal.hs
+++ b/src/Heist/Compiled/Internal.hs
@@ -335,8 +335,7 @@
             (AP.Fail _ _ _) -> []
             (AP.Partial _ ) -> []
     cvt (Literal x) = x
-    cvt (Escaped c) = T.singleton c
-    cvt (Ident _) = error "parseAttrs: impossible case"
+    cvt (Ident i) = T.concat ["${", i, "}"]
 
 ------------------------------------------------------------------------------
 -- | Checks whether a node's subtree is static and can be rendered up front at
@@ -380,7 +379,6 @@
 
   where
     cvt (Literal x) = return $ yieldPureText x
-    cvt (Escaped c) = return $ yieldPureText $ T.singleton c
     cvt (Ident x) =
         localParamNode (const $ X.Element x [] []) $ getAttributeSplice x
 
@@ -464,7 +462,9 @@
 ------------------------------------------------------------------------------
 getAttributeSplice :: Text -> HeistT n IO (DList (Chunk n))
 getAttributeSplice name =
-    lookupSplice name >>= fromMaybe (return DL.empty)
+    lookupSplice name >>= fromMaybe
+      (return $ DL.singleton $ Pure $ T.encodeUtf8 $
+       T.concat ["${", name, "}"])
 {-# INLINE getAttributeSplice #-}
 
 
diff --git a/src/Heist/Interpreted/Internal.hs b/src/Heist/Interpreted/Internal.hs
--- a/src/Heist/Interpreted/Internal.hs
+++ b/src/Heist/Interpreted/Internal.hs
@@ -236,20 +236,10 @@
     return $ T.concat chunks
   where
     cvt (Literal x) = return x
-    cvt (Escaped c) = renderEscaped c
     cvt (Ident x)   =
         localParamNode (const $ X.Element x [] []) $ getAttributeSplice x
 
-    renderEscaped c = do
-        hs <- getHS
-        if _preprocessingMode hs
-          -- Load time splices can't be descructive, therefore we need to
-          -- output the slashes so we don't change anything before later
-          -- splice processing.
-          then return $ T.snoc "\\" c
-          else return $ T.singleton c
 
-
 ------------------------------------------------------------------------------
 -- | Gets the attribute value.  If the splice's result list contains non-text
 -- nodes, this will translate them into text nodes with nodeText and
@@ -275,10 +265,8 @@
 getAttributeSplice :: Monad n => Text -> HeistT n n Text
 getAttributeSplice name = do
     hs <- getHS
-    let noSplice = if _preprocessingMode hs
-                     then return $ T.concat ["${", name, "}"]
-                     else return ""
-    let s = lookupSplice name hs
+    let noSplice = return $ T.concat ["${", name, "}"]
+        s = lookupSplice name hs
     maybe noSplice (liftM (T.concat . map X.nodeText)) s
 
 ------------------------------------------------------------------------------
diff --git a/src/Heist/Types.hs b/src/Heist/Types.hs
--- a/src/Heist/Types.hs
+++ b/src/Heist/Types.hs
@@ -477,7 +477,6 @@
 -- attoparsec doesn't support parsers running in another monad.
 data AttAST = Literal Text
             | Ident   Text
-            | Escaped Char
   deriving (Show)
 
 
diff --git a/test/suite/Heist/Interpreted/Tests.hs b/test/suite/Heist/Interpreted/Tests.hs
--- a/test/suite/Heist/Interpreted/Tests.hs
+++ b/test/suite/Heist/Interpreted/Tests.hs
@@ -202,13 +202,13 @@
 
     out1 = B.unlines
         ["<mytag flag>Empty attribute</mytag>"
-        ,"<mytag flag='abc${foo}'>No ident capture</mytag>"
+        ,"<mytag flag='abc${bar}'>No ident capture</mytag>"
         ,"<div id='pre_meaning_of_everything_post'></div>"
         ]
     out2 = B.unlines
         ["<mytag flag>Empty attribute</mytag>"
-        ,"<mytag flag='abc${foo}'>No ident capture</mytag>"
-        ,"<div id='pre__post'></div>"
+        ,"<mytag flag='abc${bar}'>No ident capture</mytag>"
+        ,"<div id='pre_${foo}_post'></div>"
         ]
 
 
diff --git a/test/suite/Heist/Tests.hs b/test/suite/Heist/Tests.hs
--- a/test/suite/Heist/Tests.hs
+++ b/test/suite/Heist/Tests.hs
@@ -191,6 +191,6 @@
     iOut <- iRender hs "backslash"
     H.assertEqual "interpreted failure" iExpected iOut
   where
-    cExpected = "<foo regex='d+\\d'></foo>&#10;"
-    iExpected = "<foo regex='d+\\d'></foo>\n"
+    cExpected = "<foo regex='abc\\d+\\\\e'></foo>&#10;"
+    iExpected = "<foo regex='abc\\d+\\\\e'></foo>\n"
 
diff --git a/test/templates/attrs.tpl b/test/templates/attrs.tpl
--- a/test/templates/attrs.tpl
+++ b/test/templates/attrs.tpl
@@ -1,3 +1,3 @@
 <mytag flag="">Empty attribute</mytag>
-<mytag flag="abc\${foo}">No ident capture</mytag>
+<mytag flag="abc${bar}">No ident capture</mytag>
 <div id="pre_${foo}_post"/>