diff --git a/ginger.cabal b/ginger.cabal
--- a/ginger.cabal
+++ b/ginger.cabal
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                ginger
-version:             0.1.7.0
+version:             0.1.8.0
 synopsis:            An implementation of the Jinja2 template language in Haskell
 description:         Ginger is Jinja, minus the most blatant pythonisms. Wants
                      to be feature complete, but isn't quite there yet.
diff --git a/src/Text/Ginger.hs b/src/Text/Ginger.hs
--- a/src/Text/Ginger.hs
+++ b/src/Text/Ginger.hs
@@ -191,6 +191,35 @@
 -- a function to a context value on the host side, you can use it just like
 -- any other function / filter.
 
+-- ** Control Constructs
+-- *** Conditionals: `{% if %}`
+-- | Simplest form:
+
+-- | > {% if condition %}Hello!{% endif %}
+
+-- | Slightly more elaborate:
+
+-- | > {% if condition %}Hello!{% else %}Goodbye!{% endif %}
+
+-- | Full glory:
+
+-- | > {% if condition %}Hello!{% elseif otherCondition %}Sayonara!{% else %}Goodbye!{% endif %}
+
+-- *** set
+-- | TODO
+-- *** for
+-- | TODO
+-- *** include
+-- | TODO
+-- *** macro
+-- | TODO
+-- *** block
+-- | TODO
+-- *** call
+-- | TODO
+-- *** scope
+-- | TODO
+
 -- * Haskell API
 -- ** General
 -- | On the Haskell side of things, executing a template is a two-step process.
@@ -208,7 +237,7 @@
 -- example implementation for 'IO' would look like this:
 
 -- | > loadFile fn = openFile fn ReadMode >>= hGetContents
--- > 
+-- >
 -- > loadFileMay fn =
 -- >     tryIOError (loadFile fn) >>= \e ->
 -- >          case e of
diff --git a/src/Text/Ginger/Parse.hs b/src/Text/Ginger/Parse.hs
--- a/src/Text/Ginger/Parse.hs
+++ b/src/Text/Ginger/Parse.hs
@@ -473,6 +473,10 @@
         additiveExprP
         [ ("==", "equals")
         , ("!=", "nequals")
+        , (">=", "greaterEquals")
+        , ("<=", "lessEquals")
+        , (">", "greater")
+        , ("<", "less")
         ]
 
 additiveExprP :: Monad m => Parser m Expression
diff --git a/src/Text/Ginger/Run.hs b/src/Text/Ginger/Run.hs
--- a/src/Text/Ginger/Run.hs
+++ b/src/Text/Ginger/Run.hs
@@ -29,6 +29,7 @@
 where
 
 import Prelude ( (.), ($), (==), (/=)
+               , (>), (<), (>=), (<=)
                , (+), (-), (*), (/), div
                , (||), (&&)
                , (++)
@@ -140,6 +141,10 @@
             , ("difference", fromFunction . variadicNumericFunc 0 $ difference)
             , ("equals", fromFunction gfnEquals)
             , ("nequals", fromFunction gfnNEquals)
+            , ("greaterEquals", fromFunction gfnGreaterEquals)
+            , ("lessEquals", fromFunction gfnLessEquals)
+            , ("greater", fromFunction gfnGreater)
+            , ("less", fromFunction gfnLess)
             , ("floor", fromFunction . unaryNumericFunc 0 $ Prelude.fromIntegral . Prelude.floor)
             , ("int", fromFunction . unaryFunc $ toGVal . (fmap (Prelude.truncate :: Scientific -> Int)) . asNumber)
             , ("int_ratio", fromFunction . variadicNumericFunc 1 $ fromIntegral . intRatio . Prelude.map Prelude.floor)
@@ -215,6 +220,46 @@
             -- If either is NULL, the other must be falsy
             | isNull a || isNull b = asBoolean a == asBoolean b
             | otherwise = asText a == asText b
+
+        gfnLess :: Function (Run m)
+        gfnLess [] = return . toGVal $ False
+        gfnLess xs' =
+            let xs = fmap snd xs'
+            in return . toGVal $
+                Prelude.all (== Just True) (Prelude.zipWith less xs (Prelude.tail xs))
+
+        gfnGreater :: Function (Run m)
+        gfnGreater [] = return . toGVal $ False
+        gfnGreater xs' =
+            let xs = fmap snd xs'
+            in return . toGVal $
+                Prelude.all (== Just True) (Prelude.zipWith greater xs (Prelude.tail xs))
+
+        gfnLessEquals :: Function (Run m)
+        gfnLessEquals [] = return . toGVal $ False
+        gfnLessEquals xs' =
+            let xs = fmap snd xs'
+            in return . toGVal $
+                Prelude.all (== Just True) (Prelude.zipWith lessEq xs (Prelude.tail xs))
+
+        gfnGreaterEquals :: Function (Run m)
+        gfnGreaterEquals [] = return . toGVal $ False
+        gfnGreaterEquals xs' =
+            let xs = fmap snd xs'
+            in return . toGVal $
+                Prelude.all (== Just True) (Prelude.zipWith greaterEq xs (Prelude.tail xs))
+
+        less :: GVal (Run m) -> GVal (Run m) -> Maybe Bool
+        less a b = (<) <$> asNumber a <*> asNumber b
+
+        greater :: GVal (Run m) -> GVal (Run m) -> Maybe Bool
+        greater a b = (>) <$> asNumber a <*> asNumber b
+
+        lessEq :: GVal (Run m) -> GVal (Run m) -> Maybe Bool
+        lessEq a b = (<=) <$> asNumber a <*> asNumber b
+
+        greaterEq :: GVal (Run m) -> GVal (Run m) -> Maybe Bool
+        greaterEq a b = (>=) <$> asNumber a <*> asNumber b
 
         difference :: Prelude.Num a => [a] -> a
         difference (x:xs) = x - Prelude.sum xs