diff --git a/hsp.cabal b/hsp.cabal
--- a/hsp.cabal
+++ b/hsp.cabal
@@ -1,5 +1,5 @@
 Name:                   hsp
-Version:                0.9.2
+Version:                0.10.0
 License:                BSD3
 License-File:           LICENSE
 Author:                 Niklas Broberg, Joel Bjornson
diff --git a/src/HSP/HTML4.hs b/src/HSP/HTML4.hs
--- a/src/HSP/HTML4.hs
+++ b/src/HSP/HTML4.hs
@@ -70,6 +70,7 @@
         renderAttr :: Attribute -> Builder
         renderAttr (MkAttr (nam, (Value needsEscape val))) =
             showName nam <> singleton '=' <> renderAttrVal (if needsEscape then (escaper htmlEscapeChars val) else fromLazyText val)
+        renderAttr (MkAttr (nam, NoValue)) = showName nam
 
         renderAttrVal :: Builder -> Builder
         renderAttrVal s = singleton '\"' <> s <> singleton '\"'
diff --git a/src/HSP/Monad.hs b/src/HSP/Monad.hs
--- a/src/HSP/Monad.hs
+++ b/src/HSP/Monad.hs
@@ -11,10 +11,11 @@
 import Control.Monad.State  (MonadState)
 import Control.Monad.Trans  (MonadIO, MonadTrans(lift))
 import Data.String          (fromString)
+import qualified Data.Text  as Strict
 import Data.Text.Lazy       (Text)
-import qualified Data.Text.Lazy as Text
+import qualified Data.Text.Lazy as Lazy
 import HSP.XMLGenerator     (AppendChild(..), Attr(..), EmbedAsAttr(..), EmbedAsChild(..), IsName(..), SetAttr(..), XMLGen(..), XMLGenerator)
-import HSP.XML              (Attribute(..), XML(..), pAttrVal, pcdata)
+import HSP.XML              (Attribute(..), XML(..), AttrValue(..), pAttrVal, pcdata)
 
 newtype HSPT xml m a = HSPT { unHSPT :: m a }
     deriving (Functor, Applicative, Alternative, Monad, MonadPlus, MonadIO, MonadReader r, MonadWriter w, MonadState s, MonadCont, MonadError e, MonadFix)
@@ -55,13 +56,16 @@
     asChild = return . map HSPChild
 
 instance (Functor m, Monad m) => EmbedAsChild (HSPT XML m) String where
-    asChild = return . (:[]) . HSPChild . pcdata . Text.pack
+    asChild = return . (:[]) . HSPChild . pcdata . Lazy.pack
 
 instance (Functor m, Monad m) => EmbedAsChild (HSPT XML m) Text where
     asChild = return . (:[]) . HSPChild . pcdata
 
+instance (Functor m, Monad m) => EmbedAsChild (HSPT XML m) Strict.Text where
+    asChild = return . (:[]) . HSPChild . pcdata . Lazy.fromStrict
+
 instance (Functor m, Monad m) => EmbedAsChild (HSPT XML m) Char where
-    asChild = return . (:[]) . pcdataToChild . Text.singleton
+    asChild = return . (:[]) . pcdataToChild . Lazy.singleton
 
 instance (Functor m, Monad m) => EmbedAsChild (HSPT XML m) () where
     asChild = return . const []
@@ -72,14 +76,39 @@
 instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) where
     asAttr (n := v) = asAttr $ MkAttr (toName n, (pAttrVal v))
 
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text Text) where
+    asAttr (n := v) = asAttr $ MkAttr (toName n, (pAttrVal v))
+
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text Strict.Text) where
+    asAttr (n := v) = asAttr $ MkAttr (toName n, (pAttrVal $ Lazy.fromStrict v))
+
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Strict.Text) where
+    asAttr (n := v) = asAttr $ MkAttr (toName n, (pAttrVal $ Lazy.fromStrict v))
+
 instance (Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) where
