diff --git a/.gitignore b/.gitignore
index 5faae9b128d..e8b537fc9ca 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,6 +59,7 @@ release.cmd
 Samples/typescript/out/
 help/RELEASE_NOTES.md
 paket.exe
+paket-files/
 
 # Ignore the Vagrant local directories
 .vagrant/*
diff --git a/build.fsx b/build.fsx
index bf35c08ce0b..c3d7af27253 100644
--- a/build.fsx
+++ b/build.fsx
@@ -149,6 +149,44 @@ Target "Test" (fun _ ->
     |>  xUnit id
 )
 
+Target "Bootstrap" (fun _ ->
+    let buildScript = "build.fsx"
+    let testScript = "testbuild.fsx"
+    // Check if we can build ourself with the new binaries.
+    let test clearCache script =
+        let clear () =
+            // Will make sure the test call actually compiles the script.
+            // Note: We cannot just clean .fake here as it might be locked by the currently executing code :)
+            if Directory.Exists ".fake" then
+                Directory.EnumerateFiles(".fake")
+                  |> Seq.filter (fun s -> (Path.GetFileName s).StartsWith script)
+                  |> Seq.iter File.Delete
+        let executeTarget target =
+            if clearCache then clear ()
+            ExecProcess (fun info ->
+                info.FileName <- "build/FAKE.exe"
+                info.WorkingDirectory <- "."
+                info.Arguments <- sprintf "%s %s -pd" script target) (System.TimeSpan.FromMinutes 3.0)
+
+        let result = executeTarget "PrintColors"
+        if result <> 0 then failwith "Bootstrapping failed"
+
+        let result = executeTarget "FailFast"
+        if result = 0 then failwith "Bootstrapping failed"
+
+    // Replace the include line to use the newly build FakeLib, otherwise things will be weird.
+    File.ReadAllText buildScript
+    |> fun s -> s.Replace("#I @\"packages/build/FAKE/tools/\"", "#I @\"build/\"")
+    |> fun text -> File.WriteAllText(testScript, text)
+
+    try
+      // Will compile the script.
+      test true testScript
+      // Will use the compiled/cached version.
+      test false testScript
+    finally File.Delete(testScript)
+)
+
 Target "SourceLink" (fun _ ->
     !! "src/app/**/*.fsproj" 
     |> Seq.iter (fun f ->
@@ -287,7 +325,18 @@ Target "Release" (fun _ ->
     Branches.tag "" release.NugetVersion
     Branches.pushTag "" "origin" release.NugetVersion
 )
-
+open System
+Target "PrintColors" (fun s ->
+  let color (color: ConsoleColor) (code : unit -> _) =
+      let before = Console.ForegroundColor
+      try
+        Console.ForegroundColor <- color
+        code ()
+      finally
+        Console.ForegroundColor <- before
+  color ConsoleColor.Magenta (fun _ -> printfn "TestMagenta")
+)
+Target "FailFast" (fun _ -> failwith "fail fast")
 Target "Default" DoNothing
 
 // Dependencies
@@ -296,6 +345,7 @@ Target "Default" DoNothing
     ==> "BuildSolution"
     //==> "ILRepack"
     ==> "Test"
+    ==> "Bootstrap"
     ==> "Default"
     ==> "CopyLicense"
     =?> ("GenerateDocs", isLocalBuild && not isLinux)
diff --git a/paket.dependencies b/paket.dependencies
index c4220e83584..497d4b52e1d 100644
--- a/paket.dependencies
+++ b/paket.dependencies
@@ -38,6 +38,8 @@ nuget FluentMigrator.Runner
 nuget HashLib
 nuget FSharp.Compiler.Service
 
+github matthid/Yaaf.FSharp.Scripting src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs
+
 group Build
 content: none
 source http://nuget.org/api/v2
diff --git a/paket.lock b/paket.lock
index 430dbf72bcb..34c0289a47f 100644
--- a/paket.lock
+++ b/paket.lock
@@ -81,7 +81,10 @@ NUGET
     xunit.extensions (1.9.2)
       xunit (1.9.2)
     xunit.runners (1.9.2)
-
+GITHUB
+  remote: matthid/Yaaf.FSharp.Scripting
+  specs:
+    src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs (48789eeb63382a6934966472e270e87880cb49ed)
 GROUP Build
 CONTENT: NONE
 NUGET
diff --git a/src/app/FAKE/Program.fs b/src/app/FAKE/Program.fs
index e93d1262128..1c5550d16f3 100644
--- a/src/app/FAKE/Program.fs
+++ b/src/app/FAKE/Program.fs
@@ -55,7 +55,9 @@ try
         | Choice1Of2(fakeArgs) ->
             
             //Break to allow a debugger to be attached here
-            if fakeArgs.Contains <@ Cli.Break @> then Diagnostics.Debugger.Break()
+            if fakeArgs.Contains <@ Cli.Break @> then
+                Diagnostics.Debugger.Launch() |> ignore
+                Diagnostics.Debugger.Break() |> ignore
 
             //Boot and version force us to ignore other args, so check for them and handle.
             let isBoot, bootArgs = fakeArgs.Contains <@ Cli.Boot @>, fakeArgs.GetResults <@ Cli.Boot @>
@@ -162,3 +164,5 @@ try
 
 finally
     traceEndBuild()
+    if !TargetHelper.ExitCode.exitCode <> 0 then exit !TargetHelper.ExitCode.exitCode
+    if Environment.ExitCode <> 0 then exit Environment.ExitCode
\ No newline at end of file
diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/FSIHelper.fs
index 9886f532f3a..507a044f5b3 100644
--- a/src/app/FakeLib/FSIHelper.fs
+++ b/src/app/FakeLib/FSIHelper.fs
@@ -9,6 +9,7 @@ open System.Diagnostics
 open System.Threading
 open System.Text.RegularExpressions
 open System.Xml.Linq
+open Yaaf.FSharp.Scripting
 
 let private FSIPath = @".\tools\FSharp\;.\lib\FSharp\;[ProgramFilesX86]\Microsoft SDKs\F#\4.0\Framework\v4.0;[ProgramFilesX86]\Microsoft SDKs\F#\3.1\Framework\v4.0;[ProgramFilesX86]\Microsoft SDKs\F#\3.0\Framework\v4.0;[ProgramFiles]\Microsoft F#\v4.0\;[ProgramFilesX86]\Microsoft F#\v4.0\;[ProgramFiles]\FSharp-2.0.0.0\bin\;[ProgramFilesX86]\FSharp-2.0.0.0\bin\;[ProgramFiles]\FSharp-1.9.9.9\bin\;[ProgramFilesX86]\FSharp-1.9.9.9\bin\"
 
@@ -203,59 +204,34 @@ type private AssemblySource =
 | Disk
 
 let hashRegex = Text.RegularExpressions.Regex("(?<script>.+)_(?<hash>[a-zA-Z0-9]+\.dll$)", System.Text.RegularExpressions.RegexOptions.Compiled)
-/// Run the given FAKE script with fsi.exe at the given working directory. Provides full access to Fsi options and args. Redirect output and error messages.
-let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(fsiOptions, scriptPath, scriptArgs)) env onErrMsg onOutMsg useCache cleanCache =
-
-    if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
-
-    // Add arguments to the Environment
-    for (k,v) in env do
-      Environment.SetEnvironmentVariable(k, v, EnvironmentVariableTarget.Process)
 
