diff --git a/AUTHORS b/AUTHORS
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,2 +1,3 @@
 Jan Rochel
+Robert Kreuzer
 Chas Leichner (Google Inc.)
diff --git a/GL.hs b/GL.hs
--- a/GL.hs
+++ b/GL.hs
@@ -22,11 +22,8 @@
 		Operator   {} → sd n : [sd $ rm (alpha ops*x) `mmul` sws | x <- [0..la ops - 1]]
 		where
 			n  = Vector2 0 1
-			w  = Vector2 (-1) 0
 			e  = Vector2 1 0
 			s  = Vector2 0 (-1)
-			sw = Vector2 (-1) (-1)
-			se = Vector2 1 (-1)
 
 			la field = toEnum $ length (field node)
 			alpha f  = pi/(2*la f)
diff --git a/Rules.hs b/Rules.hs
--- a/Rules.hs
+++ b/Rules.hs
@@ -9,8 +9,6 @@
 import GraphRewriting.Graph.Read
 import GraphRewriting.Graph.Write
 import Data.List (transpose, elemIndex, delete)
-import Control.Applicative
-import Data.Monoid
 import Control.Monad
 
 import Data.Maybe (fromJust)
diff --git a/Term.hs b/Term.hs
--- a/Term.hs
+++ b/Term.hs
@@ -2,15 +2,10 @@
 module Term where
 
 import Prelude.Unicode
-import Text.ParserCombinators.Parsec as Parsec
-	hiding (space, eof, notFollowedBy, anyChar, many, optional, (<|>))
-import Text.ParserCombinators.Parsec.IndentParser as Indent
-import Text.ParserCombinators.Parsec.Language
-import Text.ParserCombinators.Parsec.IndentParser.Token
-import qualified Text.ParserCombinators.Parsec.Token as T
-import Control.Monad
-import Data.Functor
-import Control.Applicative
+import Text.Parsec
+import Control.Monad.Identity
+import Text.Parsec.Token (makeTokenParser, GenLanguageDef(..))
+import Text.Parsec.IndentParsec
 
 -- | The AST of a lambda expression
 data Λ = A Λ Λ            -- ^ application
@@ -23,89 +18,93 @@
 -- | The LHS of a case expression. Numbers are parsed as strings.
 data Pattern = Pat {constr ∷ String, vars ∷ [String]} deriving (Show, Eq, Ord)
 
-testParser ∷ IndentParser tok () c → [tok] → c
-testParser parser str = either (error ∘ show) id (Indent.parse parser "(null)" str)
+type IndentCharParser a = IndentParsec String () a
 
-parse ∷ [Char] → Λ
-parse = testParser expression
+langDef = LanguageDef { commentStart = "{-"
+                      , commentEnd   = "-}"
+                      , commentLine  = "--"
+                      , identStart = letter   <|> char '_'
+                      , identLetter = alphaNum <|> char '_'
+                      , opStart = oneOf "-+/*=<>"
+                      , opLetter = oneOf "-+/*=<>"
+                      , reservedNames = ["let", "in", "case", "of"]
+                      , reservedOpNames = ["=", "->", "→", "."]
+                      , caseSensitive = False
+                      , nestedComments = True
+                      }
 
 parseFile ∷ FilePath → IO Λ
-parseFile = liftM (either (error ∘ show) id) ∘ Indent.parseFromFile expression
+parseFile f = do
+	file ← readFile f
+	let parseErrorOrExpr = runIdentity $ runGIPT expression () f file
+	return $ either (error ∘ show) id parseErrorOrExpr
 
-expression ∷ IndentCharParser st Λ
+expression ∷ IndentCharParser Λ
 expression = flip label "expression" $ letBinding <|> caseExpr <|> application
 
-application ∷ IndentCharParser st Λ
+application ∷ IndentCharParser Λ
 application = foldl1 A <$> many1 (parenthetic <|> abstraction <|> variable <|> numeral)
 
-variable ∷ IndentCharParser st Λ
-variable = C <$> (ident <|> operator haskell) <*> pure []
+variable ∷ IndentCharParser Λ
+variable = C <$> (ident <|> operator tokP) <*> pure []
 
-numeral ∷ IndentCharParser st Λ
+numeral ∷ IndentCharParser Λ
 numeral = C <$> numeric <*> pure []
 
-numeric ∷ IndentCharParser st String
-numeric = either show show <$> naturalOrFloat haskell
+numeric ∷ IndentCharParser String
+numeric = either show show <$> naturalOrFloat tokP
 
-parenthetic ∷ IndentCharParser st Λ
-parenthetic = parens haskell expression
+parenthetic ∷ IndentCharParser Λ
+parenthetic = parens tokP expression
 
-tokP ∷ T.TokenParser st
-tokP = T.makeTokenParser haskellDef
+tokP :: IndentTokenParser String () Identity
+tokP = makeTokenParser langDef
 
