diff --git a/src/app/FakeLib/AssemblyInfo.fs b/src/app/Fake.Runtime/AssemblyInfo.fs
similarity index 100%
rename from src/app/FakeLib/AssemblyInfo.fs
rename to src/app/Fake.Runtime/AssemblyInfo.fs
diff --git a/src/app/Fake.Runtime/BuildServer.fs b/src/app/Fake.Runtime/BuildServer.fs
new file mode 100644
index 00000000000..850ce97124e
--- /dev/null
+++ b/src/app/Fake.Runtime/BuildServer.fs
@@ -0,0 +1,112 @@
+/// Contains functions which allow build scripts to interact with a build server.
+module Fake.Runtime.BuildServer
+open Fake.Runtime.Environment
+open Fake.Runtime.String
+
+/// The server type option.
+type BuildServer = 
+    | TeamFoundation
+    | TeamCity
+    | CCNet
+    | Jenkins
+    | Travis
+    | AppVeyor
+    | GitLabCI
+    | Bamboo
+    | BitbucketPipelines
+    | LocalBuild
+
+/// The trace mode option.
+type TraceMode = 
+    | Console
+    | Xml
+
+/// Defines if FAKE will use verbose tracing.
+/// This flag can be specified by setting the *verbose* build parameter.
+let mutable verbose = hasBuildParam "verbose"
+
+/// A constant label for local builds
+/// [omit]            
+let localBuildLabel = "LocalBuild"
+
+/// Defines the XML output file - used for build servers like CruiseControl.NET.
+/// This output file can be specified by using the *logfile* build parameter.
+let mutable xmlOutputFile = getBuildParamOrDefault "logfile" "./output/Results.xml"
+
+/// Build number retrieved from Bamboo
+/// [omit]
+let bambooBuildNumber = environVar "bamboo_buildNumber"
+
+/// Checks if we are on Bamboo
+/// [omit]
+let isBambooBuild =
+    isNotNullOrEmpty bambooBuildNumber
+
+/// Checks if we are on Team Foundation
+/// [omit]
+let isTFBuild =
+    let tfbuild = environVar "TF_BUILD"
+    tfbuild <> null && tfbuild.ToLowerInvariant() = "true"
+
+/// Build number retrieved from Team Foundation
+/// [omit]
+let tfBuildNumber = environVar "BUILD_BUILDNUMBER"
+
+/// Build number retrieved from TeamCity
+/// [omit]
+let tcBuildNumber = environVar "BUILD_NUMBER"
+
+/// Build number retrieved from Travis
+/// [omit]
+let travisBuildNumber = environVar "TRAVIS_BUILD_NUMBER"
+
+/// Checks if we are on GitLab CI
+/// [omit]
+let isGitlabCI = environVar "CI_SERVER_NAME" = "GitLab CI"
+
+/// Build number retrieved from GitLab CI
+/// [omit]
+let gitlabCIBuildNumber = if isGitlabCI then environVar "CI_BUILD_ID" else ""
+
+/// Build number retrieved from Jenkins
+/// [omit]
+let jenkinsBuildNumber = tcBuildNumber
+
+/// CruiseControl.NET Build label
+/// [omit]
+let ccBuildLabel = environVar "CCNETLABEL"
+
+/// AppVeyor build number
+/// [omit]
+let appVeyorBuildVersion = environVar "APPVEYOR_BUILD_VERSION"
+
+/// The current build server
+let buildServer = 
+    if hasBuildParam "JENKINS_HOME" then Jenkins
+    elif hasBuildParam "TEAMCITY_VERSION" then TeamCity
+    elif not (isNullOrEmpty ccBuildLabel) then CCNet
+    elif not (isNullOrEmpty travisBuildNumber) then Travis
+    elif not (isNullOrEmpty appVeyorBuildVersion) then AppVeyor
+    elif isGitlabCI then GitLabCI
+    elif isTFBuild then TeamFoundation
+    elif isBambooBuild then Bamboo
+    elif hasBuildParam "BITBUCKET_COMMIT" then BitbucketPipelines
+    else LocalBuild
+
+/// The current build version as detected from the current build server.
+let buildVersion = 
+    let getVersion = getBuildParamOrDefault "buildVersion"
+    match buildServer with
+    | Jenkins -> getVersion jenkinsBuildNumber
+    | TeamCity -> getVersion tcBuildNumber
+    | CCNet -> getVersion ccBuildLabel
+    | Travis -> getVersion travisBuildNumber
+    | AppVeyor -> getVersion appVeyorBuildVersion
+    | GitLabCI -> getVersion gitlabCIBuildNumber
+    | TeamFoundation -> getVersion tfBuildNumber
+    | Bamboo -> getVersion bambooBuildNumber
+    | LocalBuild -> getVersion localBuildLabel
+    | BitbucketPipelines -> getVersion ""
+
+/// Is true when the current build is a local build.
+let isLocalBuild = LocalBuild = buildServer
diff --git a/src/app/Fake.Runtime/Environment.fs b/src/app/Fake.Runtime/Environment.fs
new file mode 100644
index 00000000000..4e2c3497d19
--- /dev/null
+++ b/src/app/Fake.Runtime/Environment.fs
@@ -0,0 +1,303 @@
+/// This module contains functions which allow to read and write environment variables and build parameters
+module Fake.Runtime.Environment
+type Environment = System.Environment
+
+open System
+open System.IO
+#if !CORE_CLR
+open System.Configuration
+#endif
+open System.Diagnostics
+open System.Collections.Generic
+open System.Text
+open System.Text.RegularExpressions
+open Microsoft.Win32
+
+/// Type alias for System.EnvironmentVariableTarget
+#if !CORE_CLR
+type EnvironTarget = EnvironmentVariableTarget
+#endif
+
+/// Retrieves the environment variable with the given name
+let environVar name = Environment.GetEnvironmentVariable name
+
+/// Combines two path strings using Path.Combine
+let inline combinePaths path1 (path2 : string) = Path.Combine(path1, path2.TrimStart [| '\\'; '/' |])
+/// Combines two path strings using Path.Combine
+let inline combinePathsNoTrim path1 path2 = Path.Combine(path1, path2)
+
+/// Combines two path strings using Path.Combine
+let inline (@@) path1 path2 = combinePaths path1 path2
+/// Combines two path strings using Path.Combine
+let inline (</>) path1 path2 = combinePathsNoTrim path1 path2
+
+// Normalizes path for different OS
+let inline normalizePath (path : string) = 
+    path.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar)
+
+let getCurrentDirectory () =
+    System.IO.Directory.GetCurrentDirectory()
+
+/// Retrieves all environment variables from the given target
+#if !CORE_CLR
+let environVars target = 
+    let vars = Environment.GetEnvironmentVariables target
+#else
+let environVars () = 
+    let vars = Environment.GetEnvironmentVariables ()
+#endif
+    [ for e in vars -> 
+          let e1 = e :?> Collections.DictionaryEntry
+          e1.Key, e1.Value ]
+
+/// Sets the environment variable with the given name
+let setEnvironVar name value = Environment.SetEnvironmentVariable(name, value)
+
+#if !CORE_CLR
+/// Sets the environment variable with the given name for the current user.
+let setUserEnvironVar name value = Environment.SetEnvironmentVariable(name, value, EnvironmentVariableTarget.User)
+
+/// Sets the environment variable with the given name for the current machine.
+let setMachineEnvironVar name value = Environment.SetEnvironmentVariable(name, value, EnvironmentVariableTarget.Machine)
+#endif
+
+/// Sets the environment variable with the given name for the current process.
+#if !CORE_CLR
+let setProcessEnvironVar name value = Environment.SetEnvironmentVariable(name, value, EnvironmentVariableTarget.Process)
+#else
+let setProcessEnvironVar name value = Environment.SetEnvironmentVariable(name, value)
+#endif
+
+/// Clears the environment variable with the given name for the current process.
+#if !CORE_CLR
+let clearProcessEnvironVar name = Environment.SetEnvironmentVariable(name, null, EnvironmentVariableTarget.Process)
+#else
+let clearProcessEnvironVar name = Environment.SetEnvironmentVariable(name, null)
+#endif
+
+/// Sets the build parameter with the given name for the current process.
+let setBuildParam name value = setProcessEnvironVar name value
+
+/// Retrieves the environment variable with the given name or returns the default if no value was set
+let environVarOrDefault name defaultValue = 
+    let var = environVar name
+    if String.IsNullOrEmpty var then defaultValue
+    else var
+
+/// Retrieves the environment variable with the given name or fails if not found
+let environVarOrFail name = 
+    let var = environVar name
+    if String.IsNullOrEmpty var then failwith <| sprintf "Environment variable '%s' not found" name
+    else var
+
+/// Retrieves the environment variable with the given name or returns the default bool if no value was set
+let getEnvironmentVarAsBoolOrDefault varName defaultValue=
+    try  
+        (environVar varName).ToUpper() = "TRUE" 
+    with
+    | _ ->  defaultValue
+
+/// Retrieves the environment variable with the given name or returns the false if no value was set
+let getEnvironmentVarAsBool varName = getEnvironmentVarAsBoolOrDefault varName false
+
+/// Retrieves the environment variable or None
+let environVarOrNone name = 
+    let var = environVar name
+    if String.IsNullOrEmpty var then None
+    else Some var
+
+/// Splits the entries of an environment variable and removes the empty ones.
+let splitEnvironVar name =
+    let var = environVarOrNone name
+    if var = None then [ ]
+    else var.Value.Split([| Path.PathSeparator |]) |> Array.toList
+
+#if !CORE_CLR
+/// Retrieves the application settings variable with the given name
+let appSetting (name : string) = ConfigurationManager.AppSettings.[name]
+#endif
+
+/// Returns if the build parameter with the given name was set
+let inline hasBuildParam name = environVar name <> null
+
+/// Returns the value of the build parameter with the given name if it was set and otherwise the given default value
+let inline getBuildParamOrDefault name defaultParam = 
+    if hasBuildParam name then environVar name
+    else defaultParam
+
+/// Returns the value of the build parameter with the given name if it was set and otherwise an empty string
+let inline getBuildParam name = getBuildParamOrDefault name String.Empty
+
+#if !CORE_CLR
+/// The path of the "Program Files" folder - might be x64 on x64 machine
+let ProgramFiles = Environment.GetFolderPath Environment.SpecialFolder.ProgramFiles
+#endif
+
+/// The path of Program Files (x86)
+/// It seems this covers all cases where PROCESSOR\_ARCHITECTURE may misreport and the case where the other variable 
+/// PROCESSOR\_ARCHITEW6432 can be null
+let ProgramFilesX86 = 
+    let wow64 = environVar "PROCESSOR_ARCHITEW6432"
+    let globalArch = environVar "PROCESSOR_ARCHITECTURE"
+    match wow64, globalArch with
+    | "AMD64", "AMD64" 
+    | null, "AMD64" 
+    | "x86", "AMD64" -> environVar "ProgramFiles(x86)"
+    | _ -> environVar "ProgramFiles"
+    |> fun detected -> if detected = null then @"C:\Program Files (x86)\" else detected
+
+/// The system root environment variable. Typically "C:\Windows"
+let SystemRoot = environVar "SystemRoot"
+
+#if !CORE_CLR
+/// Determines if the current system is an Unix system
+let isUnix = Environment.OSVersion.Platform = PlatformID.Unix
+
+/// Determines if the current system is a MacOs system
+let isMacOS =
+    (Environment.OSVersion.Platform = PlatformID.MacOSX) ||
+      // Running on OSX with mono, Environment.OSVersion.Platform returns Unix
+      // rather than MacOSX, so check for osascript (the AppleScript
+      // interpreter). Checking for osascript for other platforms can cause a
+      // problem on Windows if the current-directory is on a mapped-drive
+      // pointed to a Mac's root partition; e.g., Parallels does this to give
+      // Windows virtual machines access to files on the host.
+      (Environment.OSVersion.Platform = PlatformID.Unix && (File.Exists "/usr/bin/osascript"))
+
+/// Determines if the current system is a Linux system
+let isLinux = (not isMacOS) && (int System.Environment.OSVersion.Platform |> fun p -> (p = 4) || (p = 6) || (p = 128))
+
+/// Determines if the current system is a mono system
+/// Todo: Detect mono on windows
+let isMono = isLinux || isUnix || isMacOS
+
+let monoPath =
+    if isMacOS && File.Exists "/Library/Frameworks/Mono.framework/Commands/mono" then
+        "/Library/Frameworks/Mono.framework/Commands/mono"
+    else
+        "mono"
+
+// Note: The same field is available in the old API, therefore we use a workaround to make the "new" api point to the old field.
+let mutable internal monoArguments = ref ""
+
+let mutable internal monoArgumentsHelper = LegacyApiHelper.ofRef monoArguments
+let getMonoArguments, setMonoArguments = LegacyApiHelper.toGetSet monoArgumentsHelper
+ 
+
+/// Modifies the ProcessStartInfo according to the platform semantics
+let platformInfoAction (psi : ProcessStartInfo) = 
+    if isMono && psi.FileName.EndsWith ".exe" then 
+        psi.Arguments <- getMonoArguments() + " \"" + psi.FileName + "\" " + psi.Arguments
+        psi.FileName <- monoPath
+
+/// The path of the current target platform
+let mutable TargetPlatformPrefix = 
+    let (<|>) a b = 
+        match a with
+        | None -> b
+        | _ -> a
+    environVarOrNone "FrameworkDir32" <|> if (String.IsNullOrEmpty SystemRoot) then None
+                                          else Some(SystemRoot @@ @"Microsoft.NET\Framework") 
+    <|> if (isUnix) then Some "/usr/lib/mono"
+        else Some @"C:\Windows\Microsoft.NET\Framework"
+    |> Option.get
+
+/// Base path for getting tools from windows SDKs
+let sdkBasePath = ProgramFilesX86 @@ "Microsoft SDKs\Windows"
+
+/// Helper function to help find framework or sdk tools from the 
+/// newest toolkit available
+let getNewestTool possibleToolPaths = 
+       possibleToolPaths 
+       |> Seq.sortBy (fun p -> p) 
+       |> Array.ofSeq 
+       |> Array.rev 
+       |> Seq.ofArray 
+       |> Seq.head
+
+/// Gets the local directory for the given target platform
+let getTargetPlatformDir platformVersion = 
+    if Directory.Exists(TargetPlatformPrefix + "64") then (TargetPlatformPrefix + "64") @@ platformVersion
+    else TargetPlatformPrefix @@ platformVersion
+
+/// The path to the personal documents
+let documentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
+#endif
+
+/// The directory separator string. On most systems / or \
+let directorySeparator = Path.DirectorySeparatorChar.ToString()
+
+/// Convert the given windows path to a path in the current system
+let convertWindowsToCurrentPath (windowsPath : string) = 
+    if (windowsPath.Length > 2 && windowsPath.[1] = ':' && windowsPath.[2] = '\\') then windowsPath
+    else windowsPath.Replace(@"\", directorySeparator)
+
+/// Contains the IO encoding which is given via build parameter "encoding" or the default encoding if no encoding was specified.
+let encoding = 
+    match getBuildParamOrDefault "encoding" "default" with
+#if !CORE_CLR
+    | "default" -> Text.Encoding.Default
+#else
+    | "default" -> Text.Encoding.UTF8
+#endif
+    | enc -> Text.Encoding.GetEncoding(enc)
+
+#if !CORE_CLR
+/// Returns a sequence with all installed .NET framework versions
+let getInstalledDotNetFrameworks() = 
+    let frameworks = new ResizeArray<_>()
+    try 
+        let matches = 
+            Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP").GetSubKeyNames() 
+            |> Seq.filter (fun keyname -> Regex.IsMatch(keyname, @"^v\d"))
+        for item in matches do
+            match item with
+            | "v4.0" -> ()
+            | "v4" -> 
+                let key = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\" + item
+                Registry.LocalMachine.OpenSubKey(key).GetSubKeyNames() 
+                |> Seq.iter (fun subkey -> 
+                       let key = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\" + item + @"\" + subkey
+                       let version = Registry.LocalMachine.OpenSubKey(key).GetValue("Version").ToString()
+                       frameworks.Add(String.Format("{0} ({1})", version, subkey)))
+            | "v1.1.4322" -> frameworks.Add item
+            | _ -> 
+                let key = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\" + item
+                frameworks.Add(Registry.LocalMachine.OpenSubKey(key).GetValue("Version").ToString())
+        frameworks :> seq<_>
+    with e -> frameworks :> seq<_> //Probably a new unrecognisable version
+
+/// A record which allows to display lots of machine specific information like machine name, processor count etc.
+type MachineDetails = 
+    { ProcessorCount : int
+      Is64bit : bool
+      OperatingSystem : string
+      MachineName : string
+      NETFrameworks : seq<string>
+      UserDomainName : string
+      AgentVersion : string
+      DriveInfo : seq<string> }
+
+/// Retrieves information about the hard drives
+let getDrivesInfo() = 
+    Environment.GetLogicalDrives()
+    |> Seq.map (fun d -> IO.DriveInfo(d))
+    |> Seq.filter (fun d -> d.IsReady)
+    |> Seq.map 
+           (fun d -> 
+           sprintf "%s has %0.1fGB free of %0.1fGB" (d.Name.Replace(":\\", "")) 
+               (Convert.ToDouble(d.TotalFreeSpace) / (1024. * 1024. * 1024.)) 
+               (Convert.ToDouble(d.TotalSize) / (1024. * 1024. * 1024.)))
+
+/// Retrieves lots of machine specific information like machine name, processor count etc.
+let getMachineEnvironment() = 
+    { ProcessorCount = Environment.ProcessorCount
+      Is64bit = Environment.Is64BitOperatingSystem
+      OperatingSystem = Environment.OSVersion.ToString()
+      MachineName = Environment.MachineName
+      NETFrameworks = getInstalledDotNetFrameworks()
+      UserDomainName = Environment.UserDomainName
+      AgentVersion = 
+          sprintf "%A" ((System.Reflection.Assembly.GetAssembly(typedefof<MachineDetails>)).GetName().Version)
+      DriveInfo = getDrivesInfo() }
+#endif
\ No newline at end of file
diff --git a/src/app/Fake.Runtime/FakeRuntime.fs b/src/app/Fake.Runtime/FakeRuntime.fs
index c87f43485a1..2f8e4190988 100644
--- a/src/app/Fake.Runtime/FakeRuntime.fs
+++ b/src/app/Fake.Runtime/FakeRuntime.fs
@@ -1,8 +1,10 @@
-module Fake.FakeRuntime
+module Fake.Runtime.FakeRuntime
 
 open System
 open System.IO
-open Fake
+open Fake.Runtime
+
+#if DOTNETCORE
 
 (* Runtime will restore packages before running the script
 
@@ -162,14 +164,14 @@ let paketCachingProvider printDetails cacheDir (paketDependencies:Paket.Dependen
     |> Seq.choose (fun fi ->
       let fullName = fi.FullName
       try let assembly = Mono.Cecil.AssemblyDefinition.ReadAssembly fullName
-          { Fake.Fsi.AssemblyInfo.FullName = assembly.Name.FullName
-            Fake.Fsi.AssemblyInfo.Version = assembly.Name.Version.ToString()
-            Fake.Fsi.AssemblyInfo.Location = fullName } |> Some
+          { Fsi.AssemblyInfo.FullName = assembly.Name.FullName
+            Fsi.AssemblyInfo.Version = assembly.Name.Version.ToString()
+            Fsi.AssemblyInfo.Location = fullName } |> Some
       with e -> (if printDetails then Trace.log <| sprintf "Could not load '%s': %O" fullName e); None)
     |> Seq.toList
   // Restore or update immediatly, because or everything might be OK -> cached path.
   let mutable assemblies = restoreOrUpdate()
-  { new Fake.Fsi.ICachingProvider with
+  { new Fsi.ICachingProvider with
       member x.Invalidate cacheFile =
         if printDetails then Trace.log "Invalidating cache..."
         if File.Exists cacheFile then File.Delete cacheFile
@@ -177,7 +179,7 @@ let paketCachingProvider printDetails cacheDir (paketDependencies:Paket.Dependen
           // Restore again -> cache might have been invalidated -> lock file might have changed.
           //assemblies <- restoreOrUpdate()
           let options = Yaaf.FSharp.Scripting.FsiOptions.ofArgs opts
-          let references = assemblies |> List.map (fun (a:Fake.Fsi.AssemblyInfo) -> a.Location)
+          let references = assemblies |> List.map (fun (a:Fsi.AssemblyInfo) -> a.Location)
           { options with
               NoFramework = true
               Defines =  "FAKE" :: options.Defines
@@ -231,11 +233,13 @@ let prepareFakeScript printDetails script =
     restoreDependencies printDetails cacheDir section
   | None ->
     if printDetails then Trace.traceFAKE "No dependencies section found in script: %s" script
-    Fake.Fsi.Cache.defaultProvider
+    Fsi.Cache.defaultProvider
 
 let prepareAndRunScriptRedirect printDetails (Fsi.FsiArgs(fsiOptions, scriptPath, scriptArgs) as fsiArgs) envVars onErrMsg onOutMsg useCache =
   let provider = prepareFakeScript printDetails scriptPath
   Fsi.runFakeWithCache provider printDetails fsiArgs envVars onErrMsg onOutMsg useCache
 
 let prepareAndRunScript printDetails fsiArgs envVars useCache =
-  prepareAndRunScriptRedirect printDetails fsiArgs envVars (Fake.Fsi.onMessage true) (Fake.Fsi.onMessage false) useCache
\ No newline at end of file
+  prepareAndRunScriptRedirect printDetails fsiArgs envVars (Fsi.onMessage true) (Fsi.onMessage false) useCache
+
+#endif
\ No newline at end of file
diff --git a/src/app/Fake.Runtime/Fsi.fs b/src/app/Fake.Runtime/Fsi.fs
new file mode 100644
index 00000000000..c0d042cabc2
--- /dev/null
+++ b/src/app/Fake.Runtime/Fsi.fs
@@ -0,0 +1,619 @@
+/// Contains helper functions which allow to interact with the F# Interactive.
+module Fake.Runtime.Fsi
+open Fake.Runtime.Environment
+open Fake.Runtime.String
+open Fake.Runtime.Trace
+#if NETSTANDARD1_5
+open System.Runtime.Loader
+#endif
+
+open System
+open System.IO
+open System.Diagnostics
+open System.Threading
+open System.Text.RegularExpressions
+open System.Xml.Linq
+open Yaaf.FSharp.Scripting
+
+let createDirectiveRegex id = 
+    Regex("^\s*#" + id + "\s*(@\"|\"\"\"|\")(?<path>.+?)(\"\"\"|\")", RegexOptions.Compiled ||| RegexOptions.Multiline)
+
+let loadRegex = createDirectiveRegex "load"
+let rAssemblyRegex = createDirectiveRegex "r"
+let searchPathRegex = createDirectiveRegex "I"
+
+let private extractDirectives (regex : Regex) scriptContents = 
+    regex.Matches scriptContents
+    |> Seq.cast<Match>
+    |> Seq.map(fun m -> m.Groups.Item("path").Value)
+    
+type Script = {
+    Content : string
+    Location : string
+    SearchPaths : string seq
+    IncludedAssemblies : Lazy<string seq>
+}
+
+let getAllScriptContents (pathsAndContents : seq<Script>) = 
+    pathsAndContents |> Seq.map(fun s -> s.Content)
+let getIncludedAssembly scriptContents = extractDirectives rAssemblyRegex scriptContents
+let getSearchPaths scriptContents = extractDirectives searchPathRegex scriptContents
+
+let rec getAllScripts scriptPath : seq<Script> = 
+    let scriptContents = File.ReadAllText scriptPath
+    let searchPaths = getSearchPaths scriptContents |> Seq.toList
+
+    let loadedContents = 
+        extractDirectives loadRegex scriptContents
+        |> Seq.collect (fun path -> 
+            let path = 
+                if Path.IsPathRooted path then
+                    path
+                else
+                    let pathMaybe = 
+                        ["./"] @ searchPaths
+                        |> List.map(fun searchPath ->
+                            if Path.IsPathRooted searchPath then
+                                Path.Combine(searchPath, path)
+                            else
+                                Path.Combine(Path.GetDirectoryName scriptPath, searchPath, path))
+                        |> List.tryFind File.Exists
+
+                    match pathMaybe with 
+                    | None -> failwithf "Could not find script '%s' in any paths searched. Searched paths:\n%A" path searchPaths
+                    | Some x -> x
+            getAllScripts path
+        )
+    let s = 
+      { Location = scriptPath
+        Content = scriptContents
+        SearchPaths = searchPaths
+        IncludedAssemblies = lazy(getIncludedAssembly scriptContents) }
+    Seq.concat [List.toSeq [s]; loadedContents]
+
+let getStringHash (s:string) =
+    use sha256 = System.Security.Cryptography.SHA256.Create()
+    s
+    |> System.Text.Encoding.UTF8.GetBytes
+    |> sha256.ComputeHash
+    |> BitConverter.ToString
+    |> fun s -> s.Replace("-", "")
+
+let getScriptHash pathsAndContents fsiOptions =
+    (getAllScriptContents pathsAndContents |> String.concat "\n")
+    + (pathsAndContents |> Seq.map(fun x -> x.Location |> normalizePath) |> String.concat "\n")
+    + (fsiOptions |> String.concat "\n")
+    |> getStringHash
+
+type AssemblyInfo = {
+    FullName : string
+    Version : string
+    Location : string
+}
+
+type ICachingProvider =
+    abstract TryLoadCache : configFile:string -> AssemblyInfo list option
+    abstract TrySaveCache : configFile:string -> bool
+    abstract Invalidate : configFile:string -> unit
+    abstract MapFsiOptions : string[] -> string[]
+    abstract ResolveAssembly : Choice<System.Reflection.AssemblyName, System.Reflection.Assembly> -> System.Reflection.Assembly
+
+module internal Cache =
+    let xname name = XName.Get(name)
+    let create (loadedAssemblies : Reflection.Assembly seq) =
+        let xelement name = XElement(xname name)
+        let xattribute name value = XAttribute(xname name, value)
+
+        let doc = XDocument()
+        let root = xelement "FAKECache"
+        doc.Add(root)
+        let assemblies = xelement "Assemblies"
+        root.Add(assemblies)
+
+        let assemNodes =
+            loadedAssemblies
+            |> Seq.map(fun assem ->
+                let ele = xelement "Assembly"
+                ele.Add(xattribute "Location" assem.Location)
+                ele.Add(xattribute "FullName" assem.FullName)
+                ele.Add(xattribute "Version" (assem.GetName().Version.ToString()))
+                ele)
+            |> Seq.iter(assemblies.Add)
+        doc
+
+    let read (path : string) = 
+        let doc = XDocument.Load(path)
+        //let root = doc.Descendants() |> Seq.exactlyOne
+        let assembliesEle = doc.Descendants(xname "Assemblies") |> Seq.exactlyOne
+        assembliesEle.Descendants()
+        |> Seq.map(fun assemblyEle ->
+            let get name = assemblyEle.Attribute(xname name).Value
+            { Location = get "Location"
+              FullName = get "FullName"
+              Version = get "Version" })
+        |> Seq.toList
+
+    let defaultProvider =
+#if !NETSTANDARD1_6
+        { new ICachingProvider with
+            member x.MapFsiOptions options = options
+            member x.Invalidate cachePath = if File.Exists cachePath then File.Delete cachePath
+            member x.TryLoadCache (cachePath) =
+                if File.Exists cachePath then
+                    Some (read cachePath)
+                else None
+            //member x.GetAssembliesFromCache c = c.Assemblies
+            member x.ResolveAssembly a =
+                match a with
+                | Choice1Of2 name -> null
+                | Choice2Of2 a -> a
+            member x.TrySaveCache (cachePath) =
+                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 -> not <| 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
+                    false
+                else
+                    let assemblies =
+                        System.AppDomain.CurrentDomain.GetAssemblies()
+                        |> Seq.filter(fun assem -> not assem.IsDynamic)
+                        |> Seq.filter(fun assem -> not <| 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 = create assemblies
+                    cacheConfig.Save (cachePath)
+                    true }
+#else
+        { new ICachingProvider with
+            member x.MapFsiOptions opts =
+                let options = FsiOptions.ofArgs opts
+                if not options.NoFramework then // Caller should take care!
+                    let basePath = System.AppContext.BaseDirectory
+                    let references =
+                        System.IO.Directory.GetFiles(basePath, "*.dll")
+                        |> Seq.filter (fun r -> not (System.IO.Path.GetFileName(r).ToLowerInvariant().StartsWith("api-ms")))
+                        |> Seq.filter (fun r ->
+                            try Mono.Cecil.ModuleDefinition.ReadModule(r) |> ignore
+                                true
+                            with e -> false)
+                        |> Seq.toList
+                    { options with
+                        NoFramework = true
+                        Debug = Some DebugMode.Portable
+                        References = (references) @ options.References }
+                else options
+                |> (fun options -> options.AsArgs)
+            member x.Invalidate cachePath = if File.Exists cachePath then File.Delete cachePath
+            member x.TryLoadCache (cachePath) = 
+                traceFAKE "Default caching is disabled on dotnetcore, see https://github.com/dotnet/coreclr/issues/919#issuecomment-219212910"
+                None
+            //member x.GetAssembliesFromCache c = c.Assemblies
+            member x.ResolveAssembly a =
+                match a with
+                | Choice1Of2 name -> null
+                | Choice2Of2 a -> a
+            member x.TrySaveCache (cachePath) = false }
+#endif
+
+type FsiArgs =
+    FsiArgs of fsiOptions:string list * script:string * scriptArgs:string list with
+    static member parse (args:string array) =
+        //Find first arg that does not start with - (as these are fsi options that precede the fsx).
+        match args |> Array.tryFindIndex (fun arg -> arg.StartsWith("-") = false) with
+        | Some(i) ->
+            let fsxPath = args.[i]
+#if !CORE_CLR
+            if fsxPath.EndsWith(".fsx", StringComparison.InvariantCultureIgnoreCase) then
+#else
+            if fsxPath.EndsWith(".fsx", StringComparison.OrdinalIgnoreCase) then
+#endif
+                let fsiOpts = if i > 0 then args.[0..i-1] else [||]
+                let scriptArgs = if args.Length > (i+1) then args.[i+1..] else [||]
+                Choice1Of2(FsiArgs(fsiOpts |> List.ofArray, fsxPath, scriptArgs |> List.ofArray))
+            else Choice2Of2(sprintf "Expected argument %s to be the build script path, but it does not have the .fsx extension." fsxPath) 
+        | None -> Choice2Of2("Unable to locate the build script path.") 
+
+open Microsoft.FSharp.Compiler.Interactive.Shell
+open System.Reflection
+
+let getScriptAndHash =
+    let hashRegex = Text.RegularExpressions.Regex("(?<script>.+)_(?<hash>[a-zA-Z0-9]+)(\.dll|_config\.xml|_warnings\.txt)$", System.Text.RegularExpressions.RegexOptions.Compiled)
+    fun fileName ->
+        let matched = hashRegex.Match(fileName)
+        matched.Groups.Item("script").Value, matched.Groups.Item("hash").Value
+
+type private CacheInfo =
+  {
+    Provider : ICachingProvider
+    ScriptFileName : string
+    ScriptHash : string
+    AssemblyPath : string
+    AssemblyWarningsPath : string
+    CacheConfigPath : string
+    IsValid : bool
+  }
+
+/// gets a cache entry for the given script.
+/// We need to consider fsiOptions as they might contain --defines.
+let private getCacheInfoFromScript (provider:ICachingProvider) printDetails fsiOptions scriptPath =
+    let allScriptContents = getAllScripts scriptPath
+    let scriptHash = getScriptHash allScriptContents fsiOptions
+    //TODO this is only calculating the hash for the input file, not anything #load-ed
+    
+    let scriptFileName = Path.GetFileName(scriptPath)
+    let fakeDir = Path.Combine(Path.GetDirectoryName scriptPath, ".fake")
+    let hashPath = Path.Combine(fakeDir, scriptFileName + "_" + scriptHash)
+    let assemblyPath = hashPath + ".dll"
+    let assemblyWarningsPath = hashPath + "_warnings.txt"
+    let cacheConfigPath = hashPath + "_config.xml"
+    let cacheConfig = provider.TryLoadCache cacheConfigPath
+#if NETSTANDARD1_5
+    let loadContext = AssemblyLoadContext.Default
+#endif
+    let loadedAssemblies, knownAssemblies, cacheValid =
+        let cacheFilesExistAndAreValid =
+            File.Exists(assemblyPath) &&
+            cacheConfig.IsSome &&
+            File.Exists(assemblyWarningsPath) &&
+            cacheConfig.Value |> Seq.length > 0
+        if cacheFilesExistAndAreValid then
+            let loadedAssemblies =
+                cacheConfig.Value
+                |> Seq.choose (fun assemInfo ->
+                    try let assem =
+                            if assemInfo.Location <> "" then
+#if NETSTANDARD1_5
+                                loadContext.LoadFromAssemblyPath(assemInfo.Location)
+                            else loadContext.LoadFromAssemblyName(new AssemblyName(assemInfo.FullName))
+#else
+                                Reflection.Assembly.LoadFrom(assemInfo.Location)
+                            else Reflection.Assembly.Load(assemInfo.FullName)
+#endif
+                        Some(assemInfo, assem)
+                    with ex -> if printDetails then tracef "Unable to find assembly %A" assemInfo
+                               None)
+                |> Seq.toList
+            let knownAssemblies =
+                loadedAssemblies
+                |> List.map (fun (assemInfo, assem) -> assemInfo.FullName, assem)
+                |> dict
+            let assemVersionValidCount =
+                loadedAssemblies
+                |> Seq.filter(fun (assemInfo, assem) ->
+                    assem.GetName().Version.ToString() = assemInfo.Version)
+                |> Seq.length
+            loadedAssemblies, knownAssemblies, assemVersionValidCount = Seq.length cacheConfig.Value
+        else
+            [], dict [], false
+    
+#if NETSTANDARD1_5
+    loadContext.add_Resolving(new Func<AssemblyLoadContext, AssemblyName, Assembly>(fun _ name ->
+        let strName = name.FullName
+#else
+    AppDomain.CurrentDomain.add_AssemblyResolve(new ResolveEventHandler(fun _ ev ->
+        let strName = ev.Name
+        let name = AssemblyName(strName)
+#endif
+        match knownAssemblies.TryGetValue(strName) with
+        | true, a ->
+            if printDetails then tracefn "Redirect assembly load to known assembly: %s" strName
+            Choice2Of2 a
+        | _ ->
+            let token = name.GetPublicKeyToken()
+            match loadedAssemblies
+                |> Seq.map snd
+                |> Seq.tryFind (fun asem ->
+                    let n = asem.GetName()
+                    n.Name = name.Name &&
+                    (isNull token || // When null accept what we have.
+                        n.GetPublicKeyToken() = token)) with
+            | Some (asem) ->
+                traceFAKE "Redirect assembly from '%s' to '%s'" strName asem.FullName
+                Choice2Of2 asem
+            | _ ->
+                if printDetails then traceFAKE "Could not resolve '%s'" strName
+                Choice1Of2 name
+        |> provider.ResolveAssembly))
+    if not cacheValid then provider.Invalidate(cacheConfigPath)
+    { Provider = provider
+      ScriptFileName = scriptFileName
+      ScriptHash = scriptHash
+      AssemblyPath = assemblyPath
+      AssemblyWarningsPath = assemblyWarningsPath
+      CacheConfigPath = cacheConfigPath
+      IsValid = cacheValid }
+
+/// because it is used by test code
+let nameParser scriptFileName =
+    let noExtension = Path.GetFileNameWithoutExtension(scriptFileName)
+    let startString = "<StartupCode$FSI_"
+    let endString =
+      sprintf "_%s%s$%s"
+        (noExtension.Substring(0, 1).ToUpper())
+        (noExtension.Substring(1))
+        (Path.GetExtension(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
+    exampleName, fullName, parseName
+
+/// Run a script from the cache
+let private runScriptCached printDetails cacheInfo out err =
+    if printDetails then trace "Using cache"
+    let exampleName, fullName, parseName = nameParser cacheInfo.ScriptFileName
+    try
+        Yaaf.FSharp.Scripting.Helper.consoleCapture out err (fun () ->
+#if NETSTANDARD1_5
+            let loadContext = AssemblyLoadContext.Default
+            let ass = loadContext.LoadFromAssemblyPath(cacheInfo.AssemblyPath)
+#else
+            let ass = Reflection.Assembly.LoadFrom(cacheInfo.AssemblyPath)
+#endif
+            match ass.GetTypes()
+                  |> Seq.filter (fun t -> parseName t.FullName |> Option.isSome)
+                  |> Seq.map (fun t -> t.GetMethod("main@", BindingFlags.InvokeMethod ||| BindingFlags.Public ||| BindingFlags.Static))
+                  |> Seq.filter (isNull >> not)
+                  |> Seq.tryHead with
+            | Some mainMethod ->
+              try mainMethod.Invoke(null, [||])
+                  |> ignore
+                  true
+              with
+              | ex ->
+                  traceError (ex.ToString())
+                  false
+            | None -> failwithf "We could not find a type similar to '%s' containing a 'main@' method in the cached assembly (%s)!" exampleName cacheInfo.AssemblyPath)
+    finally
+        try
+            traceFAKE "%s" (File.ReadAllText cacheInfo.AssemblyWarningsPath)
+        with e -> traceError (e.ToString())
+
+/// Handles a cache store operation, this should not throw as it is executed in a finally block and
+/// therefore might eat other exceptions. And a caching error is not critical.
+let private handleCaching printDetails (session:IFsiSession) fsiErrorOutput (cacheDir:DirectoryInfo) cacheInfo  =
+    try
+        let wishName = "FAKE_CACHE_" + Path.GetFileNameWithoutExtension cacheInfo.ScriptFileName + "_" + cacheInfo.ScriptHash
+        let d = session.DynamicAssemblyBuilder
+        let name = "FSI-ASSEMBLY"
+#if NETSTANDARD1_6
+        failwith "Wow. Dotnetcore currently doesn't support saving dynamic assemblies. See https://github.com/dotnet/coreclr/issues/1709, https://github.com/dotnet/corefx/issues/4491. As it only hits F# it will probably never be implemented ;). One way to solve this would be to use IKVM.Reflection or Mono.Cecil in FSharp.Compiler.Service. But that's probably a lot of work. Feel free to start :). For now Caching cannot work."
+#else
+        d.Save(name + ".dll")
+#endif
+        if not <| Directory.Exists cacheDir.FullName then
+            let di = Directory.CreateDirectory cacheDir.FullName
+            di.Attributes <- FileAttributes.Directory ||| FileAttributes.Hidden
+
+        let destinationFile = FileInfo(cacheInfo.AssemblyPath)
+        let targetDirectory = destinationFile.Directory
+
+        if (not <| targetDirectory.Exists) then targetDirectory.Create()
+        if (destinationFile.Exists) then destinationFile.Delete()
+
+        File.WriteAllText(cacheInfo.AssemblyWarningsPath, fsiErrorOutput.ToString())
+
+        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...
+#if NETSTANDARD1_6
+            let reader =
+                let searchpaths =
+                    [ AppContext.BaseDirectory ]
+                let resolve name =
+                    let n = AssemblyName(name)
+                    // Maybe caching provider can already tell us
+                    match cacheInfo.Provider.TryLoadCache (cacheInfo.CacheConfigPath) 
+                          |> Option.bind (List.tryFind (fun a -> a.FullName = name)) with
+                    | Some f -> f.Location
+                    | None ->
+                        match searchpaths
+                              |> Seq.collect (fun p -> Directory.GetFiles(p, "*.dll"))
+                              |> Seq.tryFind (fun f -> f.ToLowerInvariant().Contains(n.Name.ToLowerInvariant())) with
+                        | Some f -> f
+                        | None ->
+                            failwithf "Could not resolve '%s'" name
+                { new Mono.Cecil.IAssemblyResolver with 
+                    member x.Resolve (name : string) =
+                        Mono.Cecil.AssemblyDefinition.ReadAssembly(
+                            resolve name,
+                            new Mono.Cecil.ReaderParameters(AssemblyResolver = x))
+                    member x.Resolve (name : string, parms : Mono.Cecil.ReaderParameters) =
+                        Mono.Cecil.AssemblyDefinition.ReadAssembly(resolve name, parms)
+                    member x.Resolve (name : Mono.Cecil.AssemblyNameReference) =
+                        x.Resolve(name.FullName)
+                    member x.Resolve (name : Mono.Cecil.AssemblyNameReference, parms : Mono.Cecil.ReaderParameters) =
+                        x.Resolve(name.FullName, parms) }
+#else
+            let reader = new Mono.Cecil.DefaultAssemblyResolver() // see https://github.com/fsharp/FAKE/issues/1084
+            reader.AddSearchDirectory (Path.GetDirectoryName fakePath)
+            reader.AddSearchDirectory (Path.GetDirectoryName typeof<string option>.Assembly.Location)
+#endif
+            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)
+
+        if cacheInfo.Provider.TrySaveCache(cacheInfo.CacheConfigPath) then
+            if printDetails then trace (System.Environment.NewLine + "Saved cache")
+    with ex ->
+#if NETSTANDARD1_6
+        traceFAKE "Caching is not working on dotnetcore: %s" ex.Message
+#else
+        // 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\n\nError: %O" ex
+#endif
+        if File.Exists cacheInfo.AssemblyWarningsPath then
+            // Invalidates the cache
+            try File.Delete cacheInfo.AssemblyWarningsPath with _ -> ()
+
+/// Run a given script uncached, saves the cache if useCache is set to true.
+/// deletes any existing caching for the given script.
+let private runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err =
+    let options = fsiOptions |> Seq.toArray |> cacheInfo.Provider.MapFsiOptions |> FsiOptions.ofArgs
+
+    let cacheDir = DirectoryInfo(Path.Combine(Path.GetDirectoryName(scriptPath),".fake"))
+    if useCache then
+        // If we are here that proably means that
+        // when trying to load the cached version something went wrong...
+        if cacheDir.Exists then
+            let oldFiles =
+                cacheDir.GetFiles()
+                |> Seq.filter(fun file ->
+                    let oldScriptName, _ = getScriptAndHash(file.Name)
+                    oldScriptName = cacheInfo.ScriptFileName)
+                |> Seq.toList
+
+            if not <| List.isEmpty oldFiles then
+                if printDetails then trace "Cache is invalid, recompiling"
+                oldFiles
+                |> List.map (fun file ->
+                    try file.Delete(); true
+                    // File might be locked (for example when executing the test suite!)
+                    with :? UnauthorizedAccessException ->
+                        traceFAKE "Unable to access %s" file.FullName
+                        false)
+                |> List.exists id |> not
+                // we could not delete a single file -> cache was not invalidated
+                |> function
+                    | true ->
+                        traceError (sprintf "Unable to invalidate cache for '%s', please delete the .fake folder!" cacheInfo.ScriptFileName)
+                    | _ -> ()
+            else
+                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
+        try
+            session.EvalScript scriptPath
+            true
+        with :? FsiEvaluationException as eval ->
+            traceFAKE "%O" eval
+            false
+    finally
+        // Write Script Warnings & Errors at the end
+        let strFsiErrorOutput = fsiErrorOutput.ToString()
+        if strFsiErrorOutput <> "" then
+            traceFAKE "%O" strFsiErrorOutput
+        // Cache in the error case as well.
+        if useCache && not cacheInfo.IsValid then
+            handleCaching printDetails session fsiErrorOutput cacheDir cacheInfo
+
+/// 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 runFakeWithCache provider printDetails (FsiArgs(fsiOptions, scriptPath, scriptArgs)) env onErrMsg onOutMsg useCache =
+    if printDetails then traceFAKE "Running Buildscript: %s" scriptPath
+    
+    if printDetails then
+#if NETSTANDARD1_5
+      let loadContext = AssemblyLoadContext.Default
+      loadContext.add_Resolving(new Func<AssemblyLoadContext, AssemblyName, Assembly>(fun _ name ->
+        let strName = name.FullName
+#else
+      AppDomain.CurrentDomain.add_AssemblyResolve(new ResolveEventHandler(fun _ ev ->
+        let strName = ev.Name
+        let name = AssemblyName(strName)
+#endif
+        trace <| sprintf "FAKE: Trying to resolve %s" strName; null))
+
+    // Add arguments to the Environment
+    for (k,v) in env do
+      setProcessEnvironVar k v
+
+    // Create an env var that only contains the build script args part from the --fsiargs (or "").
+    setEnvironVar "fsiargs-buildscriptargs" (String.Join(" ", scriptArgs))
+
+    let scriptPath =
+        if Path.IsPathRooted scriptPath then
+            scriptPath
+        else
+            Path.Combine(getCurrentDirectory(), scriptPath)
+
+    let cacheInfo = getCacheInfoFromScript provider printDetails fsiOptions scriptPath
+
+    use out = ScriptHost.CreateForwardWriter onOutMsg
+    use err = ScriptHost.CreateForwardWriter onErrMsg
+    if useCache && cacheInfo.IsValid then
+        try
+            runScriptCached printDetails cacheInfo out err
+        with ex ->
+            traceFAKE """CACHING WARNING
+this might happen after Updates...
+please open a issue on FAKE and /cc @matthid ONLY IF this happens reproducibly)
+
+Error: %O""" ex
+            // Invalidates the cache
+            runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
+    else
+        runScriptUncached (useCache, scriptPath, fsiOptions) printDetails cacheInfo out err
+
+let internal runFAKEScriptWithFsiArgsAndRedirectMessages printDetails fsiArgs env onErrMsg onOutMsg useCache =
+    runFakeWithCache Cache.defaultProvider printDetails fsiArgs env onErrMsg onOutMsg useCache
+
+let internal onMessage isError =
+    let printer = if isError && Trace.importantMessagesToStdErr then eprintf else printf
+    printer "%s"
+
+/// 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 =
+    runFAKEScriptWithFsiArgsAndRedirectMessages
+        printDetails (FsiArgs(fsiOptions, script, scriptArgs)) env
+        (onMessage true) (onMessage false)
+        useCache
+
+/// Run the given buildscript with fsi.exe at the given working directory.
+let runBuildScriptAt printDetails script extraFsiArgs env useCache =
+    runBuildScriptWithFsiArgsAt printDetails (FsiArgs(extraFsiArgs, script, [])) env useCache
+
+/// Run the given buildscript with fsi.exe
+let runBuildScript printDetails script extraFsiArgs env useCache =
+    runBuildScriptAt printDetails script extraFsiArgs env useCache
diff --git a/src/app/Fake.Runtime/LegacyApiHelper.fs b/src/app/Fake.Runtime/LegacyApiHelper.fs
new file mode 100644
index 00000000000..b6ed2dcc870
--- /dev/null
+++ b/src/app/Fake.Runtime/LegacyApiHelper.fs
@@ -0,0 +1,6 @@
+module internal Fake.Runtime.LegacyApiHelper
+
+type NewApiMutableHelper<'a> = { Set : 'a -> unit; Get : unit -> 'a }
+
+let ofRef r = { Set = (fun v -> r := v); Get = (fun () -> !r) }
+let toGetSet { Set = s; Get = g } = g, s
\ No newline at end of file
diff --git a/src/app/Fake.Runtime/String.fs b/src/app/Fake.Runtime/String.fs
new file mode 100644
index 00000000000..74cd0a718b4
--- /dev/null
+++ b/src/app/Fake.Runtime/String.fs
@@ -0,0 +1,179 @@
+/// Contains basic functions for string manipulation.
+
+module Fake.Runtime.String
+type String = System.String
+open Fake.Runtime.Environment
+open System
+open System.IO
+open System.Text
+open System.Collections.Generic
+
+/// [omit]
+let productName() = "FAKE"
+
+/// Returns if the string is null or empty
+let inline isNullOrEmpty value = String.IsNullOrEmpty value
+
+/// Returns if the string is not null or empty
+let inline isNotNullOrEmpty value = String.IsNullOrEmpty value |> not
+
+/// Returns if the string is null or empty or completely whitespace
+let inline isNullOrWhiteSpace value = isNullOrEmpty value || value |> Seq.forall Char.IsWhiteSpace
+
+/// Replaces the given pattern in the given text with the replacement
+let inline replace (pattern : string) replacement (text : string) = text.Replace(pattern, replacement)
+
+/// Converts a sequence of strings to a string with delimiters
+let inline separated delimiter (items : string seq) = String.Join(delimiter, Array.ofSeq items)
+
+/// Removes the slashes from the end of the given string
+let inline trimSlash (s : string) = s.TrimEnd('\\')
+
+/// Splits the given string at the given char delimiter
+let inline split (delimiter : char) (text : string) = text.Split [| delimiter |] |> Array.toList
+
+/// Splits the given string at the given string delimiter
+let inline splitStr (delimiterStr : string) (text : string) = 
+    text.Split([| delimiterStr |], StringSplitOptions.None) |> Array.toList
+
+/// Converts a sequence of strings into a string separated with line ends
+let inline toLines text = separated Environment.NewLine text
+
+/// Checks whether the given text starts with the given prefix
+let startsWith prefix (text : string) = text.StartsWith prefix
+
+/// Checks whether the given text ends with the given suffix
+let endsWith suffix (text : string) = text.EndsWith suffix
+
+/// Determines whether the last character of the given <see cref="string" />
+/// matches Path.DirectorySeparatorChar.         
+let endsWithSlash = endsWith (Path.DirectorySeparatorChar.ToString())
+
+/// Replaces the first occurrence of the pattern with the given replacement.
+let replaceFirst (pattern : string) replacement (text : string) = 
+    let pos = text.IndexOf pattern
+    if pos < 0 then text
+    else text.Remove(pos, pattern.Length).Insert(pos, replacement)
+
+/// Appends a text to a StringBuilder.
+let inline append text (builder : StringBuilder) = builder.Append(sprintf "\"%s\" " text)
+
+/// Appends a text to a StringBuilder without surrounding quotes.
+let inline appendWithoutQuotes (text : string) (builder : StringBuilder) = builder.Append(sprintf "%s " text)
+
+/// Appends string of function value if option has some value
+let inline appendIfSome o f builder = 
+    match o with
+    | Some(value) -> appendWithoutQuotes (f value) builder
+    | None -> builder
+
+/// Appends a text if the predicate is true.
+let inline appendIfTrue p s builder = 
+    if p then append s builder
+    else builder
+
+let inline appendIfTrueWithoutQuotes p s builder = 
+    if p then appendWithoutQuotes s builder
+    else builder
+
+/// Appends a text if the predicate is false.
+let inline appendIfFalse p = appendIfTrue (not p)
+
+/// Appends a text without quoting if the value is not null.
+let inline appendWithoutQuotesIfNotNull (value : Object) s = 
+    appendIfTrueWithoutQuotes 
+        (value <> null) 
+        (match value with
+         | :? String as sv -> (sprintf "%s%s" s sv)
+         | _ -> (sprintf "%s%A" s value))
+
+/// Appends a text if the value is not null.
+let inline appendIfNotNull (value : Object) s = 
+    appendIfTrue 
+        (value <> null) 
+        (match value with
+         | :? String as sv -> (sprintf "%s%s" s sv)
+         | _ -> (sprintf "%s%A" s value))
+
+/// Appends a quoted text if the value is not null.
+let inline appendQuotedIfNotNull (value : Object) s (builder : StringBuilder) = 
+    if (value = null) then builder
+    else 
+        (match value with
+         | :? String as sv -> builder.Append(sprintf "%s\"%s\" " s sv)
+         | _ -> builder.Append(sprintf "%s\"%A\" " s value))
+
+/// Appends a text if the value is not null.
+let inline appendStringIfValueIsNotNull value = appendIfTrue (value <> null)
+
+/// Appends a text if the value is not null or empty.
+let inline appendStringIfValueIsNotNullOrEmpty value = appendIfTrue (isNullOrEmpty value |> not)
+
+/// Appends a text if the value is not null or empty.
+let inline appendIfNotNullOrEmpty value s = appendIfTrue (isNotNullOrEmpty value) (sprintf "%s%s" s value)
+
+/// Appends all notnull fileNames.
+let inline appendFileNamesIfNotNull fileNames (builder : StringBuilder) = 
+    fileNames |> Seq.fold (fun builder file -> appendIfTrue (isNullOrEmpty file |> not) file builder) builder
+
+/// Returns the text from the StringBuilder
+let inline toText (builder : StringBuilder) = builder.ToString()
+
+/// [omit]
+let private regexes = new Dictionary<_, _>()
+
+/// [omit]
+let getRegEx pattern = 
+    match regexes.TryGetValue pattern with
+    | true, regex -> regex
+    | _ -> (new System.Text.RegularExpressions.Regex(pattern))
+
+/// [omit]
+let regex_replace pattern (replacement : string) text = (getRegEx pattern).Replace(text, replacement)
+
+/// Checks whether the given char is a german umlaut.
+let isUmlaut c = Seq.exists ((=) c) [ 'ä'; 'ö'; 'ü'; 'Ä'; 'Ö'; 'Ü'; 'ß' ]
+
+/// Converts all characters in a string to lower case.
+let inline toLower (s : string) = s.ToLower()
+
+/// Returns all standard chars and digits.
+let charsAndDigits = [ 'a'..'z' ] @ [ 'A'..'Z' ] @ [ '0'..'9' ]
+
+/// Checks whether the given char is a standard char or digit.
+let isLetterOrDigit c = List.exists ((=) c) charsAndDigits
+
+/// Trims the given string with the DirectorySeparatorChar
+let inline trimSeparator (s : string) = s.TrimEnd Path.DirectorySeparatorChar
+
+/// Trims all special characters from a string.
+let inline trimSpecialChars (text : string) = 
+    text
+    |> Seq.filter isLetterOrDigit
+    |> Seq.filter (isUmlaut >> not)
+    |> Seq.fold (fun (acc : string) c -> acc + string c) ""
+
+/// Trims the given string
+let inline trim (x : string) = 
+    if isNullOrEmpty x then x
+    else x.Trim()
+
+/// Trims the given string
+let inline trimChars chars (x : string) = 
+    if isNullOrEmpty x then x
+    else x.Trim chars
+
+/// Trims the start of the given string
+let inline trimStartChars chars (x : string) =
+    if isNullOrEmpty x then x
+    else x.TrimStart chars
+
+/// Trims the end of the given string
+let inline trimEndChars chars (x : string) =
+    if isNullOrEmpty x then x
+    else x.TrimEnd chars
+
+/// Lifts a string to an option
+let liftString x = 
+    if isNullOrEmpty x then None
+    else Some x
diff --git a/src/app/Fake.Runtime/Trace.fs b/src/app/Fake.Runtime/Trace.fs
new file mode 100644
index 00000000000..d5796b543d8
--- /dev/null
+++ b/src/app/Fake.Runtime/Trace.fs
@@ -0,0 +1,291 @@
+/// This module contains function which allow to trace build output
+module Fake.Runtime.Trace
+open Fake.Runtime.Environment
+open Fake.Runtime.String
+open Fake.Runtime.BuildServer
+
+open System
+open System.IO
+open System.Reflection
+open System.Threading
+
+
+/// Defines Tracing information for TraceListeners
+type TraceData = 
+    | StartMessage
+    | ImportantMessage of string
+    | ErrorMessage of string
+    | LogMessage of string * bool
+    | TraceMessage of string * bool
+    | 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 = 
+    abstract Write : TraceData -> unit
+
+/// A default color map which maps TracePriorities to ConsoleColors
+let colorMap traceData = 
+    match traceData with
+    | ImportantMessage _ -> ConsoleColor.Yellow
+    | ErrorMessage _ -> ConsoleColor.Red
+    | LogMessage _ -> ConsoleColor.Gray
+    | TraceMessage _ -> ConsoleColor.Green
+    | FinishedMessage -> ConsoleColor.White
+    | _ -> ConsoleColor.Gray
+
+/// Implements a TraceListener for System.Console.
+/// ## Parameters
+///  - `importantMessagesToStdErr` - Defines whether to trace important messages to StdErr.
+///  - `colorMap` - A function which maps TracePriorities to ConsoleColors.
+type ConsoleTraceListener(importantMessagesToStdErr, colorMap) = 
+    
+    let writeText toStdErr color newLine text = 
+        let curColor = Console.ForegroundColor
+        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.
+        member this.Write msg = 
+            let color = colorMap msg
+            match msg with
+            | StartMessage -> ()
+            | OpenTag _ -> ()
+            | CloseTag _ -> ()
+            | 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 && buildServer <> TeamCity
+
+/// The default TraceListener for Console.
+let defaultConsoleTraceListener =
+  ConsoleTraceListener(importantMessagesToStdErr, colorMap)
+
+/// Specifies if the XmlWriter should close tags automatically
+let mutable AutoCloseXmlWriter = false
+
+/// A List with all registered listeners
+let listeners = new Collections.Generic.List<ITraceListener>()
+
+// register listeners
+listeners.Add defaultConsoleTraceListener
+
+/// Allows to post messages to all trace listeners
+let postMessage x = listeners.ForEach(fun listener -> listener.Write x)
+
+
+
+type FAKEException(msg) =
+    inherit System.Exception(msg)
+
+/// Gets the path of the current FAKE instance
+#if !CORE_CLR
+let fakePath = productName.GetType().Assembly.Location
+#else
+let fakePath = productName.GetType().GetTypeInfo().Assembly.Location
+#endif
+
+/// Gets the FAKE version no.
+let fakeVersion = AssemblyVersionInformation.Version
+
+let private openTags = new ThreadLocal<list<string>>(fun _ -> [])
+
+/// Logs the specified string        
+let log message = LogMessage(message, true) |> postMessage
+
+/// Logs the specified message
+let logfn fmt = Printf.ksprintf log fmt
+
+/// Logs the specified message (without line break)
+let logf fmt = Printf.ksprintf (fun text -> postMessage (LogMessage(text, false))) fmt
+
+/// Logs the specified string if the verbose mode is activated.
+let logVerbosefn fmt = 
+    Printf.ksprintf (if verbose then log
+                     else ignore) fmt
+
+/// Writes a trace to the command line (in green)
+let trace message = postMessage (TraceMessage(message, true))
+
+/// Writes a message to the command line (in green)
+let tracefn fmt = Printf.ksprintf trace fmt
+
+/// Writes a message to the command line (in green) and without a line break
+let tracef fmt = Printf.ksprintf (fun text -> postMessage (TraceMessage(text, false))) fmt
+
+/// Writes a trace to the command line (in green) if the verbose mode is activated.
+let traceVerbose s = 
+    if verbose then trace s
+
+/// Writes a trace to stderr (in yellow)  
+let traceImportant text = postMessage (ImportantMessage text)
+
+/// Writes a trace to the command line (in yellow)
+let traceFAKE fmt = Printf.ksprintf (fun text -> postMessage (ImportantMessage text)) fmt
+
+/// Traces an error (in red)
+let traceError error = postMessage (ErrorMessage error)
+
+open Microsoft.FSharp.Core.Printf
+
+/// Converts an exception and its inner exceptions to a nice string.
+let exceptionAndInnersToString (ex:Exception) =
+    let sb = Text.StringBuilder()
+    let delimeter = String.replicate 50 "*"
+    let nl = Environment.NewLine
+    let rec printException (e:Exception) count =
+        if (e :? TargetException && e.InnerException <> null)
+        then printException (e.InnerException) count
+        else
+            if (count = 1) then bprintf sb "Exception Message:%s%s%s" e.Message nl delimeter
+            else bprintf sb "%s%s%d)Exception Message:%s%s%s" nl nl count e.Message nl delimeter
+            bprintf sb "%sType: %s" nl (e.GetType().FullName)
+            // Loop through the public properties of the exception object
+            // and record their values.
+            e.GetType().GetProperties()
+            |> Array.iter (fun p ->
+                // Do not log information for the InnerException or StackTrace.
+                // This information is captured later in the process.
+                if (p.Name <> "InnerException" && p.Name <> "StackTrace" &&
+                    p.Name <> "Message" && p.Name <> "Data") then
+                    try
+                        let value = p.GetValue(e, null)
+                        if (value <> null)
+                        then bprintf sb "%s%s: %s" nl p.Name (value.ToString())
+                    with
+                    | e2 -> bprintf sb "%s%s: %s" nl p.Name e2.Message
+            )
+            if (e.StackTrace <> null) then
+                bprintf sb "%s%sStackTrace%s%s%s" nl nl nl delimeter nl
+                bprintf sb "%s%s" nl e.StackTrace
+            if (e.InnerException <> null)
+            then printException e.InnerException (count+1)
+    printException ex 1
+    sb.ToString()
+
+/// Traces an exception details (in red)
+let traceException (ex:Exception) = exceptionAndInnersToString ex |> traceError
+
+/// Traces the EnvironmentVariables
+let TraceEnvironmentVariables() = 
+#if !CORE_CLR
+    [ EnvironTarget.Machine; EnvironTarget.Process; EnvironTarget.User ] 
+    |> Seq.iter (fun mode -> 
+           tracefn "Environment-Settings (%A):" mode
+           environVars mode |> Seq.iter (tracefn "  %A"))
+#else
+    tracefn "Environment-Settings (%A):" "Process"
+    environVars () |> Seq.iter (tracefn "  %A")
+#endif
+
+/// Gets the FAKE Version string
+let fakeVersionStr = sprintf "FAKE - F# Make %A" fakeVersion
+
+/// Traces a line
+let traceLine() = trace "---------------------------------------------------------------------"
+
+/// Traces a header
+let traceHeader name = 
+    trace ""
+    traceLine()
+    trace name
+    traceLine()
+
+/// Traces the begin of the build
+let traceStartBuild() = postMessage StartMessage
+
+/// Traces the end of the build
+let traceEndBuild() = postMessage FinishedMessage
+
+/// Puts an opening tag on the internal tag stack
+let openTag tag = openTags.Value <- tag :: openTags.Value
+
+/// Removes an opening tag from the internal tag stack
+let closeTag tag = 
+    match openTags.Value with
+    | x :: rest when x = tag -> openTags.Value <- rest
+    | _ -> failwithf "Invalid tag structure. Trying to close %s tag but stack is %A" tag openTags
+    CloseTag tag |> postMessage
+
+let closeAllOpenTags() = Seq.iter closeTag openTags.Value
+
+/// Traces the begin of a target
+let traceStartTarget name description dependencyString =
+    openTag "target"
+    OpenTag("target", name) |> postMessage
+    tracefn "Starting Target: %s %s" name dependencyString
+    if description <> null then tracefn "  %s" description
+
+/// Traces the end of a target   
+let traceEndTarget name = 
+    tracefn "Finished Target: %s" name
+    closeTag "target"
+
+/// Traces the begin of a task
+let traceStartTask task description = 
+    openTag "task"
+    OpenTag("task", task) |> postMessage
+
+/// Traces the end of a task
+let traceEndTask task description = 
+    closeTag "task"
+
+let console = new ConsoleTraceListener(false, colorMap) :> ITraceListener
+
+open System.Diagnostics
+#if CORE_CLR
+type EventLogEntryType =
+  | Error
+  | Information
+  | Warning
+  | Other
+#endif
+/// Traces the message to the console
+let logToConsole (msg, eventLogEntry : EventLogEntryType) = 
+    match eventLogEntry with
+    | EventLogEntryType.Error -> ErrorMessage msg
+    | EventLogEntryType.Information -> TraceMessage(msg, true)
+    | EventLogEntryType.Warning -> ImportantMessage msg
+    | _ -> LogMessage(msg, true)
+    |> console.Write
+
+/// Logs the given files with the message.
+let Log message files = files |> Seq.iter (log << sprintf "%s%s" message)
+
+
+
diff --git a/src/app/Fake.Runtime/project.json b/src/app/Fake.Runtime/project.json
index 12bcc80ffa0..03185aaa65c 100644
--- a/src/app/Fake.Runtime/project.json
+++ b/src/app/Fake.Runtime/project.json
@@ -5,6 +5,7 @@
     "compilerName": "fsc",
     "define": [
       "CORE_CLR",
+      "DOTNETCORE",
       "EXPLICIT_DEPENDENCIES"
     ],
     "emitEntryPoint": false,
@@ -18,14 +19,13 @@
     ],
     "compile": {
       "includeFiles": [
-        "../FakeLib/AssemblyInfo.fs",
+        "AssemblyInfo.fs",
         "../../../paket-files/matthid/Yaaf.FSharp.Scripting/src/source/Yaaf.FSharp.Scripting/YaafFSharpScripting.fs",
-        "../FakeLib/EnvironmentHelper.fs",
-        "../FakeLib/StringHelper.fs",
-        "../FakeLib/BuildServerHelper.fs",
-        "../FakeLib/TraceListener.fs",
-        "../FakeLib/TraceHelper.fs",
-        "../FakeLib/FSIHelper.fs",
+        "Environment.fs",
+        "String.fs",
+        "BuildServer.fs",
+        "Trace.fs",
+        "Fsi.fs",
         "FakeRuntime.fs"
       ]
     }
diff --git a/src/app/Fake.netcore/Program.fs b/src/app/Fake.netcore/Program.fs
index fce2e2d1296..86126a23816 100644
--- a/src/app/Fake.netcore/Program.fs
+++ b/src/app/Fake.netcore/Program.fs
@@ -1,10 +1,10 @@
 open System
-open Fake
-open Fake.Environment
-open Fake.String
-open Fake.Trace
-open Fake.BuildServer
-open Fake.Fsi
+open Fake.Runtime
+open Fake.Runtime.Environment
+open Fake.Runtime.String
+open Fake.Runtime.Trace
+open Fake.Runtime.BuildServer
+open Fake.Runtime.Fsi
 open System.IO
 open Argu
 
diff --git a/src/app/FakeLib/FakeLib.fsproj b/src/app/FakeLib/FakeLib.fsproj
index e99a538ac9c..5d161c1b76d 100644
--- a/src/app/FakeLib/FakeLib.fsproj
+++ b/src/app/FakeLib/FakeLib.fsproj
@@ -40,151 +40,174 @@
       <Paket>True</Paket>
       <Link>paket-files/YaafFSharpScripting.fs</Link>
     </Compile>
-    <Compile Include="AssemblyInfo.fs" />
-    <Compile Include="UserInputHelper.fs" />
-    <Compile Include="CSharpHelper.fs" />
-    <Compile Include="EnvironmentHelper.fs" />
-    <Compile Include="RegistryHelper.fs" />
-    <Compile Include="FileSystemHelper.fs" />
-    <Compile Include="StringHelper.fs" />
-    <Compile Include="TemplateHelper.fs" />
-    <Compile Include="CacheHelper.fs" />
-    <Compile Include="XMLHelper.fs" />
-    <Compile Include="REST.fs" />
-    <Compile Include="BuildServerHelper.fs" />
-    <Compile Include="TraceListener.fs" />
-    <Compile Include="TeamCityHelper.fs" />
-    <Compile Include="TeamCityRESTHelper.fs" />
-    <Compile Include="TraceHelper.fs" />
-    <Compile Include="ServiceControllerHelper.fs" />
-    <Compile Include="GuardedAwaitObservable.fs" />
-    <Compile Include="ProcessHelper.fs" />
-    <Compile Include="PsExecHelper.fs" />
-    <Compile Include="NpmHelper.fs" />
-    <Compile Include="BowerHelper.fs" />
-    <Compile Include="AppVeyor.fs" />
-    <Compile Include="BitbucketPipelines.fs" />
-    <Compile Include="TaskRunnerHelper.fs" />
-    <Compile Include="Globbing\Globbing.fs" />
-    <Compile Include="Globbing\FileSystem.fs" />
-    <Compile Include="FileHelper.fs" />
-    <Compile Include="FileUtils.fs" />
-    <Compile Include="FuchuHelper.fs" />
-    <Compile Include="UnitTest\UnitTestCommon.fs" />
-    <Compile Include="UnitTest\UnitTestHelper.fs" />
-    <Compile Include="UnitTest\NUnit\Xml.fs" />
-    <Compile Include="UnitTest\NUnit\Common.fs" />
-    <Compile Include="UnitTest\NUnit\Sequential.fs" />
-    <Compile Include="UnitTest\NUnit\Parallel.fs" />
-    <Compile Include="UnitTest\NUnit\NUnit3.fs" />
-    <Compile Include="UnitTest\XUnit\XUnit.fs" />
-    <Compile Include="UnitTest\XUnit\XUnitHelper.fs" />
-    <Compile Include="UnitTest\XUnit\XUnit2.fs" />
-    <Compile Include="UnitTest\XUnit\XUnit2Helper.fs" />
-    <Compile Include="UnitTest\MSpecHelper.fs" />
-    <Compile Include="UnitTest\MSTest.fs" />
-    <Compile Include="UnitTest\ProcessTestRunner.fs" />
-    <Compile Include="UnitTest\VSTest.fs" />
-    <Compile Include="AssemblyInfoFile.fs" />
-    <Compile Include="AssemblyInfoHelper.fs" />
-    <Compile Include="FXCopHelper.fs" />
-    <Compile Include="FSharpFormattingHelper.fs" />
-    <Compile Include="NCoverHelper.fs" />
-    <Compile Include="NDependHelper.fs" />
-    <Compile Include="MsBuildLogger.fs" />
-    <Compile Include="MSBuildHelper.fs" />
-    <Compile Include="ArchiveHelper.fs" />
-    <Compile Include="ZipHelper.fs" />
-    <Compile Include="StrongNamingHelper.fs" />
-    <Compile Include="GACHelper.fs" />
-    <Compile Include="NGenHelper.fs" />
-    <Compile Include="DocuHelper.fs" />
-    <Compile Include="ILMergeHelper.fs" />
-    <Compile Include="WiXHelper.fs" />
-    <Compile Include="MSIHelper.fs" />
-    <Compile Include="RegAsmHelper.fs" />
-    <Compile Include="RestorePackageHelper.fs" />
-    <Compile Include="VSSHelper.fs" />
-    <Compile Include="DynamicsNavHelper.fs" />
-    <Compile Include="DynamicsNavFile.fs" />
-    <Compile Include="SCPHelper.fs" />
-    <Compile Include="RoboCopyHelper.fs" />
-    <Compile Include="XpkgHelper.fs" />
-    <Compile Include="VersionHelper.fs" />
-    <Compile Include="MSBuild\ProjectSystem.fs" />
-    <Compile Include="MSBuild\SpecsRemovement.fs" />
-    <Compile Include="Git\CommandHelper.fs" />
-    <Compile Include="Git\Sha1.fs" />
-    <Compile Include="Git\Repository.fs" />
-    <Compile Include="Git\Submodule.fs" />
-    <Compile Include="Git\Branches.fs" />
-    <Compile Include="Git\Reset.fs" />
-    <Compile Include="Git\Merge.fs" />
-    <Compile Include="Git\Stash.fs" />
-    <Compile Include="Git\SanityChecks.fs" />
-    <Compile Include="Git\Information.fs" />
-    <Compile Include="Git\FileStatus.fs" />
-    <Compile Include="Git\Rebase.fs" />
-    <Compile Include="Git\CommitMessage.fs" />
-    <Compile Include="Git\Staging.fs" />
-    <Compile Include="Git\Commit.fs" />
-    <Compile Include="FSIHelper.fs" />
-    <Compile Include="Boot.fs" />
-    <Compile Include="MessageHelper.fs" />
-    <Compile Include="HTMLHelpWorkShopHelper.fs" />
-    <Compile Include="ConfigurationHelper.fs" />
-    <Compile Include="TargetHelper.fs" />
-    <Compile Include="AdditionalSyntax.fs" />
-    <Compile Include="PermissionsHelper.fs" />
-    <Compile Include="SpecFlowHelper.fs" />
-    <Compile Include="OctoTools.fs" />
-    <None Include="paket.references" />
-    <Compile Include="SignToolHelper.fs" />
-    <Compile Include="MageHelper.fs" />
-    <Compile Include="SemVerHelper.fs" />
-    <Compile Include="ReleaseNotesHelper.fs" />
+    <Compile Include="..\Fake.Runtime\AssemblyInfo.fs">
+      <Link>Fake.Runtime/AssemblyInfo.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\LegacyApiHelper.fs">
+      <Link>Fake.Runtime/LegacyApiHelper.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\Environment.fs">
+      <Link>Fake.Runtime/Environment.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\String.fs">
+      <Link>Fake.Runtime/String.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\BuildServer.fs">
+      <Link>Fake.Runtime/BuildServer.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\Trace.fs">
+      <Link>Fake.Runtime/Trace.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\Fsi.fs">
+      <Link>Fake.Runtime/Fsi.fs</Link>
+    </Compile>
+    <Compile Include="..\Fake.Runtime\FakeRuntime.fs">
+      <Link>Fake.Runtime/FakeRuntime.fs</Link>
+    </Compile>
+    <Compile Include="LegacyApi\UserInputHelper.fs" />
+    <Compile Include="LegacyApi\CSharpHelper.fs" />
+    <Compile Include="LegacyApi\EnvironmentHelper.fs" />
+    <Compile Include="LegacyApi\RegistryHelper.fs" />
+    <Compile Include="LegacyApi\FileSystemHelper.fs" />
+    <Compile Include="LegacyApi\StringHelper.fs" />
+    <Compile Include="LegacyApi\TemplateHelper.fs" />
+    <Compile Include="LegacyApi\CacheHelper.fs" />
+    <Compile Include="LegacyApi\XMLHelper.fs" />
+    <Compile Include="LegacyApi\REST.fs" />
+    <Compile Include="LegacyApi\BuildServerHelper.fs" />
+    <Compile Include="LegacyApi\TraceListener.fs" />
+    <Compile Include="LegacyApi\TeamCityHelper.fs" />
+    <Compile Include="LegacyApi\TeamCityRESTHelper.fs" />
+    <Compile Include="LegacyApi\TraceHelper.fs" />
+    <Compile Include="LegacyApi\ServiceControllerHelper.fs" />
+    <Compile Include="LegacyApi\GuardedAwaitObservable.fs" />
+    <Compile Include="LegacyApi\ProcessHelper.fs" />
+    <Compile Include="LegacyApi\PsExecHelper.fs" />
+    <Compile Include="LegacyApi\NpmHelper.fs" />
+    <Compile Include="LegacyApi\BowerHelper.fs" />
+    <Compile Include="LegacyApi\AppVeyor.fs" />
+    <Compile Include="LegacyApi\BitbucketPipelines.fs" />
+    <Compile Include="LegacyApi\TaskRunnerHelper.fs" />
+    <Compile Include="LegacyApi\Globbing\Globbing.fs" />
+    <Compile Include="LegacyApi\Globbing\FileSystem.fs" />
+    <Compile Include="LegacyApi\FileHelper.fs" />
+    <Compile Include="LegacyApi\FileUtils.fs" />
+    <Compile Include="LegacyApi\FuchuHelper.fs" />
+    <Compile Include="LegacyApi\UnitTest\UnitTestCommon.fs" />
+    <Compile Include="LegacyApi\UnitTest\UnitTestHelper.fs" />
+    <Compile Include="LegacyApi\UnitTest\NUnit\Xml.fs" />
+    <Compile Include="LegacyApi\UnitTest\NUnit\Common.fs" />
+    <Compile Include="LegacyApi\UnitTest\NUnit\Sequential.fs" />
+    <Compile Include="LegacyApi\UnitTest\NUnit\Parallel.fs" />
+    <Compile Include="LegacyApi\UnitTest\NUnit\NUnit3.fs" />
+    <Compile Include="LegacyApi\UnitTest\XUnit\XUnit.fs" />
+    <Compile Include="LegacyApi\UnitTest\XUnit\XUnitHelper.fs" />
+    <Compile Include="LegacyApi\UnitTest\XUnit\XUnit2.fs" />
+    <Compile Include="LegacyApi\UnitTest\XUnit\XUnit2Helper.fs" />
+    <Compile Include="LegacyApi\UnitTest\MSpecHelper.fs" />
+    <Compile Include="LegacyApi\UnitTest\MSTest.fs" />
+    <Compile Include="LegacyApi\UnitTest\ProcessTestRunner.fs" />
+    <Compile Include="LegacyApi\UnitTest\VSTest.fs" />
+    <Compile Include="LegacyApi\AssemblyInfoFile.fs" />
+    <Compile Include="LegacyApi\AssemblyInfoHelper.fs" />
+    <Compile Include="LegacyApi\FXCopHelper.fs" />
+    <Compile Include="LegacyApi\FSharpFormattingHelper.fs" />
+    <Compile Include="LegacyApi\NCoverHelper.fs" />
+    <Compile Include="LegacyApi\NDependHelper.fs" />
+    <Compile Include="LegacyApi\MsBuildLogger.fs" />
+    <Compile Include="LegacyApi\MSBuildHelper.fs" />
+    <Compile Include="LegacyApi\ArchiveHelper.fs" />
+    <Compile Include="LegacyApi\ZipHelper.fs" />
+    <Compile Include="LegacyApi\StrongNamingHelper.fs" />
+    <Compile Include="LegacyApi\GACHelper.fs" />
+    <Compile Include="LegacyApi\NGenHelper.fs" />
+    <Compile Include="LegacyApi\DocuHelper.fs" />
+    <Compile Include="LegacyApi\ILMergeHelper.fs" />
+    <Compile Include="LegacyApi\WiXHelper.fs" />
+    <Compile Include="LegacyApi\MSIHelper.fs" />
+    <Compile Include="LegacyApi\RegAsmHelper.fs" />
+    <Compile Include="LegacyApi\RestorePackageHelper.fs" />
+    <Compile Include="LegacyApi\VSSHelper.fs" />
+    <Compile Include="LegacyApi\DynamicsNavHelper.fs" />
+    <Compile Include="LegacyApi\DynamicsNavFile.fs" />
+    <Compile Include="LegacyApi\SCPHelper.fs" />
+    <Compile Include="LegacyApi\RoboCopyHelper.fs" />
+    <Compile Include="LegacyApi\XpkgHelper.fs" />
+    <Compile Include="LegacyApi\VersionHelper.fs" />
+    <Compile Include="LegacyApi\MSBuild\ProjectSystem.fs" />
+    <Compile Include="LegacyApi\MSBuild\SpecsRemovement.fs" />
+    <Compile Include="LegacyApi\Git\CommandHelper.fs" />
+    <Compile Include="LegacyApi\Git\Sha1.fs" />
+    <Compile Include="LegacyApi\Git\Repository.fs" />
+    <Compile Include="LegacyApi\Git\Submodule.fs" />
+    <Compile Include="LegacyApi\Git\Branches.fs" />
+    <Compile Include="LegacyApi\Git\Reset.fs" />
+    <Compile Include="LegacyApi\Git\Merge.fs" />
+    <Compile Include="LegacyApi\Git\Stash.fs" />
+    <Compile Include="LegacyApi\Git\SanityChecks.fs" />
+    <Compile Include="LegacyApi\Git\Information.fs" />
+    <Compile Include="LegacyApi\Git\FileStatus.fs" />
+    <Compile Include="LegacyApi\Git\Rebase.fs" />
+    <Compile Include="LegacyApi\Git\CommitMessage.fs" />
+    <Compile Include="LegacyApi\Git\Staging.fs" />
+    <Compile Include="LegacyApi\Git\Commit.fs" />
+    <Compile Include="LegacyApi\FSIHelper.fs" />
+    <Compile Include="LegacyApi\Boot.fs" />
+    <Compile Include="LegacyApi\MessageHelper.fs" />
+    <Compile Include="LegacyApi\HTMLHelpWorkShopHelper.fs" />
+    <Compile Include="LegacyApi\ConfigurationHelper.fs" />
+    <Compile Include="LegacyApi\TargetHelper.fs" />
+    <Compile Include="LegacyApi\AdditionalSyntax.fs" />
+    <Compile Include="LegacyApi\PermissionsHelper.fs" />
+    <Compile Include="LegacyApi\SpecFlowHelper.fs" />
+    <Compile Include="LegacyApi\OctoTools.fs" />
+    <Compile Include="LegacyApi\SignToolHelper.fs" />
+    <Compile Include="LegacyApi\MageHelper.fs" />
+    <Compile Include="LegacyApi\SemVerHelper.fs" />
+    <Compile Include="LegacyApi\ReleaseNotesHelper.fs" />
+    <Compile Include="LegacyApi\FixieHelper.fs" />
+    <Compile Include="LegacyApi\NuGet\NugetHelper.fs" />
+    <Compile Include="LegacyApi\NuGet\Update.fs" />
+    <Compile Include="LegacyApi\NuGet\Install.fs" />
+    <Compile Include="LegacyApi\NuGet\NugetVersion.fs" />
+    <Compile Include="LegacyApi\TestFlightHelper.fs" />
+    <Compile Include="LegacyApi\DotCover.fs" />
+    <Compile Include="LegacyApi\PaketHelper.fs" />
+    <Compile Include="LegacyApi\PaketTemplateHelper.fs" />
+    <Compile Include="LegacyApi\AzureHelper.fs" />
+    <Compile Include="LegacyApi\FtpHelper.fs" />
+    <Compile Include="LegacyApi\TypeScript.fs" />
+    <Compile Include="LegacyApi\OpenCoverHelper.fs" />
+    <Compile Include="LegacyApi\ReportGeneratorHelper.fs" />
+    <Compile Include="LegacyApi\RoundhouseHelper.fs" />
+    <Compile Include="LegacyApi\FscHelper.fs" />
+    <Compile Include="LegacyApi\CscHelper.fs" />
+    <Compile Include="LegacyApi\HipChatNotificationHelper.fs" />
+    <Compile Include="LegacyApi\XamarinHelper.fs" />
+    <Compile Include="LegacyApi\XDTHelper.fs" />
+    <Compile Include="LegacyApi\AzureWebJobs.fs" />
+    <Compile Include="LegacyApi\HockeyAppHelper.fs" />
+    <Compile Include="LegacyApi\AzureCloudServices.fs" />
+    <Compile Include="LegacyApi\Sxshelper.fs" />
+    <Compile Include="LegacyApi\Vb6helper.fs" />
+    <Compile Include="LegacyApi\AndroidPublisher.fs" />
+    <Compile Include="LegacyApi\ChangeWatcher.fs" />
+    <Compile Include="LegacyApi\CMake.fs" />
+    <Compile Include="LegacyApi\Sql.DacPac.fs" />
+    <Compile Include="LegacyApi\RaygunHelper.fs" />
+    <Compile Include="LegacyApi\SquirrelHelper.fs" />
+    <Compile Include="LegacyApi\XCopyHelper.fs" />
+    <Compile Include="LegacyApi\DynamicsCRMHelper.fs" />
+    <Compile Include="LegacyApi\Appcast.fs" />
+    <Compile Include="LegacyApi\PicklesHelper.fs" />
+    <Compile Include="LegacyApi\ChocoHelper.fs" />
+    <Compile Include="LegacyApi\SlackNotificationHelper.fs" />
+    <Compile Include="LegacyApi\SonarQubeHelper.fs" />
+    <Compile Include="LegacyApi\AzureKudu.fs" />
+    <Compile Include="LegacyApi\DocFxHelper.fs" />
     <None Include="Targets.fsx" />
-    <Compile Include="FixieHelper.fs" />
-    <Compile Include="NuGet\NugetHelper.fs" />
-    <Compile Include="NuGet\Update.fs" />
-    <Compile Include="NuGet\Install.fs" />
-    <Compile Include="NuGet\NugetVersion.fs" />
-    <Compile Include="TestFlightHelper.fs" />
-    <Compile Include="DotCover.fs" />
-    <Compile Include="PaketHelper.fs" />
-    <Compile Include="PaketTemplateHelper.fs" />
-    <Compile Include="AzureHelper.fs" />
-    <Compile Include="FtpHelper.fs" />
-    <Compile Include="TypeScript.fs" />
-    <Compile Include="OpenCoverHelper.fs" />
-    <Compile Include="ReportGeneratorHelper.fs" />
-    <Compile Include="RoundhouseHelper.fs" />
-    <Compile Include="FscHelper.fs" />
-    <Compile Include="CscHelper.fs" />
-    <Compile Include="HipChatNotificationHelper.fs" />
-    <Compile Include="XamarinHelper.fs" />
-    <Compile Include="XDTHelper.fs" />
-    <Compile Include="AzureWebJobs.fs" />
-    <Compile Include="HockeyAppHelper.fs" />
-    <Compile Include="AzureCloudServices.fs" />
-    <Compile Include="Sxshelper.fs" />
-    <Compile Include="Vb6helper.fs" />
-    <Compile Include="AndroidPublisher.fs" />
-    <Compile Include="ChangeWatcher.fs" />
-    <Compile Include="CMake.fs" />
     <None Include="app.config" />
-    <Compile Include="Sql.DacPac.fs" />
-    <Compile Include="RaygunHelper.fs" />
-    <Compile Include="SquirrelHelper.fs" />
-    <Compile Include="XCopyHelper.fs" />
-    <Compile Include="DynamicsCRMHelper.fs" />
-    <Compile Include="Appcast.fs" />
-    <Compile Include="PicklesHelper.fs" />
-    <Compile Include="ChocoHelper.fs" />
-    <Compile Include="SlackNotificationHelper.fs" />
-    <Compile Include="SonarQubeHelper.fs" />
-    <Compile Include="AzureKudu.fs" />
-    <Compile Include="DocFxHelper.fs" />
+    <None Include="paket.references" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="ICSharpCode.SharpZipLib">
diff --git a/src/app/FakeLib/AdditionalSyntax.fs b/src/app/FakeLib/LegacyApi/AdditionalSyntax.fs
similarity index 100%
rename from src/app/FakeLib/AdditionalSyntax.fs
rename to src/app/FakeLib/LegacyApi/AdditionalSyntax.fs
diff --git a/src/app/FakeLib/AndroidPublisher.fs b/src/app/FakeLib/LegacyApi/AndroidPublisher.fs
similarity index 100%
rename from src/app/FakeLib/AndroidPublisher.fs
rename to src/app/FakeLib/LegacyApi/AndroidPublisher.fs
diff --git a/src/app/FakeLib/AppVeyor.fs b/src/app/FakeLib/LegacyApi/AppVeyor.fs
similarity index 99%
rename from src/app/FakeLib/AppVeyor.fs
rename to src/app/FakeLib/LegacyApi/AppVeyor.fs
index ef612d6cd4d..371ec509dd3 100644
--- a/src/app/FakeLib/AppVeyor.fs
+++ b/src/app/FakeLib/LegacyApi/AppVeyor.fs
@@ -1,6 +1,7 @@
 /// Contains code to configure FAKE for AppVeyor integration
 module Fake.AppVeyor
 
+open Fake
 open System.IO
 
 /// AppVeyor environment variables as [described](http://www.appveyor.com/docs/environment-variables)
diff --git a/src/app/FakeLib/Appcast.fs b/src/app/FakeLib/LegacyApi/Appcast.fs
similarity index 100%
rename from src/app/FakeLib/Appcast.fs
rename to src/app/FakeLib/LegacyApi/Appcast.fs
diff --git a/src/app/FakeLib/ArchiveHelper.fs b/src/app/FakeLib/LegacyApi/ArchiveHelper.fs
similarity index 100%
rename from src/app/FakeLib/ArchiveHelper.fs
rename to src/app/FakeLib/LegacyApi/ArchiveHelper.fs
diff --git a/src/app/FakeLib/AssemblyInfoFile.fs b/src/app/FakeLib/LegacyApi/AssemblyInfoFile.fs
similarity index 100%
rename from src/app/FakeLib/AssemblyInfoFile.fs
rename to src/app/FakeLib/LegacyApi/AssemblyInfoFile.fs
diff --git a/src/app/FakeLib/AssemblyInfoHelper.fs b/src/app/FakeLib/LegacyApi/AssemblyInfoHelper.fs
similarity index 100%
rename from src/app/FakeLib/AssemblyInfoHelper.fs
rename to src/app/FakeLib/LegacyApi/AssemblyInfoHelper.fs
diff --git a/src/app/FakeLib/AzureCloudServices.fs b/src/app/FakeLib/LegacyApi/AzureCloudServices.fs
similarity index 100%
rename from src/app/FakeLib/AzureCloudServices.fs
rename to src/app/FakeLib/LegacyApi/AzureCloudServices.fs
diff --git a/src/app/FakeLib/AzureHelper.fs b/src/app/FakeLib/LegacyApi/AzureHelper.fs
similarity index 100%
rename from src/app/FakeLib/AzureHelper.fs
rename to src/app/FakeLib/LegacyApi/AzureHelper.fs
diff --git a/src/app/FakeLib/AzureKudu.fs b/src/app/FakeLib/LegacyApi/AzureKudu.fs
similarity index 100%
rename from src/app/FakeLib/AzureKudu.fs
rename to src/app/FakeLib/LegacyApi/AzureKudu.fs
diff --git a/src/app/FakeLib/AzureWebJobs.fs b/src/app/FakeLib/LegacyApi/AzureWebJobs.fs
similarity index 100%
rename from src/app/FakeLib/AzureWebJobs.fs
rename to src/app/FakeLib/LegacyApi/AzureWebJobs.fs
diff --git a/src/app/FakeLib/BitbucketPipelines.fs b/src/app/FakeLib/LegacyApi/BitbucketPipelines.fs
similarity index 100%
rename from src/app/FakeLib/BitbucketPipelines.fs
rename to src/app/FakeLib/LegacyApi/BitbucketPipelines.fs
diff --git a/src/app/FakeLib/Boot.fs b/src/app/FakeLib/LegacyApi/Boot.fs
similarity index 100%
rename from src/app/FakeLib/Boot.fs
rename to src/app/FakeLib/LegacyApi/Boot.fs
diff --git a/src/app/FakeLib/BowerHelper.fs b/src/app/FakeLib/LegacyApi/BowerHelper.fs
similarity index 100%
rename from src/app/FakeLib/BowerHelper.fs
rename to src/app/FakeLib/LegacyApi/BowerHelper.fs
diff --git a/src/app/FakeLib/BuildServerHelper.fs b/src/app/FakeLib/LegacyApi/BuildServerHelper.fs
similarity index 100%
rename from src/app/FakeLib/BuildServerHelper.fs
rename to src/app/FakeLib/LegacyApi/BuildServerHelper.fs
diff --git a/src/app/FakeLib/CMake.fs b/src/app/FakeLib/LegacyApi/CMake.fs
similarity index 100%
rename from src/app/FakeLib/CMake.fs
rename to src/app/FakeLib/LegacyApi/CMake.fs
diff --git a/src/app/FakeLib/CSharpHelper.fs b/src/app/FakeLib/LegacyApi/CSharpHelper.fs
similarity index 100%
rename from src/app/FakeLib/CSharpHelper.fs
rename to src/app/FakeLib/LegacyApi/CSharpHelper.fs
diff --git a/src/app/FakeLib/CacheHelper.fs b/src/app/FakeLib/LegacyApi/CacheHelper.fs
similarity index 100%
rename from src/app/FakeLib/CacheHelper.fs
rename to src/app/FakeLib/LegacyApi/CacheHelper.fs
diff --git a/src/app/FakeLib/ChangeWatcher.fs b/src/app/FakeLib/LegacyApi/ChangeWatcher.fs
similarity index 100%
rename from src/app/FakeLib/ChangeWatcher.fs
rename to src/app/FakeLib/LegacyApi/ChangeWatcher.fs
diff --git a/src/app/FakeLib/ChocoHelper.fs b/src/app/FakeLib/LegacyApi/ChocoHelper.fs
similarity index 100%
rename from src/app/FakeLib/ChocoHelper.fs
rename to src/app/FakeLib/LegacyApi/ChocoHelper.fs
diff --git a/src/app/FakeLib/ConfigurationHelper.fs b/src/app/FakeLib/LegacyApi/ConfigurationHelper.fs
similarity index 100%
rename from src/app/FakeLib/ConfigurationHelper.fs
rename to src/app/FakeLib/LegacyApi/ConfigurationHelper.fs
diff --git a/src/app/FakeLib/CscHelper.fs b/src/app/FakeLib/LegacyApi/CscHelper.fs
similarity index 100%
rename from src/app/FakeLib/CscHelper.fs
rename to src/app/FakeLib/LegacyApi/CscHelper.fs
diff --git a/src/app/FakeLib/DocFxHelper.fs b/src/app/FakeLib/LegacyApi/DocFxHelper.fs
similarity index 100%
rename from src/app/FakeLib/DocFxHelper.fs
rename to src/app/FakeLib/LegacyApi/DocFxHelper.fs
diff --git a/src/app/FakeLib/DocuHelper.fs b/src/app/FakeLib/LegacyApi/DocuHelper.fs
similarity index 100%
rename from src/app/FakeLib/DocuHelper.fs
rename to src/app/FakeLib/LegacyApi/DocuHelper.fs
diff --git a/src/app/FakeLib/DotCover.fs b/src/app/FakeLib/LegacyApi/DotCover.fs
similarity index 100%
rename from src/app/FakeLib/DotCover.fs
rename to src/app/FakeLib/LegacyApi/DotCover.fs
diff --git a/src/app/FakeLib/DynamicsCRMHelper.fs b/src/app/FakeLib/LegacyApi/DynamicsCRMHelper.fs
similarity index 100%
rename from src/app/FakeLib/DynamicsCRMHelper.fs
rename to src/app/FakeLib/LegacyApi/DynamicsCRMHelper.fs
diff --git a/src/app/FakeLib/DynamicsNavFile.fs b/src/app/FakeLib/LegacyApi/DynamicsNavFile.fs
similarity index 100%
rename from src/app/FakeLib/DynamicsNavFile.fs
rename to src/app/FakeLib/LegacyApi/DynamicsNavFile.fs
diff --git a/src/app/FakeLib/DynamicsNavHelper.fs b/src/app/FakeLib/LegacyApi/DynamicsNavHelper.fs
similarity index 100%
rename from src/app/FakeLib/DynamicsNavHelper.fs
rename to src/app/FakeLib/LegacyApi/DynamicsNavHelper.fs
diff --git a/src/app/FakeLib/EnvironmentHelper.fs b/src/app/FakeLib/LegacyApi/EnvironmentHelper.fs
similarity index 100%
rename from src/app/FakeLib/EnvironmentHelper.fs
rename to src/app/FakeLib/LegacyApi/EnvironmentHelper.fs
diff --git a/src/app/FakeLib/FSIHelper.fs b/src/app/FakeLib/LegacyApi/FSIHelper.fs
similarity index 100%
rename from src/app/FakeLib/FSIHelper.fs
rename to src/app/FakeLib/LegacyApi/FSIHelper.fs
diff --git a/src/app/FakeLib/FSharpFormattingHelper.fs b/src/app/FakeLib/LegacyApi/FSharpFormattingHelper.fs
similarity index 100%
rename from src/app/FakeLib/FSharpFormattingHelper.fs
rename to src/app/FakeLib/LegacyApi/FSharpFormattingHelper.fs
diff --git a/src/app/FakeLib/FXCopHelper.fs b/src/app/FakeLib/LegacyApi/FXCopHelper.fs
similarity index 100%
rename from src/app/FakeLib/FXCopHelper.fs
rename to src/app/FakeLib/LegacyApi/FXCopHelper.fs
diff --git a/src/app/FakeLib/FileHelper.fs b/src/app/FakeLib/LegacyApi/FileHelper.fs
similarity index 100%
rename from src/app/FakeLib/FileHelper.fs
rename to src/app/FakeLib/LegacyApi/FileHelper.fs
diff --git a/src/app/FakeLib/FileSystemHelper.fs b/src/app/FakeLib/LegacyApi/FileSystemHelper.fs
similarity index 100%
rename from src/app/FakeLib/FileSystemHelper.fs
rename to src/app/FakeLib/LegacyApi/FileSystemHelper.fs
diff --git a/src/app/FakeLib/FileUtils.fs b/src/app/FakeLib/LegacyApi/FileUtils.fs
similarity index 100%
rename from src/app/FakeLib/FileUtils.fs
rename to src/app/FakeLib/LegacyApi/FileUtils.fs
diff --git a/src/app/FakeLib/FixieHelper.fs b/src/app/FakeLib/LegacyApi/FixieHelper.fs
similarity index 100%
rename from src/app/FakeLib/FixieHelper.fs
rename to src/app/FakeLib/LegacyApi/FixieHelper.fs
diff --git a/src/app/FakeLib/FscHelper.fs b/src/app/FakeLib/LegacyApi/FscHelper.fs
similarity index 100%
rename from src/app/FakeLib/FscHelper.fs
rename to src/app/FakeLib/LegacyApi/FscHelper.fs
diff --git a/src/app/FakeLib/FtpHelper.fs b/src/app/FakeLib/LegacyApi/FtpHelper.fs
similarity index 100%
rename from src/app/FakeLib/FtpHelper.fs
rename to src/app/FakeLib/LegacyApi/FtpHelper.fs
diff --git a/src/app/FakeLib/FuchuHelper.fs b/src/app/FakeLib/LegacyApi/FuchuHelper.fs
similarity index 100%
rename from src/app/FakeLib/FuchuHelper.fs
rename to src/app/FakeLib/LegacyApi/FuchuHelper.fs
diff --git a/src/app/FakeLib/GACHelper.fs b/src/app/FakeLib/LegacyApi/GACHelper.fs
similarity index 100%
rename from src/app/FakeLib/GACHelper.fs
rename to src/app/FakeLib/LegacyApi/GACHelper.fs
diff --git a/src/app/FakeLib/Git/Branches.fs b/src/app/FakeLib/LegacyApi/Git/Branches.fs
similarity index 100%
rename from src/app/FakeLib/Git/Branches.fs
rename to src/app/FakeLib/LegacyApi/Git/Branches.fs
diff --git a/src/app/FakeLib/Git/CommandHelper.fs b/src/app/FakeLib/LegacyApi/Git/CommandHelper.fs
similarity index 100%
rename from src/app/FakeLib/Git/CommandHelper.fs
rename to src/app/FakeLib/LegacyApi/Git/CommandHelper.fs
diff --git a/src/app/FakeLib/Git/Commit.fs b/src/app/FakeLib/LegacyApi/Git/Commit.fs
similarity index 100%
rename from src/app/FakeLib/Git/Commit.fs
rename to src/app/FakeLib/LegacyApi/Git/Commit.fs
diff --git a/src/app/FakeLib/Git/CommitMessage.fs b/src/app/FakeLib/LegacyApi/Git/CommitMessage.fs
similarity index 100%
rename from src/app/FakeLib/Git/CommitMessage.fs
rename to src/app/FakeLib/LegacyApi/Git/CommitMessage.fs
diff --git a/src/app/FakeLib/Git/FileStatus.fs b/src/app/FakeLib/LegacyApi/Git/FileStatus.fs
similarity index 100%
rename from src/app/FakeLib/Git/FileStatus.fs
rename to src/app/FakeLib/LegacyApi/Git/FileStatus.fs
diff --git a/src/app/FakeLib/Git/Information.fs b/src/app/FakeLib/LegacyApi/Git/Information.fs
similarity index 100%
rename from src/app/FakeLib/Git/Information.fs
rename to src/app/FakeLib/LegacyApi/Git/Information.fs
diff --git a/src/app/FakeLib/Git/Merge.fs b/src/app/FakeLib/LegacyApi/Git/Merge.fs
similarity index 100%
rename from src/app/FakeLib/Git/Merge.fs
rename to src/app/FakeLib/LegacyApi/Git/Merge.fs
diff --git a/src/app/FakeLib/Git/Rebase.fs b/src/app/FakeLib/LegacyApi/Git/Rebase.fs
similarity index 100%
rename from src/app/FakeLib/Git/Rebase.fs
rename to src/app/FakeLib/LegacyApi/Git/Rebase.fs
diff --git a/src/app/FakeLib/Git/Repository.fs b/src/app/FakeLib/LegacyApi/Git/Repository.fs
similarity index 100%
rename from src/app/FakeLib/Git/Repository.fs
rename to src/app/FakeLib/LegacyApi/Git/Repository.fs
diff --git a/src/app/FakeLib/Git/Reset.fs b/src/app/FakeLib/LegacyApi/Git/Reset.fs
similarity index 100%
rename from src/app/FakeLib/Git/Reset.fs
rename to src/app/FakeLib/LegacyApi/Git/Reset.fs
diff --git a/src/app/FakeLib/Git/SanityChecks.fs b/src/app/FakeLib/LegacyApi/Git/SanityChecks.fs
similarity index 100%
rename from src/app/FakeLib/Git/SanityChecks.fs
rename to src/app/FakeLib/LegacyApi/Git/SanityChecks.fs
diff --git a/src/app/FakeLib/Git/Sha1.fs b/src/app/FakeLib/LegacyApi/Git/Sha1.fs
similarity index 100%
rename from src/app/FakeLib/Git/Sha1.fs
rename to src/app/FakeLib/LegacyApi/Git/Sha1.fs
diff --git a/src/app/FakeLib/Git/Staging.fs b/src/app/FakeLib/LegacyApi/Git/Staging.fs
similarity index 100%
rename from src/app/FakeLib/Git/Staging.fs
rename to src/app/FakeLib/LegacyApi/Git/Staging.fs
diff --git a/src/app/FakeLib/Git/Stash.fs b/src/app/FakeLib/LegacyApi/Git/Stash.fs
similarity index 100%
rename from src/app/FakeLib/Git/Stash.fs
rename to src/app/FakeLib/LegacyApi/Git/Stash.fs
diff --git a/src/app/FakeLib/Git/Submodule.fs b/src/app/FakeLib/LegacyApi/Git/Submodule.fs
similarity index 100%
rename from src/app/FakeLib/Git/Submodule.fs
rename to src/app/FakeLib/LegacyApi/Git/Submodule.fs
diff --git a/src/app/FakeLib/Globbing/FileSystem.fs b/src/app/FakeLib/LegacyApi/Globbing/FileSystem.fs
similarity index 100%
rename from src/app/FakeLib/Globbing/FileSystem.fs
rename to src/app/FakeLib/LegacyApi/Globbing/FileSystem.fs
diff --git a/src/app/FakeLib/Globbing/Globbing.fs b/src/app/FakeLib/LegacyApi/Globbing/Globbing.fs
similarity index 100%
rename from src/app/FakeLib/Globbing/Globbing.fs
rename to src/app/FakeLib/LegacyApi/Globbing/Globbing.fs
diff --git a/src/app/FakeLib/GuardedAwaitObservable.fs b/src/app/FakeLib/LegacyApi/GuardedAwaitObservable.fs
similarity index 100%
rename from src/app/FakeLib/GuardedAwaitObservable.fs
rename to src/app/FakeLib/LegacyApi/GuardedAwaitObservable.fs
diff --git a/src/app/FakeLib/HTMLHelpWorkShopHelper.fs b/src/app/FakeLib/LegacyApi/HTMLHelpWorkShopHelper.fs
similarity index 100%
rename from src/app/FakeLib/HTMLHelpWorkShopHelper.fs
rename to src/app/FakeLib/LegacyApi/HTMLHelpWorkShopHelper.fs
diff --git a/src/app/FakeLib/HipChatNotificationHelper.fs b/src/app/FakeLib/LegacyApi/HipChatNotificationHelper.fs
similarity index 100%
rename from src/app/FakeLib/HipChatNotificationHelper.fs
rename to src/app/FakeLib/LegacyApi/HipChatNotificationHelper.fs
diff --git a/src/app/FakeLib/HockeyAppHelper.fs b/src/app/FakeLib/LegacyApi/HockeyAppHelper.fs
similarity index 100%
rename from src/app/FakeLib/HockeyAppHelper.fs
rename to src/app/FakeLib/LegacyApi/HockeyAppHelper.fs
diff --git a/src/app/FakeLib/ILMergeHelper.fs b/src/app/FakeLib/LegacyApi/ILMergeHelper.fs
similarity index 100%
rename from src/app/FakeLib/ILMergeHelper.fs
rename to src/app/FakeLib/LegacyApi/ILMergeHelper.fs
diff --git a/src/app/FakeLib/MSBuild/ProjectSystem.fs b/src/app/FakeLib/LegacyApi/MSBuild/ProjectSystem.fs
similarity index 100%
rename from src/app/FakeLib/MSBuild/ProjectSystem.fs
rename to src/app/FakeLib/LegacyApi/MSBuild/ProjectSystem.fs
diff --git a/src/app/FakeLib/MSBuild/SpecsRemovement.fs b/src/app/FakeLib/LegacyApi/MSBuild/SpecsRemovement.fs
similarity index 100%
rename from src/app/FakeLib/MSBuild/SpecsRemovement.fs
rename to src/app/FakeLib/LegacyApi/MSBuild/SpecsRemovement.fs
diff --git a/src/app/FakeLib/MSBuildHelper.fs b/src/app/FakeLib/LegacyApi/MSBuildHelper.fs
similarity index 100%
rename from src/app/FakeLib/MSBuildHelper.fs
rename to src/app/FakeLib/LegacyApi/MSBuildHelper.fs
diff --git a/src/app/FakeLib/MSIHelper.fs b/src/app/FakeLib/LegacyApi/MSIHelper.fs
similarity index 100%
rename from src/app/FakeLib/MSIHelper.fs
rename to src/app/FakeLib/LegacyApi/MSIHelper.fs
diff --git a/src/app/FakeLib/MageHelper.fs b/src/app/FakeLib/LegacyApi/MageHelper.fs
similarity index 100%
rename from src/app/FakeLib/MageHelper.fs
rename to src/app/FakeLib/LegacyApi/MageHelper.fs
diff --git a/src/app/FakeLib/MessageHelper.fs b/src/app/FakeLib/LegacyApi/MessageHelper.fs
similarity index 100%
rename from src/app/FakeLib/MessageHelper.fs
rename to src/app/FakeLib/LegacyApi/MessageHelper.fs
diff --git a/src/app/FakeLib/MsBuildLogger.fs b/src/app/FakeLib/LegacyApi/MsBuildLogger.fs
similarity index 100%
rename from src/app/FakeLib/MsBuildLogger.fs
rename to src/app/FakeLib/LegacyApi/MsBuildLogger.fs
diff --git a/src/app/FakeLib/NCoverHelper.fs b/src/app/FakeLib/LegacyApi/NCoverHelper.fs
similarity index 100%
rename from src/app/FakeLib/NCoverHelper.fs
rename to src/app/FakeLib/LegacyApi/NCoverHelper.fs
diff --git a/src/app/FakeLib/NDependHelper.fs b/src/app/FakeLib/LegacyApi/NDependHelper.fs
similarity index 100%
rename from src/app/FakeLib/NDependHelper.fs
rename to src/app/FakeLib/LegacyApi/NDependHelper.fs
diff --git a/src/app/FakeLib/NGenHelper.fs b/src/app/FakeLib/LegacyApi/NGenHelper.fs
similarity index 100%
rename from src/app/FakeLib/NGenHelper.fs
rename to src/app/FakeLib/LegacyApi/NGenHelper.fs
diff --git a/src/app/FakeLib/NpmHelper.fs b/src/app/FakeLib/LegacyApi/NpmHelper.fs
similarity index 100%
rename from src/app/FakeLib/NpmHelper.fs
rename to src/app/FakeLib/LegacyApi/NpmHelper.fs
diff --git a/src/app/FakeLib/NuGet/Install.fs b/src/app/FakeLib/LegacyApi/NuGet/Install.fs
similarity index 100%
rename from src/app/FakeLib/NuGet/Install.fs
rename to src/app/FakeLib/LegacyApi/NuGet/Install.fs
diff --git a/src/app/FakeLib/NuGet/NugetHelper.fs b/src/app/FakeLib/LegacyApi/NuGet/NugetHelper.fs
similarity index 100%
rename from src/app/FakeLib/NuGet/NugetHelper.fs
rename to src/app/FakeLib/LegacyApi/NuGet/NugetHelper.fs
diff --git a/src/app/FakeLib/NuGet/NugetVersion.fs b/src/app/FakeLib/LegacyApi/NuGet/NugetVersion.fs
similarity index 100%
rename from src/app/FakeLib/NuGet/NugetVersion.fs
rename to src/app/FakeLib/LegacyApi/NuGet/NugetVersion.fs
diff --git a/src/app/FakeLib/NuGet/Update.fs b/src/app/FakeLib/LegacyApi/NuGet/Update.fs
similarity index 100%
rename from src/app/FakeLib/NuGet/Update.fs
rename to src/app/FakeLib/LegacyApi/NuGet/Update.fs
diff --git a/src/app/FakeLib/OctoTools.fs b/src/app/FakeLib/LegacyApi/OctoTools.fs
similarity index 100%
rename from src/app/FakeLib/OctoTools.fs
rename to src/app/FakeLib/LegacyApi/OctoTools.fs
diff --git a/src/app/FakeLib/OpenCoverHelper.fs b/src/app/FakeLib/LegacyApi/OpenCoverHelper.fs
similarity index 100%
rename from src/app/FakeLib/OpenCoverHelper.fs
rename to src/app/FakeLib/LegacyApi/OpenCoverHelper.fs
diff --git a/src/app/FakeLib/PaketHelper.fs b/src/app/FakeLib/LegacyApi/PaketHelper.fs
old mode 100755
new mode 100644
similarity index 100%
rename from src/app/FakeLib/PaketHelper.fs
rename to src/app/FakeLib/LegacyApi/PaketHelper.fs
diff --git a/src/app/FakeLib/PaketTemplateHelper.fs b/src/app/FakeLib/LegacyApi/PaketTemplateHelper.fs
similarity index 100%
rename from src/app/FakeLib/PaketTemplateHelper.fs
rename to src/app/FakeLib/LegacyApi/PaketTemplateHelper.fs
diff --git a/src/app/FakeLib/PermissionsHelper.fs b/src/app/FakeLib/LegacyApi/PermissionsHelper.fs
similarity index 100%
rename from src/app/FakeLib/PermissionsHelper.fs
rename to src/app/FakeLib/LegacyApi/PermissionsHelper.fs
diff --git a/src/app/FakeLib/PicklesHelper.fs b/src/app/FakeLib/LegacyApi/PicklesHelper.fs
similarity index 100%
rename from src/app/FakeLib/PicklesHelper.fs
rename to src/app/FakeLib/LegacyApi/PicklesHelper.fs
diff --git a/src/app/FakeLib/ProcessHelper.fs b/src/app/FakeLib/LegacyApi/ProcessHelper.fs
similarity index 100%
rename from src/app/FakeLib/ProcessHelper.fs
rename to src/app/FakeLib/LegacyApi/ProcessHelper.fs
diff --git a/src/app/FakeLib/PsExecHelper.fs b/src/app/FakeLib/LegacyApi/PsExecHelper.fs
similarity index 100%
rename from src/app/FakeLib/PsExecHelper.fs
rename to src/app/FakeLib/LegacyApi/PsExecHelper.fs
diff --git a/src/app/FakeLib/REST.fs b/src/app/FakeLib/LegacyApi/REST.fs
similarity index 100%
rename from src/app/FakeLib/REST.fs
rename to src/app/FakeLib/LegacyApi/REST.fs
diff --git a/src/app/FakeLib/RaygunHelper.fs b/src/app/FakeLib/LegacyApi/RaygunHelper.fs
similarity index 100%
rename from src/app/FakeLib/RaygunHelper.fs
rename to src/app/FakeLib/LegacyApi/RaygunHelper.fs
diff --git a/src/app/FakeLib/RegAsmHelper.fs b/src/app/FakeLib/LegacyApi/RegAsmHelper.fs
similarity index 100%
rename from src/app/FakeLib/RegAsmHelper.fs
rename to src/app/FakeLib/LegacyApi/RegAsmHelper.fs
diff --git a/src/app/FakeLib/RegistryHelper.fs b/src/app/FakeLib/LegacyApi/RegistryHelper.fs
similarity index 100%
rename from src/app/FakeLib/RegistryHelper.fs
rename to src/app/FakeLib/LegacyApi/RegistryHelper.fs
diff --git a/src/app/FakeLib/ReleaseNotesHelper.fs b/src/app/FakeLib/LegacyApi/ReleaseNotesHelper.fs
similarity index 100%
rename from src/app/FakeLib/ReleaseNotesHelper.fs
rename to src/app/FakeLib/LegacyApi/ReleaseNotesHelper.fs
diff --git a/src/app/FakeLib/ReportGeneratorHelper.fs b/src/app/FakeLib/LegacyApi/ReportGeneratorHelper.fs
similarity index 100%
rename from src/app/FakeLib/ReportGeneratorHelper.fs
rename to src/app/FakeLib/LegacyApi/ReportGeneratorHelper.fs
diff --git a/src/app/FakeLib/RestorePackageHelper.fs b/src/app/FakeLib/LegacyApi/RestorePackageHelper.fs
old mode 100755
new mode 100644
similarity index 100%
rename from src/app/FakeLib/RestorePackageHelper.fs
rename to src/app/FakeLib/LegacyApi/RestorePackageHelper.fs
diff --git a/src/app/FakeLib/RoboCopyHelper.fs b/src/app/FakeLib/LegacyApi/RoboCopyHelper.fs
similarity index 100%
rename from src/app/FakeLib/RoboCopyHelper.fs
rename to src/app/FakeLib/LegacyApi/RoboCopyHelper.fs
diff --git a/src/app/FakeLib/RoundhouseHelper.fs b/src/app/FakeLib/LegacyApi/RoundhouseHelper.fs
similarity index 100%
rename from src/app/FakeLib/RoundhouseHelper.fs
rename to src/app/FakeLib/LegacyApi/RoundhouseHelper.fs
diff --git a/src/app/FakeLib/SCPHelper.fs b/src/app/FakeLib/LegacyApi/SCPHelper.fs
similarity index 100%
rename from src/app/FakeLib/SCPHelper.fs
rename to src/app/FakeLib/LegacyApi/SCPHelper.fs
diff --git a/src/app/FakeLib/SemVerHelper.fs b/src/app/FakeLib/LegacyApi/SemVerHelper.fs
similarity index 100%
rename from src/app/FakeLib/SemVerHelper.fs
rename to src/app/FakeLib/LegacyApi/SemVerHelper.fs
diff --git a/src/app/FakeLib/ServiceControllerHelper.fs b/src/app/FakeLib/LegacyApi/ServiceControllerHelper.fs
similarity index 100%
rename from src/app/FakeLib/ServiceControllerHelper.fs
rename to src/app/FakeLib/LegacyApi/ServiceControllerHelper.fs
diff --git a/src/app/FakeLib/SignToolHelper.fs b/src/app/FakeLib/LegacyApi/SignToolHelper.fs
similarity index 100%
rename from src/app/FakeLib/SignToolHelper.fs
rename to src/app/FakeLib/LegacyApi/SignToolHelper.fs
diff --git a/src/app/FakeLib/SlackNotificationHelper.fs b/src/app/FakeLib/LegacyApi/SlackNotificationHelper.fs
similarity index 100%
rename from src/app/FakeLib/SlackNotificationHelper.fs
rename to src/app/FakeLib/LegacyApi/SlackNotificationHelper.fs
diff --git a/src/app/FakeLib/SonarQubeHelper.fs b/src/app/FakeLib/LegacyApi/SonarQubeHelper.fs
similarity index 100%
rename from src/app/FakeLib/SonarQubeHelper.fs
rename to src/app/FakeLib/LegacyApi/SonarQubeHelper.fs
diff --git a/src/app/FakeLib/SpecFlowHelper.fs b/src/app/FakeLib/LegacyApi/SpecFlowHelper.fs
similarity index 100%
rename from src/app/FakeLib/SpecFlowHelper.fs
rename to src/app/FakeLib/LegacyApi/SpecFlowHelper.fs
diff --git a/src/app/FakeLib/Sql.DacPac.fs b/src/app/FakeLib/LegacyApi/Sql.DacPac.fs
similarity index 100%
rename from src/app/FakeLib/Sql.DacPac.fs
rename to src/app/FakeLib/LegacyApi/Sql.DacPac.fs
diff --git a/src/app/FakeLib/SquirrelHelper.fs b/src/app/FakeLib/LegacyApi/SquirrelHelper.fs
similarity index 100%
rename from src/app/FakeLib/SquirrelHelper.fs
rename to src/app/FakeLib/LegacyApi/SquirrelHelper.fs
diff --git a/src/app/FakeLib/StringHelper.fs b/src/app/FakeLib/LegacyApi/StringHelper.fs
similarity index 100%
rename from src/app/FakeLib/StringHelper.fs
rename to src/app/FakeLib/LegacyApi/StringHelper.fs
diff --git a/src/app/FakeLib/StrongNamingHelper.fs b/src/app/FakeLib/LegacyApi/StrongNamingHelper.fs
similarity index 100%
rename from src/app/FakeLib/StrongNamingHelper.fs
rename to src/app/FakeLib/LegacyApi/StrongNamingHelper.fs
diff --git a/src/app/FakeLib/Sxshelper.fs b/src/app/FakeLib/LegacyApi/Sxshelper.fs
similarity index 100%
rename from src/app/FakeLib/Sxshelper.fs
rename to src/app/FakeLib/LegacyApi/Sxshelper.fs
diff --git a/src/app/FakeLib/TargetHelper.fs b/src/app/FakeLib/LegacyApi/TargetHelper.fs
similarity index 100%
rename from src/app/FakeLib/TargetHelper.fs
rename to src/app/FakeLib/LegacyApi/TargetHelper.fs
diff --git a/src/app/FakeLib/TaskRunnerHelper.fs b/src/app/FakeLib/LegacyApi/TaskRunnerHelper.fs
similarity index 100%
rename from src/app/FakeLib/TaskRunnerHelper.fs
rename to src/app/FakeLib/LegacyApi/TaskRunnerHelper.fs
diff --git a/src/app/FakeLib/TeamCityHelper.fs b/src/app/FakeLib/LegacyApi/TeamCityHelper.fs
similarity index 100%
rename from src/app/FakeLib/TeamCityHelper.fs
rename to src/app/FakeLib/LegacyApi/TeamCityHelper.fs
diff --git a/src/app/FakeLib/TeamCityRESTHelper.fs b/src/app/FakeLib/LegacyApi/TeamCityRESTHelper.fs
similarity index 100%
rename from src/app/FakeLib/TeamCityRESTHelper.fs
rename to src/app/FakeLib/LegacyApi/TeamCityRESTHelper.fs
diff --git a/src/app/FakeLib/TemplateHelper.fs b/src/app/FakeLib/LegacyApi/TemplateHelper.fs
similarity index 100%
rename from src/app/FakeLib/TemplateHelper.fs
rename to src/app/FakeLib/LegacyApi/TemplateHelper.fs
diff --git a/src/app/FakeLib/TestFlightHelper.fs b/src/app/FakeLib/LegacyApi/TestFlightHelper.fs
similarity index 100%
rename from src/app/FakeLib/TestFlightHelper.fs
rename to src/app/FakeLib/LegacyApi/TestFlightHelper.fs
diff --git a/src/app/FakeLib/TraceHelper.fs b/src/app/FakeLib/LegacyApi/TraceHelper.fs
similarity index 100%
rename from src/app/FakeLib/TraceHelper.fs
rename to src/app/FakeLib/LegacyApi/TraceHelper.fs
diff --git a/src/app/FakeLib/TraceListener.fs b/src/app/FakeLib/LegacyApi/TraceListener.fs
similarity index 100%
rename from src/app/FakeLib/TraceListener.fs
rename to src/app/FakeLib/LegacyApi/TraceListener.fs
diff --git a/src/app/FakeLib/TypeScript.fs b/src/app/FakeLib/LegacyApi/TypeScript.fs
similarity index 100%
rename from src/app/FakeLib/TypeScript.fs
rename to src/app/FakeLib/LegacyApi/TypeScript.fs
diff --git a/src/app/FakeLib/UnitTest/MSTest.fs b/src/app/FakeLib/LegacyApi/UnitTest/MSTest.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/MSTest.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/MSTest.fs
diff --git a/src/app/FakeLib/UnitTest/MSpecHelper.fs b/src/app/FakeLib/LegacyApi/UnitTest/MSpecHelper.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/MSpecHelper.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/MSpecHelper.fs
diff --git a/src/app/FakeLib/UnitTest/NUnit/Common.fs b/src/app/FakeLib/LegacyApi/UnitTest/NUnit/Common.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/NUnit/Common.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/NUnit/Common.fs
diff --git a/src/app/FakeLib/UnitTest/NUnit/NUnit3.fs b/src/app/FakeLib/LegacyApi/UnitTest/NUnit/NUnit3.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/NUnit/NUnit3.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/NUnit/NUnit3.fs
diff --git a/src/app/FakeLib/UnitTest/NUnit/Parallel.fs b/src/app/FakeLib/LegacyApi/UnitTest/NUnit/Parallel.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/NUnit/Parallel.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/NUnit/Parallel.fs
diff --git a/src/app/FakeLib/UnitTest/NUnit/Sequential.fs b/src/app/FakeLib/LegacyApi/UnitTest/NUnit/Sequential.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/NUnit/Sequential.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/NUnit/Sequential.fs
diff --git a/src/app/FakeLib/UnitTest/NUnit/Xml.fs b/src/app/FakeLib/LegacyApi/UnitTest/NUnit/Xml.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/NUnit/Xml.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/NUnit/Xml.fs
diff --git a/src/app/FakeLib/UnitTest/ProcessTestRunner.fs b/src/app/FakeLib/LegacyApi/UnitTest/ProcessTestRunner.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/ProcessTestRunner.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/ProcessTestRunner.fs
diff --git a/src/app/FakeLib/UnitTest/UnitTestCommon.fs b/src/app/FakeLib/LegacyApi/UnitTest/UnitTestCommon.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/UnitTestCommon.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/UnitTestCommon.fs
diff --git a/src/app/FakeLib/UnitTest/UnitTestHelper.fs b/src/app/FakeLib/LegacyApi/UnitTest/UnitTestHelper.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/UnitTestHelper.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/UnitTestHelper.fs
diff --git a/src/app/FakeLib/UnitTest/VSTest.fs b/src/app/FakeLib/LegacyApi/UnitTest/VSTest.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/VSTest.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/VSTest.fs
diff --git a/src/app/FakeLib/UnitTest/XUnit/XUnit.fs b/src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/XUnit/XUnit.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit.fs
diff --git a/src/app/FakeLib/UnitTest/XUnit/XUnit2.fs b/src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit2.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/XUnit/XUnit2.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit2.fs
diff --git a/src/app/FakeLib/UnitTest/XUnit/XUnit2Helper.fs b/src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit2Helper.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/XUnit/XUnit2Helper.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnit2Helper.fs
diff --git a/src/app/FakeLib/UnitTest/XUnit/XUnitHelper.fs b/src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnitHelper.fs
similarity index 100%
rename from src/app/FakeLib/UnitTest/XUnit/XUnitHelper.fs
rename to src/app/FakeLib/LegacyApi/UnitTest/XUnit/XUnitHelper.fs
diff --git a/src/app/FakeLib/UserInputHelper.fs b/src/app/FakeLib/LegacyApi/UserInputHelper.fs
similarity index 100%
rename from src/app/FakeLib/UserInputHelper.fs
rename to src/app/FakeLib/LegacyApi/UserInputHelper.fs
diff --git a/src/app/FakeLib/VSSHelper.fs b/src/app/FakeLib/LegacyApi/VSSHelper.fs
similarity index 100%
rename from src/app/FakeLib/VSSHelper.fs
rename to src/app/FakeLib/LegacyApi/VSSHelper.fs
diff --git a/src/app/FakeLib/Vb6helper.fs b/src/app/FakeLib/LegacyApi/Vb6helper.fs
similarity index 100%
rename from src/app/FakeLib/Vb6helper.fs
rename to src/app/FakeLib/LegacyApi/Vb6helper.fs
diff --git a/src/app/FakeLib/VersionHelper.fs b/src/app/FakeLib/LegacyApi/VersionHelper.fs
similarity index 100%
rename from src/app/FakeLib/VersionHelper.fs
rename to src/app/FakeLib/LegacyApi/VersionHelper.fs
diff --git a/src/app/FakeLib/WiXHelper.fs b/src/app/FakeLib/LegacyApi/WiXHelper.fs
similarity index 100%
rename from src/app/FakeLib/WiXHelper.fs
rename to src/app/FakeLib/LegacyApi/WiXHelper.fs
diff --git a/src/app/FakeLib/XCopyHelper.fs b/src/app/FakeLib/LegacyApi/XCopyHelper.fs
similarity index 100%
rename from src/app/FakeLib/XCopyHelper.fs
rename to src/app/FakeLib/LegacyApi/XCopyHelper.fs
diff --git a/src/app/FakeLib/XDTHelper.fs b/src/app/FakeLib/LegacyApi/XDTHelper.fs
similarity index 100%
rename from src/app/FakeLib/XDTHelper.fs
rename to src/app/FakeLib/LegacyApi/XDTHelper.fs
diff --git a/src/app/FakeLib/XMLHelper.fs b/src/app/FakeLib/LegacyApi/XMLHelper.fs
similarity index 100%
rename from src/app/FakeLib/XMLHelper.fs
rename to src/app/FakeLib/LegacyApi/XMLHelper.fs
diff --git a/src/app/FakeLib/XamarinHelper.fs b/src/app/FakeLib/LegacyApi/XamarinHelper.fs
similarity index 100%
rename from src/app/FakeLib/XamarinHelper.fs
rename to src/app/FakeLib/LegacyApi/XamarinHelper.fs
diff --git a/src/app/FakeLib/XpkgHelper.fs b/src/app/FakeLib/LegacyApi/XpkgHelper.fs
similarity index 100%
rename from src/app/FakeLib/XpkgHelper.fs
rename to src/app/FakeLib/LegacyApi/XpkgHelper.fs
diff --git a/src/app/FakeLib/ZipHelper.fs b/src/app/FakeLib/LegacyApi/ZipHelper.fs
similarity index 100%
rename from src/app/FakeLib/ZipHelper.fs
rename to src/app/FakeLib/LegacyApi/ZipHelper.fs