-    // Create an env var that only contains the build script args part from the --fsiargs (or "").
-    Environment.SetEnvironmentVariable("fsiargs-buildscriptargs", String.Join(" ", scriptArgs))
-
-    let fsiConfig = FsiEvaluationSession.GetDefaultConfiguration()
-
-    let options =
-        [ "fsi.exe"; "--noninteractive" ] @ fsiOptions
-        |> List.toArray
-
-    let sbOut = Text.StringBuilder()
-    let sbErr = Text.StringBuilder()
-    let handleMessages() =
-        let handleMessagesFrom (sb:Text.StringBuilder) onMsg =
-            let s = sb.ToString()
-            if not <| String.IsNullOrEmpty s
-                then onMsg s
-        handleMessagesFrom sbOut onOutMsg
-        handleMessagesFrom sbErr onErrMsg
-    let handleException (ex : Exception) = 
-        onErrMsg (ex.ToString())
-
-    use outStream = new StringWriter(sbOut)
-    use errStream = new StringWriter(sbErr)
-    use stdin = new StreamReader(Stream.Null)
-
-    let scriptPath =
-        if Path.IsPathRooted scriptPath then
-            scriptPath
-        else
-            Path.Combine(Directory.GetCurrentDirectory(), scriptPath)
-        
+type private CacheInfo =
+  {
+    ScriptFileName : string
+    ScriptHash : string
+    AssemblyPath : string
+    AssemblyWarningsPath : string
+    CacheConfigPath : string
+    CacheConfig : Lazy<Cache.CacheConfig>
+    IsValid : bool
+  }
+
+let private getCacheInfoFromScript printDetails fsiOptions scriptPath =
     let allScriptContents = getAllScripts scriptPath
-    let scriptHash = lazy (getScriptHash allScriptContents fsiOptions)
+    let scriptHash = getScriptHash allScriptContents fsiOptions
     //TODO this is only calculating the hash for the input file, not anything #load-ed
     
-    let scriptFileName = lazy(Path.GetFileName(scriptPath))
-    let hashPath = lazy("./.fake/" + scriptFileName.Value + "_" + scriptHash.Value)
-    let assemblyPath = lazy(hashPath.Value + ".dll")
-    let cacheConfigPath = lazy(hashPath.Value + "_config.xml")
-    let cacheConfig = lazy(Cache.read cacheConfigPath.Value)
-    let cacheValid = lazy (
+    let scriptFileName = Path.GetFileName(scriptPath)
+    let hashPath = "./.fake/" + scriptFileName + "_" + scriptHash
+    let assemblyPath = hashPath + ".dll"
+    let assemblyWarningsPath = hashPath + "_warnings.txt"
+    let cacheConfigPath = hashPath + "_config.xml"
+    let cacheConfig = lazy Cache.read cacheConfigPath
+    let cacheValid =
         let cacheFilesExist = 
-            System.IO.File.Exists(assemblyPath.Value) &&
-            System.IO.File.Exists(cacheConfigPath.Value) 
+            File.Exists(assemblyPath) &&
+            File.Exists(cacheConfigPath) &&
+            File.Exists(assemblyWarningsPath)
         if cacheFilesExist then
             let loadedAssemblies =
                 cacheConfig.Value.Assemblies
@@ -302,37 +278,89 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
             assemVersionValidCount = Seq.length cacheConfig.Value.Assemblies
         else
             false
-    )
+    { ScriptFileName = scriptFileName
+      ScriptHash = scriptHash
+      AssemblyPath = assemblyPath
+      AssemblyWarningsPath = assemblyWarningsPath
+      CacheConfigPath = cacheConfigPath
+      CacheConfig = cacheConfig
+      IsValid = cacheValid }
+
+/// Run the given FAKE script with fsi.exe at the given working directory. Provides full access to Fsi options and args. Redirect output and error messages.
+let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(fsiOptions, scriptPath, scriptArgs)) env onErrMsg onOutMsg useCache cleanCache =
 