-caseExpr ∷ IndentCharParser st Λ
-caseExpr = flip label "case expression" $
-	Case <$> (keyword "case" *> expression <* keyword "of") <*> bracesOrBlock tokP patterns
+caseExpr ∷ IndentCharParser Λ
+caseExpr = flip label "case expression" $ do
+	keyword "case"
+	Case <$> expression <* keyword "of" <*> blockOf (many1 $ foldedLinesOf pattern)
 
-patterns ∷ IndentCharParser st [(Pattern, Λ)]
-patterns = semiOrNewLineSep tokP pattern
+arrow ∷ IndentCharParser ()
+arrow = reservedOp tokP "→" <|> reservedOp tokP "->"
 
-arrow ∷ IndentCharParser st String
-arrow = sym "→" <|> sym "->"
+point ∷ IndentCharParser ()
+point = reservedOp tokP "."
 
-pattern ∷ IndentCharParser st (Pattern, Λ)
-pattern = (,) <$> lhs <*> (arrow *> expression) where
-	lhs = Pat <$> (ident <|> numeric) <*> many (ident <|> numeric)
+pattern ∷ IndentCharParser (Pattern, Λ)
+pattern = (,) <$> lhs <*> expression where
+	lhs = Pat <$> (ident <|> numeric) <*> manyTill (ident <|> numeric) arrow
 
-lambda ∷ IndentCharParser st String
+lambda ∷ IndentCharParser String
 lambda = sym "λ" <|> sym "\\"
 
-abstraction ∷ IndentCharParser st Λ
+abstraction ∷ IndentCharParser Λ
 abstraction = flip label "abstraction" $
-	flip (foldr Λ) <$> (lambda *> many1 ident) <*> ((sym "." <|> arrow) *> expression)
+	flip (foldr Λ) <$> (lambda *> many1 ident) <*> ((arrow <|> point) *> expression)
 
--- Ugly, but works. Keyword "in" terminates binding blocks and bindings. Allows empty lets
-letBinding ∷ IndentCharParser st Λ
+letBinding ∷ IndentCharParser Λ
 letBinding = flip label "let binding" $ do
-	let parseBindings = do
-		e ← optionMaybe $ keyword "in" *> expression
-		case e of
-			Just je → return ([], Just je)
-			Nothing → do
-				(b,e) ← lineFold $ (,) <$> binding <*> (optionMaybe $ keyword "in" *> expression)
-				case e of
-					Nothing → do
-						rec ← optionMaybe parseBindings
-						case rec of
-							Nothing → return ([b], Nothing)
-							Just (bs, me) → return (b:bs, me)
-					Just je → return ([b], Just je)
-	(binds, e) ← keyword "let" *> block parseBindings
-	case e of
-		Nothing → L binds <$> (keyword "in" *> expression)
-		Just je → return $ L binds je
+	keyword "let"
+	try oneLiner <|> multipleBindings where
+		oneLiner = do
+			b ← binding
+			L [b] <$> (keyword "in" *> expression)
+		multipleBindings = L <$> blockOf (many1 $ foldedLinesOf binding) <*> (keyword "in" *> expression)
 
-binding ∷ IndentCharParser st (String,Λ)
+binding ∷ IndentCharParser (String,Λ)
 binding = flip label "binding" $ do
 	funct ← ident
-	rhs ← flip (foldr Λ) <$> many ident <*> (sym "=" *> expression)
+	rhs ← flip (foldr Λ) <$> manyTill ident equals <*> expression
 	return (funct, rhs)
 
-keyword ∷ String → IndentCharParser st ()
-keyword = reserved haskell
+keyword ∷ String → IndentCharParser ()
+keyword = reserved tokP
 
-ident ∷ IndentCharParser st String
-ident = identifier haskell
+ident ∷ IndentCharParser String
+ident = identifier tokP
 
-sym ∷ String → IndentCharParser st String
-sym = symbol haskell
+sym ∷ String → IndentCharParser String
+sym = symbol tokP
+
+equals ∷ IndentCharParser ()
+equals = reservedOp tokP "="
diff --git a/examples/WW-beta-saving-0.l b/examples/WW-beta-saving-0.l
--- a/examples/WW-beta-saving-0.l
+++ b/examples/WW-beta-saving-0.l
@@ -1,1 +1,1 @@
-(\F. (\f. f (f 0)) (F 0)) (\y. \x. x) 
+(\F. (\f. f (f 0)) (F 0)) (\y. \x. x)
diff --git a/examples/WW-beta-saving-1.l b/examples/WW-beta-saving-1.l
--- a/examples/WW-beta-saving-1.l
+++ b/examples/WW-beta-saving-1.l
@@ -1,1 +1,1 @@
-(\F. (\f. f (f 0)) (F (F 0 0))) (\y. \x. x) 
+(\F. (\f. f (f 0)) (F (F 0 0))) (\y. \x. x)
diff --git a/examples/case/sum.l b/examples/case/sum.l
deleted file mode 100644
--- a/examples/case/sum.l
+++ /dev/null
@@ -1,5 +0,0 @@
-let
-	sum list = case list of
-		Nil -> 0
-		Cons z zs -> (\x.λy -> + x y) z (sum zs)
-in sum (Cons 1 (Cons 2 Nil))
diff --git a/examples/levy-1988-p184bottom.l b/examples/levy-1988-p184bottom.l
--- a/examples/levy-1988-p184bottom.l
+++ b/examples/levy-1988-p184bottom.l
@@ -1,6 +1,6 @@
 let I0    = \x0.x0
     I1    = \x1.x1
     J     = \z.b
