diff --git a/Duplicati/CommandLine/BackendTester/Program.cs b/Duplicati/CommandLine/BackendTester/Program.cs
index e10c1fc5d..cd9b4a848 100644
--- a/Duplicati/CommandLine/BackendTester/Program.cs
+++ b/Duplicati/CommandLine/BackendTester/Program.cs
@@ -73,7 +73,7 @@ namespace Duplicati.CommandLine.BackendTester
                     Console.WriteLine();
                     List<string> lines = new List<string>();
                     foreach (Library.Interface.ICommandLineArgument arg in SupportedCommands)
-                        Library.Interface.CommandLineArgument.PrintArgument(lines, arg, " ");
+                        Library.Interface.CommandLineArgument.PrintArgument(lines, arg);
 
                     foreach (string s in lines)
                         Console.WriteLine(s);
diff --git a/Duplicati/CommandLine/Duplicati.CommandLine.csproj b/Duplicati/CommandLine/Duplicati.CommandLine.csproj
index b9f0d92fa..0d2529941 100644
--- a/Duplicati/CommandLine/Duplicati.CommandLine.csproj
+++ b/Duplicati/CommandLine/Duplicati.CommandLine.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -61,6 +61,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Help.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Strings\Program.Designer.cs">
@@ -99,6 +100,10 @@
       <Project>{FF2BF37C-E502-4C98-BEA0-701671DDFA08}</Project>
       <Name>Duplicati.Library.Backend.SSHv2</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Library\Backend\TahoeLAFS\Duplicati.Library.Backend.TahoeLAFS.csproj">
+      <Project>{C0270709-2A40-43B5-8CF1-69581B9FA2A1}</Project>
+      <Name>Duplicati.Library.Backend.TahoeLAFS</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Library\Backend\WEBDAV\Duplicati.Library.Backend.WEBDAV.csproj">
       <Project>{BAE27510-8B5D-44B2-B33E-372A98908041}</Project>
       <Name>Duplicati.Library.Backend.WEBDAV</Name>
@@ -185,6 +190,7 @@
       <Link>win-tools\pscp.exe</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <EmbeddedResource Include="help.txt" />
     <Content Include="TrayWarning.ico" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Duplicati/CommandLine/Help.cs b/Duplicati/CommandLine/Help.cs