+    if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
+
+    // Add arguments to the Environment
+    for (k,v) in env do
+      Environment.SetEnvironmentVariable(k, v, EnvironmentVariableTarget.Process)
+
+    // Create an env var that only contains the build script args part from the --fsiargs (or "").
+    Environment.SetEnvironmentVariable("fsiargs-buildscriptargs", String.Join(" ", scriptArgs))
+
+    let options =
+        fsiOptions
+        |> FsiOptions.ofArgs
+
+    let handleException (ex : Exception) =
+        traceError (ex.ToString())
+
+    let scriptPath =
+        if Path.IsPathRooted scriptPath then
+            scriptPath
+        else
+            Path.Combine(Directory.GetCurrentDirectory(), scriptPath)
+
+    let cacheInfo = getCacheInfoFromScript printDetails fsiOptions scriptPath
     let getScriptAndHash fileName =
         let matched = hashRegex.Match(fileName)
         matched.Groups.Item("script").Value, matched.Groups.Item("hash").Value
 
-    if useCache && cacheValid.Value then
-        
+    let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
+    use out = ScriptHost.CreateForwardWriter onOutMsg
+    use err = ScriptHost.CreateForwardWriter onErrMsg
+    if useCache && cacheInfo.IsValid then
         if printDetails then trace "Using cache"
-        let noExtension = Path.GetFileNameWithoutExtension(scriptFileName.Value)
-        let fullName = 
-            sprintf "<StartupCode$FSI_0001>.$FSI_0001_%s%s$%s" 
-                (noExtension.Substring(0, 1).ToUpper())
-                (noExtension.Substring(1))
-                (Path.GetExtension(scriptFileName.Value).Substring(1))
-
-        let assembly = Reflection.Assembly.LoadFrom(assemblyPath.Value)
-
-        let mainModule = assembly.GetType(fullName)
-        
+        let noExtension = Path.GetFileNameWithoutExtension(cacheInfo.ScriptFileName)
+
+        let startString = "<StartupCode$FSI_"
+        let endString =
+          sprintf "_%s%s$%s"
+            (noExtension.Substring(0, 1).ToUpper())
+            (noExtension.Substring(1))
+            (Path.GetExtension(cacheInfo.ScriptFileName).Substring(1))
+        let fullName i = sprintf "%s%s>.$FSI_%s%s" startString i i endString
+        let exampleName = fullName "0001"
+        let parseName (n:string) =
+            if n.Length >= exampleName.Length &&
+               n.Substring(0, startString.Length) = startString &&
+               n.Substring(n.Length - endString.Length) = endString then
+                let num = n.Substring(startString.Length, 4)
+                assert (fullName num = n)
+                Some (num)
+            else None
         try
-            let _result = 
-                mainModule.InvokeMember(
-                    "main@",
-                    BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static, 
-                    null, null, [||])
-            true
-        with
-        | ex ->
-            handleException ex
-            false
+            Yaaf.FSharp.Scripting.Helper.consoleCapture out err (fun () ->
+                let ass = Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
+                match ass.GetTypes()
+                      |> Seq.filter (fun t -> parseName t.FullName |> Option.isSome)
+                      |> Seq.tryHead with
+                | Some mainModule ->
+                  try mainModule.InvokeMember(
+                          "main@",
+                          BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static,
+                          null, null, [||])
+                      |> ignore
+                      true
+                  with
+                  | ex ->
+                      handleException ex
+                      false
+                | None -> failwithf "We could not find a type similar to '%s' in the cached assembly!" exampleName)
+        finally
+            try
+                traceFAKE "%s" (File.ReadAllText cacheInfo.AssemblyWarningsPath)
+            with e -> handleException e
     else
         let cacheDir = DirectoryInfo(Path.Combine(".",".fake"))
         if useCache then
@@ -341,7 +369,7 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                     cacheDir.GetFiles()
                     |> Seq.filter(fun file -> 
                         let oldScriptName, _ = getScriptAndHash(file.Name)
-                        oldScriptName = scriptFileName.Value)
+                        oldScriptName = cacheInfo.ScriptFileName)
 
                 if (oldFiles |> Seq.length) > 0 then
                     if cleanCache then
