diff --git a/dhall-nix.cabal b/dhall-nix.cabal
--- a/dhall-nix.cabal
+++ b/dhall-nix.cabal
@@ -1,5 +1,5 @@
 Name: dhall-nix
-Version: 1.1.7
+Version: 1.1.8
 Cabal-Version: >=1.8.0.2
 Build-Type: Simple
 Tested-With: GHC == 8.0.1
@@ -30,14 +30,16 @@
         base                      >= 4.8.0.0 && < 5   ,
         containers                              < 0.7 ,
         data-fix                                < 0.3 ,
-        dhall                     >= 1.25    && < 1.26,
+        dhall                     >= 1.26    && < 1.27,
         hnix                      >= 0.6.1   && < 0.7 ,
         neat-interpolation                      < 0.4 ,
         text                      >= 0.8.0.0 && < 1.3
     Exposed-Modules:
         Dhall.Nix
     GHC-Options: -Wall
-
+    if os(windows)
+        Buildable: False
+        
 Executable dhall-to-nix
     Hs-Source-Dirs: exec
     Main-Is: Main.hs
@@ -49,3 +51,5 @@
         optparse-generic >= 1.1.1   && < 1.4,
         text
     GHC-Options: -Wall
+    if os(windows)
+        Buildable: False
diff --git a/src/Dhall/Nix.hs b/src/Dhall/Nix.hs
--- a/src/Dhall/Nix.hs
+++ b/src/Dhall/Nix.hs
@@ -53,7 +53,7 @@
 
     Unions are Church-encoded:
 
-> $ dhall-to-nix <<< "< Left = True | Right : Natural >"
+> $ dhall-to-nix <<< "< Left : Bool | Right : Natural >.Left True"
 > { Left, Right }: Left true
 
     Also, all Dhall expressions are normalized before translation to Nix:
@@ -95,8 +95,9 @@
 import Data.Fix (Fix(..))
 import Data.Traversable (for)
 import Data.Typeable (Typeable)
-import Dhall.Core (Chunks(..), Const(..), Expr(..), Var(..))
-import Dhall.TypeCheck (X(..))
+import Data.Void (absurd)
+import Dhall.Core (Chunks(..), Const(..), Expr(..), MultiLet(..), Var(..))
+import Dhall.TypeCheck (X)
 import Nix.Atoms (NAtom(..))
 import Nix.Expr
     ( Antiquoted(..)
@@ -229,7 +230,8 @@
         a' <- loop a
         b' <- loop b
         return (Fix (NBinary NApp a' b'))
-    loop (Let as b) = do
+    loop (Let a0 b0) = do
+        let MultiLet as b = Dhall.Core.multiLet a0 b0
         as' <- for as $ \a -> do
           val <- loop $ Dhall.Core.value a
           pure $ NamedVar [StaticKey $ Dhall.Core.variable a] val Nix.nullPos
@@ -300,6 +302,14 @@
         return (Fix (NLet [e5] e8))
     loop NaturalShow = do
         return "toString"
+    loop NaturalSubtract = do
+        let e0 = NamedVar ["z"] (Fix (NBinary NMinus "y" "x")) Nix.nullPos
+        let e1 = Fix (NBinary NLt "z" (Fix (NConstant (NInt 0))))
+        let e2 = Fix (NConstant (NInt 0))
+        let e3 = "z"
+        let e4 = Fix (NIf e1 e2 e3)
+        let e5 = Fix (NLet [e0] e4)
+        return (Fix (NAbs "x" (Fix (NAbs "y" e5))))
     loop NaturalToInteger = do
         return (Fix (NAbs "n" "n"))
     loop (NaturalPlus a b) = do
@@ -444,13 +454,6 @@
                 return (NamedVar [StaticKey k] v Nix.nullPos)
         return (Fix (NSet a''))
     loop (Union _) = return (Fix (NSet []))
-    loop (UnionLit k v kts) = do
-        v' <- loop v
-        let e0 = do
-                k' <- k : Dhall.Map.keys kts
-                return (k', Nothing)
-        let e2 = Fix (NBinary NApp (Fix (NSym k)) v')
-        return (Fix (NAbs (ParamSet e0 False Nothing) e2))
     loop (Combine a b) = do
         a' <- loop a
         b' <- loop b
@@ -497,6 +500,17 @@
         a' <- loop a
         b' <- loop b
         return (Fix (NBinary NApp b' a'))
+    loop (ToMap a _) = do
+        a' <- loop a
+        let ks = Fix (NBinary NApp "builtins.attrNames" "kvs")
+        let v = Fix (NBinary NApp (Fix (NBinary NApp "builtins.getAttr" "k")) "kvs")
+        let setBindings =
+                [ NamedVar [StaticKey "mapKey"] "k" Nix.nullPos
+                , NamedVar [StaticKey "mapValue"] v Nix.nullPos
+                ]
+        let map_ = Fix (NBinary NApp "map" (Fix (NAbs "k" (Fix (NSet setBindings)))))
+        let toMap = Fix (NAbs "kvs" (Fix (NBinary NApp map_ ks)))
+        return (Fix (NBinary NApp toMap a'))
     loop (Prefer a b) = do
         a' <- loop a
         b' <- loop b
@@ -530,6 +544,10 @@
         return (Fix (NSet [Inherit (Just a') b' Nix.nullPos]))
     loop (Project _ (Right _)) = do
         Left CannotProjectByType
+    loop (Assert _) = do
+        return (Fix (NSet []))
+    loop (Equivalent _ _) = do
+        return (Fix (NSet []))
     loop (ImportAlt a _) = loop a
     loop (Note _ b) = loop b
-    loop (Embed (X x)) = x
+    loop (Embed x) = absurd x