-    asAttr (n := c)  = asAttr (n := Text.singleton c)
+    asAttr (n := c)  = asAttr (n := Lazy.singleton c)
 
+instance (Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text Char) where
+    asAttr (n := c)  = asAttr $ MkAttr (toName n, pAttrVal $ Lazy.singleton c)
+
 instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) where
     asAttr (n := True)  = asAttr $ MkAttr (toName n, pAttrVal $ fromString "true")
     asAttr (n := False) = asAttr $ MkAttr (toName n, pAttrVal $ fromString "false")
 
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text Bool) where
+    asAttr (n := True)  = asAttr $ MkAttr (toName n, pAttrVal $ fromString "true")
+    asAttr (n := False) = asAttr $ MkAttr (toName n, pAttrVal $ fromString "false")
+
 instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) where
     asAttr (n := i)  = asAttr $ MkAttr (toName n, pAttrVal $ fromString (show i))
+
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text Int) where
+    asAttr (n := i)  = asAttr $ MkAttr (toName n, pAttrVal $ fromString (show i))
+
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) where
+    asAttr (n := ())  = asAttr $ MkAttr (toName n, NoValue)
+
+instance (Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Strict.Text ()) where
+    asAttr (n := ())  = asAttr $ MkAttr (toName n, NoValue)
 
 instance (Functor m, Monad m) => XMLGenerator (HSPT XML m)
diff --git a/src/HSP/XML.hs b/src/HSP/XML.hs
--- a/src/HSP/XML.hs
+++ b/src/HSP/XML.hs
@@ -57,7 +57,7 @@
   deriving Show
 
 -- | Represents an attribue value.
-data AttrValue = Value Bool Text
+data AttrValue = Value Bool Text | NoValue
 
 -- fromStringLit :: String -> Text
 -- fromStringLit = Text.pack
@@ -69,6 +69,7 @@
 
 instance Show AttrValue where
  show (Value _ txt) = Text.unpack txt
+ show NoValue = ""
 
 type Attributes = [Attribute]
 
@@ -130,6 +131,7 @@
         renderAttr :: Attribute -> Builder
         renderAttr (MkAttr (nam, (Value needsEscape val))) =
             showNSName nam <> singleton '=' <> renderAttrVal  (if needsEscape then escape val else fromLazyText val)
+        renderAttr (MkAttr (nam, NoValue)) = showNSName nam <> singleton '=' <> renderAttrVal (fromString "")
 
         renderAttrVal :: Builder -> Builder
         renderAttrVal txt = singleton '\"' <> txt <> singleton '\"'
diff --git a/src/HSP/XMLGenerator.hs b/src/HSP/XMLGenerator.hs
--- a/src/HSP/XMLGenerator.hs
+++ b/src/HSP/XMLGenerator.hs
@@ -29,6 +29,7 @@
 import Control.Monad       (MonadPlus(..),liftM)
 import Data.Text.Lazy      (Text)
 import qualified Data.Text.Lazy as Text
+import qualified Data.Text      as Strict
 
 ----------------------------------------------
 -- General XML Generation
@@ -209,9 +210,17 @@
 instance IsName Text Text where
  toName s = (Nothing, s)
 
+-- | strings can represent names, meaning a simple name with no domain.
+instance IsName Strict.Text Text where
+ toName s = (Nothing, Text.fromStrict s)
+
 -- | Pairs of strings can represent names, meaning a name qualified with a domain.
 instance IsName (Text, Text) Text where
  toName (ns, s) = (Just $ ns, s)
+
+-- | Pairs of strings can represent names, meaning a name qualified with a domain.
+instance IsName (Strict.Text, Strict.Text) Text where
+ toName (ns, s) = (Just $ Text.fromStrict ns, Text.fromStrict s)
 
 ---------------------------------------
 -- TypeCast, in lieu of ~ constraints