@@ -352,93 +380,139 @@ let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails (FsiArgs(f
                     if printDetails then trace "Cache doesn't exist"
             else
                 if printDetails then trace "Cache doesn't exist"
+
+        // Contains warnings and errors about the build script.
+        let fsiErrorOutput = new System.Text.StringBuilder()
+        let session =
+          try ScriptHost.Create
+                (options, preventStdOut = true,
+                  fsiErrWriter = ScriptHost.CreateForwardWriter
+                    ((fun s ->
+                        if String.IsNullOrWhiteSpace s |> not then
+                            fsiErrorOutput.AppendLine s |> ignore),
+                      removeNewLines = true),
+                  outWriter = out,
+                  errWriter = err)
+          with :? FsiEvaluationException as e ->
+              traceError "FsiEvaluationSession could not be created."
+              traceError e.Result.Error.Merged
+              reraise ()
+
         try
-            let session = FsiEvaluationSession.Create(fsiConfig, options, stdin, outStream, errStream)
             try
                 session.EvalScript scriptPath
+                true
+            with :? FsiEvaluationException as eval ->
+                // Write Script Warnings & Errors at the end
+                handleException eval
+                false
+        finally
+            // Write Script Warnings & Errors at the end
+            traceFAKE "%O" fsiErrorOutput
+            // Cache in the error case as well.
+            try
+                if useCache && not cacheInfo.IsValid then
+                    let d = session.DynamicAssemblyBuilder
+                    let name = "FSI-ASSEMBLY"
+                    d.Save(name + ".dll")
+                    if not <| Directory.Exists cacheDir.FullName then
+                        let di = Directory.CreateDirectory cacheDir.FullName
+                        di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
 
-                try
-                    if useCache && not cacheValid.Value then
-                        let assemBuilder = session.DynamicAssembly :?> System.Reflection.Emit.AssemblyBuilder
-                        assemBuilder.Save("FSI-ASSEMBLY.dll")
-                        if not <| Directory.Exists cacheDir.FullName then
-                            let di = Directory.CreateDirectory cacheDir.FullName 
-                            di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
-
-                        let destinationFile = FileInfo(assemblyPath.Value)
-                        let targetDirectory = destinationFile.Directory
+                    let destinationFile = FileInfo(cacheInfo.AssemblyPath)
+                    let targetDirectory = destinationFile.Directory
 
-                        if (not <| targetDirectory.Exists) then targetDirectory.Create()
-                        if (destinationFile.Exists) then destinationFile.Delete()
+                    if (not <| targetDirectory.Exists) then targetDirectory.Create()
+                    if (destinationFile.Exists) then destinationFile.Delete()
 
-                        File.Move("FSI-ASSEMBLY.dll", assemblyPath.Value)
-                    
-                        if File.Exists("FSI-ASSEMBLY.pdb") then
-                            File.Delete("FSI-ASSEMBLY.pdb")
-                        if File.Exists("FSI-ASSEMBLY.dll.mdb") then
-                            File.Delete("FSI-ASSEMBLY.dll.mdb")
+                    File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
 
-                        let dynamicAssemblies = 
+                    try
+                        // Now we change the AssemblyName of the written Assembly via Mono.Cecil.
+                        // Strictly speaking this is not needed, however this helps with executing
+                        // the test suite, as the runtime will only load a single
+                        // FSI-ASSEMBLY with version 0.0.0.0 by using LoadFrom...
+                        let reader = new Mono.Cecil.DefaultAssemblyResolver() // see https://github.com/fsharp/FAKE/issues/1084
+                        reader.AddSearchDirectory (Path.GetDirectoryName TraceHelper.fakePath)
+                        reader.AddSearchDirectory (Path.GetDirectoryName typeof<string option>.Assembly.Location)
+                        let readerParams = new Mono.Cecil.ReaderParameters(AssemblyResolver = reader)
+                        let asem = Mono.Cecil.AssemblyDefinition.ReadAssembly(name + ".dll", readerParams)
+                        asem.Name <- new Mono.Cecil.AssemblyNameDefinition(wishName, new Version(0,0,1))
+                        asem.Write(wishName + ".dll")
+                        File.Move(wishName + ".dll", cacheInfo.AssemblyPath)
+                    with exn ->
+                        // If cecil fails we might want to trigger a warning, but you know what?
+                        // we can continue using the FSI-ASSEMBLY.dll
+                        traceFAKE "Warning (please open an issue on FAKE and /cc @matthid): %O" exn
+                        File.Move(name + ".dll", cacheInfo.AssemblyPath)
+
+                    for name in [ name; wishName ] do
+                        for ext in [ ".dll"; ".pdb"; ".dll.mdb" ] do
+                            if File.Exists(name + ext) then
+                                File.Delete(name + ext)
+
+                    let dynamicAssemblies =
+                        System.AppDomain.CurrentDomain.GetAssemblies()
+                        |> Seq.filter(fun assem -> assem.IsDynamic)
+                        |> Seq.map(fun assem -> assem.GetName().Name)
+                        |> Seq.filter(fun assem -> assem <> "FSI-ASSEMBLY")
+                        |> Seq.filter(fun assem -> assem.StartsWith "FAKE_CACHE_")
+                        // General Reflection.Emit helper (most likely harmless to ignore)
+                        |> Seq.filter(fun assem -> assem <> "Anonymously Hosted DynamicMethods Assembly")
+                        // RazorEngine generated
+                        |> Seq.filter(fun assem -> assem <> "RazorEngine.Compilation.ImpromptuInterfaceDynamicAssembly")
+                        |> Seq.cache
+                    if dynamicAssemblies |> Seq.length > 0 then
+                        let msg =
+                            sprintf "Dynamic assemblies were generated during evaluation of script (%s).\nCan not save cache."
+                                (System.String.Join(", ", dynamicAssemblies))
+                        trace msg
+
+                    else
+                        let assemblies =
                             System.AppDomain.CurrentDomain.GetAssemblies()
-                            |> Seq.filter(fun assem -> assem.IsDynamic)
-                            |> Seq.map(fun assem -> assem.GetName().Name)
-                            |> Seq.filter(fun assem -> assem <> "FSI-ASSEMBLY")
-                            // General Reflection.Emit helper (most likely harmless to ignore)
-                            |> Seq.filter(fun assem -> assem <> "Anonymously Hosted DynamicMethods Assembly")
-                            // RazorEngine generated
-                            |> Seq.filter(fun assem -> assem <> "RazorEngine.Compilation.ImpromptuInterfaceDynamicAssembly")
-                            |> Seq.cache
-                        if dynamicAssemblies |> Seq.length > 0 then
-                            let msg =
-                                sprintf "Dynamic assemblies were generated during evaluation of script (%s).\nCan not save cache." 
-                                    (System.String.Join(", ", dynamicAssemblies))
-                            trace msg
-
-                        else
-                            let assemblies = 
-                                System.AppDomain.CurrentDomain.GetAssemblies()
-                                |> Seq.filter(fun assem -> not assem.IsDynamic)
-                                // They are not dynamic, but can't be re-used either.
-                                |> Seq.filter(fun assem -> not <| assem.GetName().Name.StartsWith("CompiledRazorTemplates.Dynamic.RazorEngine_"))
+                            |> Seq.filter(fun assem -> not assem.IsDynamic)
+                            |> Seq.filter(fun assem -> assem.GetName().Name.StartsWith "FAKE_CACHE_")
+                            // They are not dynamic, but can't be re-used either.
+                            |> Seq.filter(fun assem -> not <| assem.GetName().Name.StartsWith("CompiledRazorTemplates.Dynamic.RazorEngine_"))
                         
-                            let cacheConfig : XDocument = Cache.create assemblies
-                            cacheConfig.Save(cacheConfigPath.Value) 
-                            if printDetails then trace (System.Environment.NewLine + "Saved cache")
-                with 
-                | ex ->
-                    handleException ex
-                    reraise()
-                // TODO: Reactivate when FCS don't show output any more 
-                // handleMessages()
-                true
-            with
-            | _ex ->
-                handleMessages()
-                false
-        with
-        | exn ->
-            traceError "FsiEvaluationSession could not be created."
-            traceError <| sbErr.ToString()
-            raise exn
+                        let cacheConfig : XDocument = Cache.create assemblies
+                        cacheConfig.Save(cacheInfo.CacheConfigPath)
+                        if printDetails then trace (System.Environment.NewLine + "Saved cache")
+            with ex ->
+                // Caching errors are not critical, and we shouldn't throw in a finally clause.
+                traceFAKE "CACHING ERROR (please open a issue on FAKE and /cc @matthid): %O" ex
+                if File.Exists cacheInfo.AssemblyWarningsPath then
+                    // Invalidates the cache
+                    try File.Delete cacheInfo.AssemblyWarningsPath with _ -> ()
+
+let internal onMessage isError =
+    let printer = if isError && TraceListener.importantMessagesToStdErr then eprintf else printf
+    printer "%s"
 
 /// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
-let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
+let executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script (scriptArgs: string[]) (fsiArgs:string[]) useCache cleanCache =
     let messages = ref []
     let appendMessage isError msg =
+        onMessage isError msg // For the tests to be more realistic
         messages := { IsError = isError
                       Message = msg
                       Timestamp = DateTimeOffset.UtcNow } :: !messages
     let result =
         runFAKEScriptWithFsiArgsAndRedirectMessages
-            true (FsiArgs([], script, scriptArgs |> List.ofArray)) []
+            true (FsiArgs(fsiArgs |> List.ofArray, script, scriptArgs |> List.ofArray)) []
             (appendMessage true) (appendMessage false) useCache cleanCache
-    (result, !messages)
+    (result, !messages |> List.rev)
+
+/// Run the given buildscript with fsi.exe and allows for extra arguments to the script. Returns output.
+let executeBuildScriptWithArgsAndReturnMessages script (scriptArgs: string[]) useCache cleanCache =
+    executeBuildScriptWithArgsAndFsiArgsAndReturnMessages script scriptArgs [||] useCache cleanCache
 
 /// Run the given buildscript with fsi.exe at the given working directory.  Provides full access to Fsi options and args.
 let runBuildScriptWithFsiArgsAt printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env useCache cleanCache =
     runFAKEScriptWithFsiArgsAndRedirectMessages
         printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env
-        traceError (fun s-> traceFAKE "%s" s)
+        (onMessage true) (onMessage false)
         useCache
         cleanCache
 
diff --git a/src/app/FakeLib/FakeLib.fsproj b/src/app/FakeLib/FakeLib.fsproj
index 48118664736..b4f40b7e3d4 100644
--- a/src/app/FakeLib/FakeLib.fsproj
+++ b/src/app/FakeLib/FakeLib.fsproj
@@ -16,7 +16,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug</OutputPath>
-    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>
@@ -30,12 +30,16 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>..\..\..\build\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;NET40</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>3</WarningLevel>
     <DocumentationFile>..\..\..\build\FakeLib.XML</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="..\..\..\paket-files\matthid\Yaaf.FSharp.Scripting\src\source\Yaaf.FSharp.Scripting\YaafFSharpScripting.fs">
+      <Paket>True</Paket>
+      <Link>paket-files/YaafFSharpScripting.fs</Link>
+    </Compile>
     <Compile Include="AssemblyInfo.fs" />
     <Compile Include="UserInputHelper.fs" />
     <Compile Include="CSharpHelper.fs" />
diff --git a/src/app/FakeLib/TargetHelper.fs b/src/app/FakeLib/TargetHelper.fs
index 8bcf63396b6..8c4fb7d2e8f 100644
--- a/src/app/FakeLib/TargetHelper.fs
+++ b/src/app/FakeLib/TargetHelper.fs
@@ -278,7 +278,6 @@ let targetError targetName (exn:System.Exception) =
         | _ -> exn.ToString()
 
     let msg = sprintf "%s%s" (error exn) (if exn.InnerException <> null then "\n" + (exn.InnerException |> error) else "")
-            
     traceError <| sprintf "Running build failed.\nError:\n%s" msg
 
     let isFailedTestsException = exn :? UnitTestCommon.FailedTestsException
@@ -427,7 +426,9 @@ let WriteTaskTimeSummary total =
 
     traceLine()
 
-let private changeExitCodeIfErrorOccured() = if errors <> [] then exit 42 
+module ExitCode =
+    let exitCode = ref 0
+let private changeExitCodeIfErrorOccured() = if errors <> [] then Environment.ExitCode <- 42; ExitCode.exitCode := 42
    
 /// [omit]
 let isListMode = hasBuildParam "list"
diff --git a/src/app/FakeLib/TraceListener.fs b/src/app/FakeLib/TraceListener.fs
index a0385c3492c..404dde81f58 100644
--- a/src/app/FakeLib/TraceListener.fs
+++ b/src/app/FakeLib/TraceListener.fs
@@ -14,6 +14,26 @@ type TraceData =
     | FinishedMessage
     | OpenTag of string * string
     | CloseTag of string
+    member x.NewLine =
+        match x with
+        | ImportantMessage _
+        | ErrorMessage _ -> Some true
+        | LogMessage (_, newLine)
+        | TraceMessage (_, newLine) -> Some newLine
+        | StartMessage
+        | FinishedMessage
+        | OpenTag _
+        | CloseTag _ -> None
+    member x.Message =
+        match x with
+        | ImportantMessage text
+        | ErrorMessage text
+        | LogMessage (text, _)
+        | TraceMessage (text, _) -> Some text
+        | StartMessage
+        | FinishedMessage
+        | OpenTag _
+        | CloseTag _ -> None
 
 /// Defines a TraceListener interface
 type ITraceListener = 
@@ -37,13 +57,17 @@ type ConsoleTraceListener(importantMessagesToStdErr, colorMap) =
     
     let writeText toStdErr color newLine text = 
         let curColor = Console.ForegroundColor
-        if curColor <> color then Console.ForegroundColor <- color
-        if toStdErr then 
-            if newLine then eprintfn "%s" text
-            else eprintf "%s" text
-        else if newLine then printfn "%s" text
-        else printf "%s" text
-        if curColor <> color then Console.ForegroundColor <- curColor
+        try
+          if curColor <> color then Console.ForegroundColor <- color
+          let printer =
+            match toStdErr, newLine with
+            | true, true -> eprintfn
+            | true, false -> eprintf
+            | false, true -> printfn
+            | false, false -> printf
+          printer "%s" text
+        finally
+          if curColor <> color then Console.ForegroundColor <- curColor
     
     interface ITraceListener with
         /// Writes the given message to the Console.
@@ -53,14 +77,18 @@ type ConsoleTraceListener(importantMessagesToStdErr, colorMap) =
             | StartMessage -> ()
             | OpenTag _ -> ()
             | CloseTag _ -> ()
-            | ImportantMessage text | ErrorMessage text -> writeText importantMessagesToStdErr color true text
-            | LogMessage(text, newLine) | TraceMessage(text, newLine) -> writeText false color newLine text
+            | ImportantMessage text | ErrorMessage text ->
+                writeText importantMessagesToStdErr color true text
+            | LogMessage(text, newLine) | TraceMessage(text, newLine) ->
+                writeText false color newLine text
             | FinishedMessage -> ()
 
+// If we write the stderr on those build servers the build will fail.
+let importantMessagesToStdErr = buildServer <> CCNet && buildServer <> AppVeyor
+
 /// The default TraceListener for Console.
 let defaultConsoleTraceListener =
-  // If we write the stderr on those build servers the build will fail.
-  ConsoleTraceListener(buildServer <> CCNet && buildServer <> AppVeyor, colorMap)
+  ConsoleTraceListener(importantMessagesToStdErr, colorMap)
 
 /// Specifies if the XmlWriter should close tags automatically
 let mutable AutoCloseXmlWriter = false
diff --git a/src/app/FakeLib/UserInputHelper.fs b/src/app/FakeLib/UserInputHelper.fs
index 235c4388dc5..64034699e0f 100644
--- a/src/app/FakeLib/UserInputHelper.fs
+++ b/src/app/FakeLib/UserInputHelper.fs
@@ -38,10 +38,11 @@ let internal readString (echo: bool) : string =
 
 let internal color (color: ConsoleColor) (code : unit -> _) =
     let before = Console.ForegroundColor
-    Console.ForegroundColor <- color
-    let result = code ()
-    Console.ForegroundColor <- before
-    result
+    try
+      Console.ForegroundColor <- color
+      code ()
+    finally
+      Console.ForegroundColor <- before
     
 /// Return a string entered by the user followed by enter. The input is echoed to the screen.
 let getUserInput prompt =
diff --git a/src/app/FakeLib/paket.references b/src/app/FakeLib/paket.references
index 5bb6c8e93a7..d34763987b0 100644
--- a/src/app/FakeLib/paket.references
+++ b/src/app/FakeLib/paket.references
@@ -1,3 +1,4 @@
+File: YaafFSharpScripting.fs
 FSharp.Core
 FSharp.Compiler.Service
 Mono.Web.Xdt
diff --git a/src/test/Test.FAKECore/FSIHelperSpecs.cs b/src/test/Test.FAKECore/FSIHelperSpecs.cs
index 581e3743d54..acf4f6952ea 100644
--- a/src/test/Test.FAKECore/FSIHelperSpecs.cs
+++ b/src/test/Test.FAKECore/FSIHelperSpecs.cs
@@ -5,25 +5,60 @@
 using System.IO;
 using Fake;
 using Machine.Specifications;
+using Messages = Microsoft.FSharp.Collections.FSharpList<Fake.ProcessHelper.ConsoleMessage>;
 
 namespace Test.FAKECore
 {
     public class when_running_script
     {
+        class MyTracer : Fake.TraceListener.ITraceListener
+        {
+            StringBuilder builder;
+            public MyTracer(StringBuilder builder)
+            {
+                this.builder = builder;
+            }
+
+            public void Write(TraceListener.TraceData value)
+            {
+                if (value.Message != null)
+                {
+                    builder.Append(value.Message.Value);
+                }
+
+                if (value.NewLine != null)
+                {
+                    builder.AppendLine();
+                }
+            }
+
+            public override string ToString() { return builder.ToString(); }
+        }
+
+        static string[] EmptyArgs = new string[0];
+
+        static Messages IgnoreDateTimeOffset(Messages msgs)
+        {
+            // We don't care about the datetimeoffset.
+            var mapFunc = FSharpFuncUtil.ToFSharpFunc<Fake.ProcessHelper.ConsoleMessage, Fake.ProcessHelper.ConsoleMessage>(cm =>
+                new ProcessHelper.ConsoleMessage(cm.IsError, cm.Message, new DateTimeOffset()));
+            return Microsoft.FSharp.Collections.ListModule.Map(mapFunc, msgs);
+        }
 
-        static string RunExplicit(string scriptFilePath, string arguments, bool useCache)
+        static Tuple<Messages, string> RunExplicit(string scriptFilePath, string[] scriptArguments, string[] fsiArguments, bool useCache)
         {
             var stdOut = Console.Out;
 
             var sbOut = new System.Text.StringBuilder();
             var outStream = new StringWriter(sbOut);
             Console.SetOut(outStream);
-            Tuple<bool, Microsoft.FSharp.Collections.FSharpList<ProcessHelper.ConsoleMessage>> result;
-            
+            Tuple<bool, Messages> result;
+
             try
             {
-                
-                result = FSIHelper.executeBuildScriptWithArgsAndReturnMessages(scriptFilePath, new string[] { }, useCache, false);
+
+                result = FSIHelper.executeBuildScriptWithArgsAndFsiArgsAndReturnMessages(
+                    scriptFilePath, scriptArguments, fsiArguments, useCache, false);
             }
             finally
             {
@@ -41,21 +76,26 @@ static string RunExplicit(string scriptFilePath, string arguments, bool useCache
             {
                 Console.WriteLine(x.Message);
             }
-            var messages = result.Item2.Where(x => !x.IsError).Select(x => x.Message);
-            return 
+
+            return Tuple.Create(result.Item2,
                 sbOut.ToString()
                 .Replace("Running Buildscript: " + scriptFilePath, "")
-                .Replace("\n", "").Replace("\r", "");
+                .Replace("\n", "").Replace("\r", ""));
+        }
+
+        static string RunExplicit(string scriptFilePath, string[] scriptArguments, bool useCache)
+        {
+            return RunExplicit(scriptFilePath, scriptArguments, EmptyArgs, useCache).Item2;
         }
 
-        static string Run(string script, string arguments, bool useCache)
+        static string Run(string script, string[] scriptArguments, bool useCache)
         {
             var scriptFilePath = Path.GetTempFileName() + ".fsx";
             string result;
             try
             {
                 File.WriteAllText(scriptFilePath, script);
-                result = RunExplicit(scriptFilePath, arguments, useCache);
+                result = RunExplicit(scriptFilePath, scriptArguments, useCache);
             }
             finally
             {
@@ -72,10 +112,147 @@ static FSIHelper.Script script(string path, string contents)
             return new FSIHelper.Script(contents, path.Replace("\\", "/"), null, null);
         }
 
+        It caching_and_non_caching_version_should_handle_stderr_and_stdout_equally =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "printf \"stdout\"; eprintf \"stderr\"");
+                    // without cache
+                    var res1 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res1.Item2.ShouldStartWith("Cache doesn't exist");
+
+                    // with cache
+                    var res2 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res2.Item2.ShouldStartWith("Using cache");
+
+                    Microsoft.FSharp.Core.Operators.op_Equality(IgnoreDateTimeOffset(res1.Item1), IgnoreDateTimeOffset(res2.Item1))
+                        .ShouldBeTrue();
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
+        It tracing_functions_should_work =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                var t = new MyTracer(new StringBuilder());
+                try
+                {
+                    var fakeLib = typeof(TraceListener).Assembly.Location;
+                    TraceListener.listeners.Add(t);
+                    {
+                        File.WriteAllText(scriptFilePath, @"
+#r """ + fakeLib.Replace(@"\", @"\\") + @"""
+open Fake
+traceFAKE ""TEST_FAKE_OUTPUT""");
+                        RunExplicit(scriptFilePath, EmptyArgs, false);
+                        var result = t.ToString();
+                        var idx = result.IndexOf("TEST_FAKE_OUTPUT");
+                        idx.ShouldBeGreaterThan(-1);
+                        // We should not have it twice
+                        result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                    }
+                    TraceListener.listeners.Remove(t);
+                    t = new MyTracer(new StringBuilder());
+                    TraceListener.listeners.Add(t);
+                    {
+                        File.WriteAllText(scriptFilePath, @"
+#r """ + fakeLib.Replace(@"\", @"\\") + @"""
+open Fake
+trace ""TEST_FAKE_OUTPUT""");
+                        RunExplicit(scriptFilePath, EmptyArgs, false);
+                        var result = t.ToString();
+                        var idx = result.IndexOf("TEST_FAKE_OUTPUT");
+                        idx.ShouldBeGreaterThan(-1);
+                        // We should not have it twice
+                        result.Substring(idx + "TEST_FAKE_OUTPUT".Length).ShouldNotContain("TEST_FAKE_OUTPUT");
+                    }
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                    TraceListener.listeners.Remove(t);
+                }
+            };
+
+        It should_be_able_to_use_system_xml =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "open System.Xml");
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
+                        .ShouldEqual("");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
+        It should_be_able_to_use_system_web =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "open System.Web");
+                    RunExplicit(scriptFilePath, EmptyArgs, false)
+                        .ShouldEqual("");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
+        /// <summary>
+        /// See https://github.com/fsharp/FAKE/pull/1080
+        /// </summary>
+        It should_work_with_debug_flag =
+            () =>
+            {
+                var scriptFilePath = Path.GetTempFileName() + ".fsx";
+                var scriptFileName = Path.GetFileName(scriptFilePath);
+                try
+                {
+                    File.WriteAllText(scriptFilePath, "printfn \"test\"");
+                    RunExplicit(
+                        scriptFilePath,
+                        EmptyArgs,
+                        new[] {
+                            "--debug+",
+                            "--optimize-",
+                            "--platform", "AnyCpu",
+                            "--configuration", "Release",
+                            "--csversion", "2007" },
+                        false)
+                        .Item1.Head.Message.ShouldEqual("test");
+                }
+                finally
+                {
+                    if (File.Exists(scriptFilePath))
+                        File.Delete(scriptFilePath);
+                }
+            };
+
         It should_use_then_invalidate_cache =
             () =>
             {
-                var arguments = "";
                 var scriptFilePath = Path.GetTempFileName() + ".fsx";
                 var scriptFileName = Path.GetFileName(scriptFilePath);
                 try
@@ -88,26 +265,32 @@ static FSIHelper.Script script(string path, string contents)
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
-                    RunExplicit(scriptFilePath, arguments, false)
-                       .ShouldEqual("foobar");
+                    RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, false)
+                       .Item1.Head.Message.ShouldEqual("foobar");
 
                     File.Exists(cacheFilePath).ShouldEqual(false);
 
-                    RunExplicit(scriptFilePath, arguments, true)
+                    RunExplicit(scriptFilePath, EmptyArgs, true)
                         .ShouldStartWith("Cache doesn't exist");
 
                     File.Exists(cacheFilePath).ShouldEqual(true);
 
-                    RunExplicit(scriptFilePath, arguments, true)
-                        .ShouldEqual(
-                            ("Using cache" + nl + "foobar")
-                            .Replace("\n", "").Replace("\r", ""));
+                    var res1 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res1.Item2.ShouldStartWith("Using cache");
+                    res1.Item1.Head.Message.ShouldEqual("foobar");
 
                     File.WriteAllText(scriptFilePath, "printf \"foobarbaz\"");
 
                     var changedScriptHash = FSIHelper.getScriptHash(new FSIHelper.Script[] { script(scriptFilePath, "printf \"foobarbaz\"") }, new List<string>());
-                    RunExplicit(scriptFilePath, arguments, true)
-                        .ShouldStartWith("Cache is invalid, recompiling");
+                    var res2 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res2.Item2.ShouldStartWith("Cache is invalid, recompiling");
+                    res2.Item1.Head.Message.ShouldEqual("foobarbaz");
+
+                    // This last test is not strictly needed, but it is a good test to check if we can execute
+                    // multiple caching tests in the same session (see comment in FSIHelper.fs where we use Mono.Cecil to rename the assembly)
+                    var res3 = RunExplicit(scriptFilePath, EmptyArgs, EmptyArgs, true);
+                    res3.Item2.ShouldStartWith("Using cache");
+                    res3.Item1.Head.Message.ShouldEqual("foobarbaz");
 
                     File.Exists("./.fake/" + scriptFileName + "_" + changedScriptHash + ".dll").ShouldEqual(true);
                 }
@@ -132,8 +315,10 @@ static FSIHelper.Script script(string path, string contents)
                     File.WriteAllText(mainPath, mainScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
                     File.WriteAllText(loadedPath, loadedScript.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\r", nl));
 
-                    RunExplicit(mainPath, "", false)
-                        .ShouldEqual("loaded;main");
+                    var res = RunExplicit(mainPath, EmptyArgs, EmptyArgs, false);
+                    res.Item2.ShouldEqual("loaded;main");
+                    res.Item1.Head.Message.ShouldEqual("loaded;");
+                    res.Item1.Tail.Head.Message.ShouldEqual("main");
                 }
                 finally
                 {