-    Delta = \y.I1 (y y) 
+    Delta = \y.I1 (y y)
 in (\f.(f I0)(f J)) (\x. Delta (x a))
 
diff --git a/examples/sum_case.l b/examples/sum_case.l
new file mode 100644
--- /dev/null
+++ b/examples/sum_case.l
@@ -0,0 +1,4 @@
+let
+  sum list = case list of Nil -> 0
+                          Cons z zs -> (\x.λy -> plus x y) z (sum zs)
+in sum (Cons 1 (Cons 2 Nil))
diff --git a/examples/vincent-1-ww.l b/examples/vincent-1-ww.l
--- a/examples/vincent-1-ww.l
+++ b/examples/vincent-1-ww.l
@@ -1,4 +1,4 @@
-let G = \g. g (g x) 
+let G = \g. g (g x)
     F x = F x
-    I x = x 
+    I x = x
 in  G (F I)
diff --git a/graph-rewriting-lambdascope.cabal b/graph-rewriting-lambdascope.cabal
--- a/graph-rewriting-lambdascope.cabal
+++ b/graph-rewriting-lambdascope.cabal
@@ -1,5 +1,5 @@
 Name:           graph-rewriting-lambdascope
-Version:        0.5.10
+Version:        0.5.11
 Copyright:      (c) 2010, Jan Rochel
 License:        BSD3
 License-File:   LICENSE
@@ -8,28 +8,31 @@
 Homepage:       http://rochel.info/#graph-rewriting
 Stability:      alpha
 Build-Type:     Simple
-Synopsis:       Lambdascope, an optimal evaluator of the lambda calculus, as an interactive graph-rewriting system
-Description:    Lambdascope is an optimal evaluator of the λβ-calculus described in the paper "Lambdascope - Another optimal implementation of the lambda-calculus" by Vincent van Oostrom, Kees-Jan van de Looij, and Marijn Zwitserlood. Call "lambdascope" with one of the files from the "examples" directory as an argument. For usage of the GUI see "GraphRewriting.GL.UI". Use the "--lmo" flag for leftmost outermost evalution and "--bench" for non-graphical evaluation to weak head normal form.
+Synopsis:       Lambdascope, an optimal evaluator of the lambda calculus
+Description:    Lambdascope is an optimal evaluator of the λβ-calculus described in the paper "Lambdascope - Another optimal implementation of the lambda-calculus" by Vincent van Oostrom, Kees-Jan van de Looij, and Marijn Zwitserlood. This package contains an interactive application, which implements Lambdascope as a port-graph rewriting system. Call "lambdascope" with one of the files from the "examples" directory as an argument. For usage of the GUI see "GraphRewriting.GL.UI". Use the "--lmo" flag for leftmost outermost evalution and "--bench" for non-graphical evaluation to weak head normal form.
 Category:       Compilers/Interpreters, Application
-Cabal-Version:  >= 1.6
-Data-Files:     examples/*.l examples/case/*.l
+Cabal-Version:  >= 1.10
+Data-Files:     examples/*.l examples/*.l
 Extra-Source-Files: AUTHORS
 
 Executable lambdascope
+  Default-Language: Haskell2010
   Main-Is:        Main.hs
   Build-Depends:
-    base >= 4.8 && < 4.10,
+    base >= 4.9 && < 5,
     base-unicode-symbols >= 0.2 && < 0.3,
-    graph-rewriting >= 0.7.8,
-    graph-rewriting-layout >= 0.5.4,
-    graph-rewriting-gl >= 0.7.6,
-    graph-rewriting-strategies >= 0.2.4,
+    graph-rewriting >= 0.7.8 && < 0.9,
+    graph-rewriting-layout >= 0.5.4 && < 0.6,
+    graph-rewriting-gl >= 0.7.6 && < 0.8,
+    graph-rewriting-strategies >= 0.2.4 && < 0.3,
+    mtl >= 1.1 && < 2.3,
     parsec >= 3.1 && < 3.2,
-    GLUT >= 2.2 && < 2.8,
-    OpenGL >= 3.0 && < 3.1,
-    IndentParser >= 0.2 && < 0.3
-  Extensions:
+    GLUT >= 2.2 && < 3,
+    OpenGL >= 3.0 && < 4,
+    indentparser >= 0.1 && < 0.2
+  Default-Extensions:
     UnicodeSyntax
+  Other-Extensions:
     FlexibleInstances
     FlexibleContexts
     MultiParamTypeClasses