new file mode 100644
index 000000000..a1960f98f
--- /dev/null
+++ b/Duplicati/CommandLine/Help.cs
@@ -0,0 +1,462 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Duplicati.CommandLine
+{
+    public static class Help
+    {
+        private static readonly Dictionary<string, string> _document;
+        private const string RESOURCE_NAME = "Duplicati.CommandLine.help.txt";
+        private static readonly System.Text.RegularExpressions.Regex NAMEDOPTION_REGEX = new System.Text.RegularExpressions.Regex("\\%OPTION\\:(?<name>[^\\%]+)\\%");
+
+        static Help()
+        {
+            _document = new Dictionary<string,string>(StringComparer.InvariantCultureIgnoreCase);
+
+            using (System.IO.StreamReader sr = new System.IO.StreamReader(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream(RESOURCE_NAME)))
+            {
+                List<string> keywords = new List<string>();
+                StringBuilder sb = new StringBuilder();
+                foreach(var line in sr.ReadToEnd().Split(new string[] { "\r\n" }, StringSplitOptions.None))
+                {
+                    if (line.Trim().StartsWith("#"))
+                        continue;
+
+                    if (line.Trim().StartsWith(">"))
+                    {
+                        if (sb.Length > 0)
+                        {
+                            string s = sb.ToString();
+                            foreach(var k in keywords)
+                                _document[k] = s;
+
+                            keywords.Clear();
+                            sb.Clear();
+                        }
+
+                        string[] elems = line.Split(new string[] {" ", "\t"}, StringSplitOptions.RemoveEmptyEntries);
+                        if (elems.Length >= 2 && string.Equals(elems[elems.Length - 2], "help", StringComparison.InvariantCultureIgnoreCase))
+                            keywords.Add(elems[elems.Length - 1]);
+                        else if (elems.Length == 3 && string.Equals(elems[elems.Length - 1], "help", StringComparison.InvariantCultureIgnoreCase))
+                            keywords.Add("help");
+                    }
+                    else
+                    {
+                        sb.AppendLine(line);
+                    }
+                }
+
+                if (sb.Length > 0)
+                {
+                    string s = sb.ToString();
+                    foreach(var k in keywords)
+                        _document[k] = s;
+                }
+            }
+        }
+
+        public static void PrintUsage(string topic, IDictionary<string, string> options)
+        {
+            try
+            {
+                //Force translation off
+                System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
+                System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.InvariantCulture;
+            }
+            catch { }
+
+            if (string.IsNullOrWhiteSpace(topic))
+                topic = "help";
+
+            if (string.Equals("help", topic, StringComparison.InvariantCultureIgnoreCase) && options.Count == 1)
+                topic = new List<string>(options.Keys)[0];
+
+
+            if (_document.ContainsKey(topic))
+            {
+                string tp = _document[topic];
+                Library.Main.Options opts = new Library.Main.Options(new Dictionary<string, string>());
+
+                tp = tp.Replace("%VERSION%", License.VersionNumbers.Version);
+                tp = tp.Replace("%BACKENDS%", string.Join(", ", Library.DynamicLoader.BackendLoader.Keys));
+                tp = tp.Replace("%MONO%", Library.Utility.Utility.IsMono ? "mono " : "");
+                tp = tp.Replace("%APP_PATH%", System.IO.Path.GetFileName(System.Reflection.Assembly.GetExecutingAssembly().Location));
+                tp = tp.Replace("%EXAMPLE_SOURCE_PATH%", Library.Utility.Utility.IsClientLinux ? "/source" : "D:\\source");
+                tp = tp.Replace("%EXAMPLE_SOURCE_FILE%", Library.Utility.Utility.IsClientLinux ? "/source/myfile.txt" : "D:\\source\\file.txt");
+                tp = tp.Replace("%EXAMPLE_RESTORE_PATH%", Library.Utility.Utility.IsClientLinux ? "/restore" : "D:\\restore");
+                tp = tp.Replace("%ENCRYPTIONMODULES%", string.Join(", ", Library.DynamicLoader.EncryptionLoader.Keys));
+                tp = tp.Replace("%COMPRESSIONMODULES%", string.Join(", ", Library.DynamicLoader.CompressionLoader.Keys));
+                tp = tp.Replace("%DEFAULTENCRYPTIONMODULE%", opts.EncryptionModule);
+                tp = tp.Replace("%DEFAULTCOMPRESSIONMODULE%", opts.CompressionModule);
+                tp = tp.Replace("%GENERICMODULES%", string.Join(", ", Library.DynamicLoader.GenericLoader.Keys));
+
+                if (tp.Contains("%MAINOPTIONS%"))
+                {
+                    List<string> lines = new List<string>();
+                    SortedList<string, Library.Interface.ICommandLineArgument> sorted = new SortedList<string, Library.Interface.ICommandLineArgument>();
+                    foreach (Library.Interface.ICommandLineArgument arg in opts.SupportedCommands)
+                        sorted.Add(arg.Name, arg);
+
+                    foreach (Library.Interface.ICommandLineArgument arg in sorted.Values)
+                        lines.Add(PrintArgSimple(arg, arg.Name));
+
+                    tp = tp.Replace("%MAINOPTIONS%", string.Join(Environment.NewLine, lines.ToArray()));
+                }
+
+                if (tp.Contains("%ALLOPTIONS%"))
+                {
+                    List<string> lines = new List<string>();
+                    foreach (Library.Interface.ICommandLineArgument arg in opts.SupportedCommands)
+                        Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+
+                    lines.Add("");
+                    lines.Add("");
+                    lines.Add(Strings.Program.SupportedBackendsHeader);
+                    foreach (Duplicati.Library.Interface.IBackend back in Library.DynamicLoader.BackendLoader.Backends)
+                        PrintBackend(back, lines);
+
+                    lines.Add("");
+                    lines.Add("");
+                    lines.Add(Strings.Program.SupportedEncryptionModulesHeader);
+                    foreach (Duplicati.Library.Interface.IEncryption mod in Library.DynamicLoader.EncryptionLoader.Modules)
+                        PrintEncryptionModule(mod, lines);
+
+                    lines.Add("");
+                    lines.Add("");
+                    lines.Add(Strings.Program.SupportedCompressionModulesHeader);
+                    foreach (Duplicati.Library.Interface.ICompression mod in Library.DynamicLoader.CompressionLoader.Modules)
+                        PrintCompressionModule(mod, lines);
+
+                    lines.Add("");
+
+                    lines.Add("");
+                    lines.Add("");
+                    lines.Add(Strings.Program.GenericModulesHeader);
+                    foreach (Duplicati.Library.Interface.IGenericModule mod in Library.DynamicLoader.GenericLoader.Modules)
+                        PrintGenericModule(mod, lines);
+
+                    lines.Add("");
+
+                    tp = tp.Replace("%ALLOPTIONS%", string.Join(Environment.NewLine, lines.ToArray()));
+                }
+
+                if (tp.Contains("%MODULEOPTIONS%"))
+                {
+                    //Figure out which module we are in
+                    IList<Library.Interface.ICommandLineArgument> args = null;
+                    bool found = false;
+                    foreach (Duplicati.Library.Interface.IBackend backend in Library.DynamicLoader.BackendLoader.Backends)
+                        if (string.Equals(backend.ProtocolKey, topic, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            args = backend.SupportedCommands;
+                            found = true;
+                            break;
+                        }
+
+                    if (args == null)
+                        foreach (Duplicati.Library.Interface.IEncryption module in Library.DynamicLoader.EncryptionLoader.Modules)
+                            if (string.Equals(module.FilenameExtension, topic, StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                args = module.SupportedCommands;
+                                found = true;
+                                break;
+                            }
+
+                    if (args == null)
+                        foreach (Duplicati.Library.Interface.ICompression module in Library.DynamicLoader.CompressionLoader.Modules)
+                            if (string.Equals(module.FilenameExtension, topic, StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                args = module.SupportedCommands;
+                                found = true;
+                                break;
+                            }
+
+                    if (args == null)
+                        foreach (Duplicati.Library.Interface.IGenericModule module in Library.DynamicLoader.GenericLoader.Modules)
+                            if (string.Equals(module.Key, topic, StringComparison.InvariantCultureIgnoreCase))
+                            {
+                                args = module.SupportedCommands;
+                                found = true;
+                                break;
+                            }
+
+                    //If the module is not found, we do not display the description
+                    if (found)
+                        tp = tp.Replace("%MODULEOPTIONS%", PrintArgsSimple(args));
+                    else
+                    {
+                        Console.WriteLine("Topic not found: {0}", topic);
+                        Console.WriteLine();
+                        PrintUsage("help", new Dictionary<string, string>());
+                        return;
+                    }
+                }
+
+                if (NAMEDOPTION_REGEX.IsMatch(tp))
+                    tp = NAMEDOPTION_REGEX.Replace(tp, new Matcher().MathEvaluator); 
+
+                PrintFormatted(tp.Split(new string[] { Environment.NewLine }, StringSplitOptions.None));
+            }
+            else
+            {
+                List<string> lines = new List<string>();
+
+                foreach (Duplicati.Library.Interface.IBackend backend in Library.DynamicLoader.BackendLoader.Backends)
+                    if (string.Equals(backend.ProtocolKey, topic, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        PrintBackend(backend, lines);
+                        break;
+                    }
+
+                if (lines.Count == 0)
+                    foreach (Duplicati.Library.Interface.IEncryption mod in Library.DynamicLoader.EncryptionLoader.Modules)
+                        if (string.Equals(mod.FilenameExtension, topic, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            PrintEncryptionModule(mod, lines);
+                            break;
+                        }
+
+                if (lines.Count == 0)
+                    foreach (Duplicati.Library.Interface.ICompression mod in Library.DynamicLoader.CompressionLoader.Modules)
+                        if (string.Equals(mod.FilenameExtension, topic, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            PrintCompressionModule(mod, lines);
+                            break;
+                        }
+
+                if (lines.Count == 0)
+                    foreach (Duplicati.Library.Interface.IGenericModule mod in Library.DynamicLoader.GenericLoader.Modules)
+                        if (string.Equals(mod.Key, topic, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            PrintGenericModule(mod, lines);
+                            break;
+                        }
+
+
+                if (lines.Count == 0)
+                    PrintArgumentIfFound(new Matcher().Values, topic, lines);
+
+                if (lines.Count != 0)
+                {
+                    PrintFormatted(lines);
+                }
+                else
+                {
+                    Console.WriteLine("Topic not found: {0}", topic);
+                    Console.WriteLine();
+                    PrintUsage("help", new Dictionary<string, string>());
+                }
+            }
+        }
+
+        private static void PrintArgumentIfFound(IEnumerable<Duplicati.Library.Interface.ICommandLineArgument> args, string topic, List<string> lines)
+        {
+            if (args == null)
+                return;
+
+            foreach (Duplicati.Library.Interface.ICommandLineArgument arg in args)
+            {
+                if (string.Equals(arg.Name, topic, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+                    return;
+                }
+
+                if (arg.Aliases != null)
+                    foreach (string k in arg.Aliases)
+                    {
+                        if (string.Equals(k, topic, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+                            return;
+                        }
+                    }
+            }
+        }
+
+        private static void PrintBackend(Duplicati.Library.Interface.IBackend back, List<string> lines)
+        {
+            lines.Add(back.DisplayName + " (" + back.ProtocolKey + "):");
+            lines.Add(" " + back.Description);
+            if (back.SupportedCommands != null && back.SupportedCommands.Count > 0)
+            {
+                lines.Add(" " + Strings.Program.SupportedOptionsHeader);
+                foreach (Library.Interface.ICommandLineArgument arg in back.SupportedCommands)
+                    Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+            }
+            lines.Add("");
+        }
+
+        private static void PrintEncryptionModule(Duplicati.Library.Interface.IEncryption mod, List<string> lines)
+        {
+            lines.Add(mod.DisplayName + " (." + mod.FilenameExtension + "):");
+            lines.Add(" " + mod.Description);
+            if (mod.SupportedCommands != null && mod.SupportedCommands.Count > 0)
+            {
+                lines.Add(" " + Strings.Program.SupportedOptionsHeader);
+                foreach (Library.Interface.ICommandLineArgument arg in mod.SupportedCommands)
+                    Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+            }
+            lines.Add("");
+        }
+
+        private static void PrintCompressionModule(Duplicati.Library.Interface.ICompression mod, List<string> lines)
+        {
+            lines.Add(mod.DisplayName + " (." + mod.FilenameExtension + "):");
+            lines.Add(" " + mod.Description);
+            if (mod.SupportedCommands != null && mod.SupportedCommands.Count > 0)
+            {
+                lines.Add(" " + Strings.Program.SupportedOptionsHeader);
+                foreach (Library.Interface.ICommandLineArgument arg in mod.SupportedCommands)
+                    Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+            }
+            lines.Add("");
+        }
+
+        private static void PrintGenericModule(Duplicati.Library.Interface.IGenericModule mod, List<string> lines)
+        {
+            lines.Add(mod.DisplayName + " (" + mod.Key + "):");
+            lines.Add(" " + mod.Description);
+            lines.Add(" " + (mod.LoadAsDefault ? Strings.Program.ModuleIsLoadedAutomatically : Strings.Program.ModuleIsNotLoadedAutomatically));
+            if (mod.SupportedCommands != null && mod.SupportedCommands.Count > 0)
+            {
+                lines.Add(" " + Strings.Program.SupportedOptionsHeader);
+                foreach (Library.Interface.ICommandLineArgument arg in mod.SupportedCommands)
+                    Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+            }
+            lines.Add("");
+        }
+
+        private static string PrintArguments(IEnumerable<Duplicati.Library.Interface.ICommandLineArgument> args)
+        {
+            if (args == null)
+                return "";
+
+            List<string> lines = new List<string>();
+            foreach (Library.Interface.ICommandLineArgument arg in args)
+                Library.Interface.CommandLineArgument.PrintArgument(lines, arg, "  ");
+
+            return string.Join(Environment.NewLine, lines.ToArray());
+
+        }
+
+        private static void PrintFormatted(IEnumerable<string> lines)
+        {
+            foreach (string s in lines)
+            {
+                if (string.IsNullOrEmpty(s) || s.Trim().Length == 0)
+                {
+                    Console.WriteLine();
+                    continue;
+                }
+
+                string c = s;
+
+                string leadingSpaces = "";
+                while (c.Length > 0 && c.StartsWith(" "))
+                {
+                    leadingSpaces += " ";
+                    c = c.Remove(0, 1);
+                }
+
+                bool extraIndent = c.StartsWith("--");
+
+                while (c.Length > 0)
+                {
+                    int len = Math.Min(Console.WindowWidth - 2, leadingSpaces.Length + c.Length);
+                    len -= leadingSpaces.Length;
+                    if (len < c.Length)
+                    {
+                        int ix = c.LastIndexOf(" ", len);
+                        if (ix > 0)
+                            len = ix;
+                    }
+
+                    Console.WriteLine(leadingSpaces + c.Substring(0, len).Trim());
+                    c = c.Remove(0, len);
+                    if (extraIndent)
+                    {
+                        extraIndent = false;
+                        leadingSpaces += "  ";
+                    }
+                }
+            }
+        }
+
+        private class Matcher
+        {
+            Dictionary<string, Library.Interface.ICommandLineArgument> args = new Dictionary<string, Library.Interface.ICommandLineArgument>(StringComparer.InvariantCultureIgnoreCase);
+
+            public Matcher()
+            {
+                Library.Main.Options opts = new Library.Main.Options(new Dictionary<string, string>());
+                List<IList<Library.Interface.ICommandLineArgument>> foundArgs = new List<IList<Library.Interface.ICommandLineArgument>>();
+                foundArgs.Add(new Library.Main.Options(new Dictionary<string, string>()).SupportedCommands);
+                foreach (Duplicati.Library.Interface.IBackend backend in Library.DynamicLoader.BackendLoader.Backends)
+                    if (backend.SupportedCommands != null)
+                        foundArgs.Add(backend.SupportedCommands);
+                foreach (Duplicati.Library.Interface.IEncryption mod in Library.DynamicLoader.EncryptionLoader.Modules)
+                    if (mod.SupportedCommands != null)
+                        foundArgs.Add(mod.SupportedCommands);
+                foreach (Duplicati.Library.Interface.ICompression mod in Library.DynamicLoader.CompressionLoader.Modules)
+                    if (mod.SupportedCommands != null)
+                        foundArgs.Add(mod.SupportedCommands);
+                foreach (Duplicati.Library.Interface.IGenericModule mod in Library.DynamicLoader.GenericLoader.Modules)
+                    if (mod.SupportedCommands != null)
+                        foundArgs.Add(mod.SupportedCommands);
+                
+                foreach (IEnumerable<Library.Interface.ICommandLineArgument> arglst in foundArgs)
+                    if (arglst != null)
+                    {
+                        foreach (Library.Interface.ICommandLineArgument arg in arglst)
+                        {
+                            if (!args.ContainsKey(arg.Name))
+                                args[arg.Name] = arg;
+
+                            if (arg.Aliases != null)
+                                foreach (string a in arg.Aliases)
+                                    if (!args.ContainsKey(a))
+                                        args[a] = arg;
+                        }
+                    }
+            }
+
+            public IEnumerable<Library.Interface.ICommandLineArgument> Values { get { return args.Values; } }
+
+            public string MathEvaluator(System.Text.RegularExpressions.Match m)
+            {
+                if (!m.Success || !m.Groups["name"].Success)
+                    return "";
+
+                Duplicati.Library.Interface.ICommandLineArgument arg;
+                if (!args.TryGetValue(m.Groups["name"].Value, out arg))
+                    return "";
+                else
+                    return PrintArgSimple(arg, m.Groups["name"].Value.ToLowerInvariant());
+            }
+        }
+
+        private static string PrintArgsSimple(IEnumerable<Duplicati.Library.Interface.ICommandLineArgument> args)
+        {
+            if (args == null)
+                return "";
+
+            List<string> lines = new List<string>();
+            foreach(Duplicati.Library.Interface.ICommandLineArgument arg in args)
+                lines.Add(PrintArgSimple(arg, arg.Name));
+
+            return string.Join(Environment.NewLine, lines.ToArray());
+        }
+
+
+        private static string PrintArgSimple(Duplicati.Library.Interface.ICommandLineArgument arg, string name)
+        {
+            if (string.IsNullOrEmpty(arg.DefaultValue))
+                return string.Format("  --{0}{1}    {2}", name, Environment.NewLine, arg.LongDescription);
+            else
+                return string.Format("  --{0} = {1}{2}    {3}", name, arg.DefaultValue, Environment.NewLine, arg.LongDescription);
+        }
+    }
+}
diff --git a/Duplicati/CommandLine/Program.cs b/Duplicati/CommandLine/Program.cs
index b524c7713..aa3f937a4 100644
--- a/Duplicati/CommandLine/Program.cs
+++ b/Duplicati/CommandLine/Program.cs
@@ -105,15 +105,12 @@ namespace Duplicati.CommandLine
                     }
                 }
 
-                if (cargs.Count < 2)
+                if (cargs.Count < 2 || cargs[0].Trim().Equals("help", StringComparison.InvariantCultureIgnoreCase))
                 {
-                    if (cargs.Count == 0 || cargs[0].Trim().Equals("help", StringComparison.InvariantCultureIgnoreCase))
-                        PrintUsage(true);
+                    if (cargs.Count < 2)
+                        Help.PrintUsage("help", options);
                     else
-                    {
-                        PrintUsage(false);
-                        PrintWrongNumberOfArguments(cargs, 2);
-                    }
+                        Help.PrintUsage(cargs[1], options);
                     
 
                     return;
@@ -130,6 +127,12 @@ namespace Duplicati.CommandLine
                     options["restore"] = null;
                     cargs.RemoveAt(0);
                 }
+                else if (source.Trim().ToLower() == "backup" && cargs.Count == 3)
+                {
+                    source = target;
+                    target = cargs[2];
+                    cargs.RemoveAt(0);
+                }
 
                 if (!options.ContainsKey("passphrase"))
                     if (!string.IsNullOrEmpty(System.Environment.GetEnvironmentVariable("PASSPHRASE")))
@@ -455,7 +458,7 @@ namespace Duplicati.CommandLine
 
         }
 
-        private static void PrintUsage(bool extended)
+        private static void PrintOldUsage(bool extended)
         {
             bool isLinux = Library.Utility.Utility.IsClientLinux;
 
diff --git a/Duplicati/CommandLine/help.txt b/Duplicati/CommandLine/help.txt
new file mode 100644
index 000000000..b6b6dca52
--- /dev/null
+++ b/Duplicati/CommandLine/help.txt
@@ -0,0 +1,385 @@
+# This file is the help for the Duplicati Command Line Client. It shows what 
+# commands the CLI understands and what the outputs are. Sometimes we used
+# placeholders for options. In that case descriptions are taken directly from
+# the modules. Sometimes we described options here. The reason for that is, 
+# that we found the new description much better but did not want to create a 
+# need for translation as many options are described in the UI as well and 
+# they are translated there.
+# =============================================================================
+> duplicati.commandline.exe
+> duplicati.commandline.exe help
+
+See duplicati.commandline.exe help <topic> for more information.
+
+  Examples: example
+  
+  Commands: backup, restore, delete-all-but-n-full, delete-all-but-n, cleanup, delete-older-than, list, list-current-files, list-actual-signature-files, collection-status, create-folder, find-last-version, verify
+  
+  Debugging: debug, logging
+  
+  Targets: %BACKENDS%
+  
+  Modules: %ENCRYPTIONMODULES%, %COMPRESSIONMODULES%, %GENERICMODULES%
+  
+  Formats: date, time, size, encryption, compression
+  
+  Advanced options: advanced, filter, <option> (e.g. --auto-cleanup)
+
+http://www.duplicati.com/              Version: %VERSION%
+
+
+
+# =============================================================================
+> duplicati.commandline.exe help example
+> duplicati.commandline.exe help examples
+
+Make an encrypted backup
+========================
+  The following command will make an encrypted backup and store it on an FTP server. The first backup will be full followed by 10 incremental backups before another full backup is made. As no passphrase is specified, the user will be prompted for a password. The upload speed is throttled to 500kB/s.
+  
+  %MONO%"%APP_PATH%" backup 
+    "%EXAMPLE_SOURCE_PATH%" "ftp://ftp.example.com/target"
+    --ftp-username=username
+    --ftp-password=password
+    --full-if-more-than-n-incrementals=10
+    --auto-cleanup
+    --max-upload-pr-second=500kB
+
+
+Delete old backups
+==================
+  The following command will delete old backups. If no passphrase is specified, the user will be prompted for a passphrase. The option --force is required to delete the files; without that option no files will be deleted. Duplicati does not delete backup files that are required to restore files from a valid newer backup (a full backup is always required to restore files from an incremental backup).
+  
+  %MONO%"%APP_PATH%" delete-older-than 10D 
+    "ftp://ftp.example.com/target"
+    --ftp-username=username
+    --ftp-password=password
+    --force
+
+
+Restore a specific file
+=======================
+  The following command will restore "%EXAMPLE_SOURCE_FILE%" from the backup in the latest version to the local folder "%EXAMPLE_RESTORE_PATH%".
+  
+  %MONO%"%APP_PATH%" restore 
+    "ftp://ftp.example.com/target" "%EXAMPLE_RESTORE_PATH%"
+    --ftp-username=username
+    --ftp-password=password
+    --file-to-restore="%EXAMPLE_SOURCE_FILE%"
+    
+
+# =============================================================================
+> duplicati.commandline.exe help backup
+  
+Usage: backup <source folder> <target url> <options>
+
+  This will perform full or incremental backups. It reads all files from <source folder> and stores the backups in <target url>. If no rule for full backups is specified, Duplicati will create one full backup and incremental backups afterwards. Multiple source folders have to be separated by the operating system's delimiter (semicolon ";" on Windows, colon ":" on Linux).
+
+Options:
+  --auto-cleanup
+    Removes all files that do not belong to the backup (e.g. partial files caused by interrupted uploads).
+  --backup-prefix = <string>
+    Replaces the default "duplicati" with <string> in the file names of the backup files. It is required to specify different prefixes if multiple backups are stored in the same target folder.
+  --full
+    Make a full backup. If nothing is specified, an initial full backup is made with incremental backups afterwards.
+  --full-if-older-than = <date> 
+    Make a new full backup after the specified relative date or time.
+  --full-if-more-than-n-incrementals = <number>
+    Make a full backup after n incremental backups.
+  --max-upload-pr-second = <size>
+    Limits the upload speed to the specified value. <size> is interpreted as bandwidth/s.
+  --no-encryption
+    The backup is NOT encrypted with a passphrase. Unencrypted files are stored.
+  --passphrase = <passphrase>
+    The passphrase that is used to encrypt the backup. If nothing is specified here, the environment variable PASSPHRASE will be used or the user will be prompted to type in the passphrase. 
+  --volsize = <size>
+    The maximum size of files being written to the target. Default size is 10MB.
+
+# =============================================================================
+> duplicati.commandline.exe help restore
+
+Usage: restore <source url> <target folder>
+  
+  This will restore one or more files from the backup in <source url> to the local folder <target folder>.
+
+Options:
+  --file-to-restore = <list of files>
+    List of files to be restored separated by a semicolon ";" on Windows or colon ":" on Linux.
+  --restore-time = <date>
+    Restore from a specific or relative date or time. If nothing is specified, the latest version is restored.
+
+
+# =============================================================================
+> duplicati.commandline.exe help delete-all-but-n-full
+  
+Usage: delete-all-but-n-full <number> <source url>
+  
+  This will keep the <number> latests full backups and delete older ones.
+
+Options: 
+%OPTION:force%
+%OPTION:allow-full-removal%
+
+
+# =============================================================================
+> duplicati.commandline.exe help delete-all-but-n
+
+Usage: delete-all-but-n <number> <target url>
+  
+  This will keep the <number> latest backups no matter if they are full or incremental. Older backups will be deleted. No backups are deleted that are required to restore files from a valid newer backup.
+  
+Options:
+%OPTION:force%
+%OPTION:allow-full-removal%
+
+
+# =============================================================================
+> duplicati.commandline.exe help delete-older-than
+
+Usage: delete-older-than <date> <target url>
+  
+  This will delete all backups from the target that older than the specified absolute or relative date and time.
+
+Options:
+%OPTION:force%
+%OPTION:allow-full-removal%
+  
+# =============================================================================
+> duplicati.commandline.exe help debug
+> duplicati.commandline.exe help logging
+
+Duplicati provides information for debugging and logging purposes. By default, all debugging and logging is turned off.
+
+  --debug-output
+    Error messages are more verbose.
+  --debug-retry-errors
+    If something needs to be retried (e.g. upload failed) this will cause an entry in the log file.
+  --log-file = <path>
+    The path to the log file e.g. "D:\duplicati\log.txt".
+  --log-level = Profiling | Information | Warning | Error 
+    Specifies the log level.
+  --backend-log-database = <path>
+    Duplicati can log all actions related to storing, deleting files on the backend. <path> specifies where this log is written e.g. "D:\duplicati\backend.xml".
+
+    
+# =============================================================================
+> duplicati.commandline.exe help encryption
+> duplicati.commandline.exe help compression
+
+Duplicati offers various options for the used compression and encryption modules.
+
+  --encryption-module = %ENCRYPTIONMODULES%
+    The encryption module that is used to encrypt backups. Default is %DEFAULTENCRYPTIONMODULE%.
+  --compression-module = %COMPRESSIONMODULES%
+    The compression module that is used. Default is %DEFAULTCOMPRESSIONMODULE%.
+  --enable-module = %GENERICMODULES%
+    Enable a built-in generic module that is not enabled by default
+  --disable-module = %GENERICMODULES%
+    Disable a built-in generic module that is enabled by default
+%OPTION:passphrase%
+%OPTION:no-encryption%
+
+# =============================================================================
+> duplicati.commandline.exe help gpg
+
+Duplicati is shipped with an interface to GNU Privary Guard. It requires that the gpg executable is available on the system. On Windows it is assumed that this is in the default installation folder under program files, under Linux and OSX it is assumed that the program is available via the PATH environment variable. It is possible to supply the path to GPG using the --gpg-program-path switch.
+
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help cleanup
+
+Usage: cleanup <target url>
+
+  Removes all files that do not belong to the backup (e.g. partial files caused by interrupted uploads). This can also be performed when the actions backup, restore are run with the option --auto-cleanup.
+
+Options: 
+%OPTION:force%
+
+# =============================================================================
+> duplicati.commandline.exe help list
+
+Usage: list <target url>
+
+  Lists all files stored on the remote server. These are manifest files, signature files, content files and other files that do not to any backup created by duplicati. This command can be used to see the contents of the remote folder.
+
+
+# =============================================================================
+> duplicati.commandline.exe help list-current-files
+
+Usage: list-current-files <target url>
+
+  Lists the (source) files that are contained in a backup. By default, the latest versions are listed. This action is useful to try out what files would be restored with a given set or options.
+
+Options:
+ --restore-time = <date>
+   By default, Duplicati will restore files from the most recent backup, use this option to restore older versions of a file. You may use relative times, like "-2M" for a backup from two months ago. Duplicati will pick the next older version of the value specified. If you specify "-2M", the restored version could be 2 months and 3 days old.
+
+
+# =============================================================================
+> duplicati.commandline.exe help list-actual-signature-files
+
+Usage: list-actual-signature-files <target url>
+  
+  Lists the files found in a single backup set with a status: (added, modified, deleted). This is the same as a "change set".
+
+Options:
+ --restore-time = <date>
+   By default, Duplicati will restore files from the most recent backup, use this option to select another item. You may use relative times, like "-2M" for a backup from two months ago.
+
+
+# =============================================================================
+> duplicati.commandline.exe help file
+
+Duplicati can use the local file system to store backups. The following target URL formats can be used:
+  file://hostname/folder
+  file://\\server\folder (UNC path)
+  file://c:\folder (Windows)
+  file:///usr/pub/files (Linux)
+
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help tahoe
+> duplicati.commandline.exe help tahoelafs
+
+Duplicati can use the TahoeLAFS to store backups. The following target URL format is used:
+  tahoe://hostname:port/uri/$DIRCAP
+
+Options:
+%MODULEOPTIONS%
+
+# =============================================================================
+> duplicati.commandline.exe help ftp
+
+Duplicati can use FTP servers to store backups. The following target URL formats can be used:
+  ftp://hostname/folder
+  
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help ssh
+
+Duplicati can use SSH servers to store backups. The following target URL formats can be used:
+  ssh://hostname/folder
+ 
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help webdav
+
+Duplicati can use WebDAV servers to store backups. The following target URL formats can be used:
+  webdav://hostname/folder"
+  
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help s3
+
+Duplicati can use S3-compatible servers to store backups. The following target URL format is used:
+  s3://bucketname/prefix
+
+Options:
+%MODULEOPTIONS%
+
+
+# =============================================================================
+> duplicati.commandline.exe help skydrive
+
+Duplicati can use Windows Live Skydrive to store backups. The following target URL format is used:
+  skydrive://folder/subfolder
+Please note that there is no official API and accessing SkyDrive through this backend may violate the ToS and may stop to work if Microsoft decides to change the API.
+
+Options:
+%MODULEOPTIONS%
+
+# =============================================================================
+> duplicati.commandline.exe help date
+> duplicati.commandline.exe help time
+
+Duplicati supports absolute and relative dates and times:
+
+  now --> The current time
+  
+  1234567890 --> A timestamp, seconds since 1970.
+  
+  "2009-03-26T08:30:00+01:00" --> An absolute date and time. You can also use the local date and time format of your system like e.g. "01-14-2000" or "01 jan. 2004".
+  
+  Y, M, D, W, h, m, s --> Relative date and time: year, month, day, week, hour, minute, second. Example: 2M10D5h is now + 2 months + 10 days + 5 hours.
+
+# =============================================================================
+> duplicati.commandline.exe help size
+
+Whenever a size is required, you can use any of the following suffixes:
+
+  B - Bytes
+  kB - Kilobytes
+  MB - Megabytes
+  GB - Gigabytes
+  
+For speed limits, use the same format. If you enter 1MB this will be 1MB/sec.
+
+# =============================================================================
+> duplicati.commandline.exe help filter
+> duplicati.commandline.exe help filters
+
+Duplicati can apply globbing and regex filter rules to backup and restore specific files only. It can also exclude files that meet specific conditions. It is recommended to check the website for more information how Duplicati processes filter rules. For more information, please visit http://code.google.com/p/duplicati/wiki/FilterUsage
+
+%OPTION:include%
+%OPTION:exclude%
+%OPTION:include-regexp%
+%OPTION:exclude-regexp%
+%OPTION:skip-files-larger-than%
+
+
+# =============================================================================
+> duplicati.commandline.exe help collection-status
+Usage: collection-status <target url>
+
+Collection status will list all backup chains found on the target, along with the combined size of each volume.
+
+# =============================================================================
+> duplicati.commandline.exe help create-folder
+Usage: create-folder <target url>
+
+  This command can be used to create the folder on the remote backend.
+
+# =============================================================================
+> duplicati.commandline.exe help find-last-version
+Usage: find-last-version <target url> --file-to-restore=%EXAMPLE_SOURCE_FILE%
+
+  This command finds the last backup set that contains a specified file. This can be used to locate the last backup of a file that has been deleted.
+
+# =============================================================================
+> duplicati.commandline.exe help verify
+Usage: verify <target url> --verification-level=manifest
+
+  Duplicati will check the integrity of a remote backup. Therefore, it will download backup files and check their integrity locally. Default behaviour is, that only the manifest files required to restore the latest version of the backup are checked. Using the below listed options, it is possible to also check signature and content files. It is also possible to check older versions of a backup. Please note that this command might download a lot of data!
+
+Options:
+  --verification-level = Manifest | Signature | Full
+    Defines what files are downloaded and checked.
+      Manifest --> manifest files
+      Signature --> manifest + signature files
+      Full --> manifest + signature + content files
+  --restore-time = <date>
+    Select another version of the backup that is older than the specified absolute or relative date.
+
+# =============================================================================
+> duplicati.commandline.exe help advanced
+> duplicati.commandline.exe help option
+> duplicati.commandline.exe help options
+
+Duplicati offers more options than listed in the other topics. Those additional options should only be used with care. For normal operation none of them should ever be required. Here is a complete list of options supported by Duplicati:
+
+%MAINOPTIONS%
diff --git a/Duplicati/Library/DynamicLoader/GenericLoader.cs b/Duplicati/Library/DynamicLoader/GenericLoader.cs
index c2d5b15ed..1fa4f7a13 100644
--- a/Duplicati/Library/DynamicLoader/GenericLoader.cs
+++ b/Duplicati/Library/DynamicLoader/GenericLoader.cs
@@ -60,6 +60,11 @@ namespace Duplicati.Library.DynamicLoader
         /// </summary>
         public static IGenericModule[] Modules { get { return new GenericLoaderSub().Interfaces; } }
 
+        /// <summary>
+        /// Gets a list of keys supported
+        /// </summary>
+        public static string[] Keys { get { return new GenericLoaderSub().Keys; } }
+
         #endregion
 
     }
diff --git a/Duplicati/Library/Interface/CommandLineArgument.cs b/Duplicati/Library/Interface/CommandLineArgument.cs
index eacab5722..e29b28cb5 100644
--- a/Duplicati/Library/Interface/CommandLineArgument.cs
+++ b/Duplicati/Library/Interface/CommandLineArgument.cs
@@ -289,20 +289,25 @@ namespace Duplicati.Library.Interface
 
         public static void PrintArgument(List<string> lines, ICommandLineArgument arg)
         {
-            lines.Add(" --" + arg.Name + " (" + arg.Typename + "): " + arg.ShortDescription);
+            PrintArgument(lines, arg, " ");
+        }
+
+        public static void PrintArgument(List<string> lines, ICommandLineArgument arg, string indent)
+        {
+            lines.Add(indent + "--" + arg.Name + " (" + arg.Typename + "): " + arg.ShortDescription);
             
             if (arg.Deprecated)
-                lines.Add("   " + Strings.CommandLineArgument.DeprecationMarker + ": " + arg.DeprecationMessage);
+                lines.Add(indent + "  " + Strings.CommandLineArgument.DeprecationMarker + ": " + arg.DeprecationMessage);
 
-            lines.Add("   " + arg.LongDescription);
+            lines.Add(indent + "  " + arg.LongDescription);
             if (arg.Aliases != null && arg.Aliases.Length > 0)
-                lines.Add("   * " + Strings.CommandLineArgument.AliasesHeader + ": --" + string.Join(", --", arg.Aliases));
+                lines.Add(indent + "  * " + Strings.CommandLineArgument.AliasesHeader + ": --" + string.Join(", --", arg.Aliases));
 
             if (arg.ValidValues != null && arg.ValidValues.Length > 0)
-                lines.Add("   * " + Strings.CommandLineArgument.ValuesHeader + ": " + string.Join(", ", arg.ValidValues));
+                lines.Add(indent + "  * " + Strings.CommandLineArgument.ValuesHeader + ": " + string.Join(", ", arg.ValidValues));
 
             if (!string.IsNullOrEmpty(arg.DefaultValue))
-                lines.Add("   * " + Strings.CommandLineArgument.DefaultValueHeader + ": " + arg.DefaultValue);
+                lines.Add(indent + "  * " + Strings.CommandLineArgument.DefaultValueHeader + ": " + arg.DefaultValue);
 
 
         }