diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 858c91f..3178665 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -3,7 +3,6 @@
 name: CI
 
 # Controls when the action will run. Triggers the workflow on push or pull request
-# events but only for the main branch
 on:
   push:
     branches: [ main, dev ]
diff --git a/.gitmodules b/.gitmodules
index b6c46cb..a013ccf 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,3 +7,6 @@
 [submodule "Base32"]
 	path = Base32
 	url = https://gist.github.com/9335c394c5cc65404c4cf9aceab04143.git
+[submodule "JsonKit"]
+	path = JsonKit
+	url = https://github.com/toptensoftware/JsonKit.git
diff --git a/DiffBackup/Backup/BackupService.cs b/DiffBackup/Backup/BackupService.cs
index 66c64b0..f87fa27 100644
--- a/DiffBackup/Backup/BackupService.cs
+++ b/DiffBackup/Backup/BackupService.cs
@@ -5,8 +5,10 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using deltaq_tie.BsDiff;
+using deltaq_tie_tdiff.BsDiff;
+using DiffBackup.Backup.Config;
 using DiffBackup.Logger;
+using Terraria;
 using TShockAPI.Extensions;
 
 #nullable enable
@@ -15,14 +17,19 @@ namespace DiffBackup.Backup
 {
     public class BackupService : IDisposable, IBackupService
     {
+        private readonly CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
         private readonly SemaphoreSlim _saveDiffSemaphore = new SemaphoreSlim(1, 1);
+        public readonly AllConfig Config;
         public readonly ITlog Log;
         private Stopwatch _saveDiffStopWatch = new Stopwatch();
+        private readonly Stopwatch _scheduledCleanupStopWatch = Stopwatch.StartNew();
 
-        public BackupService(ITlog log, IBackupStrategy? strategy = null, BackupIOWorker? worker = null)
+        public BackupService(ITlog log, AllConfig config, IBackupStrategy? strategy = null,
+            BackupIOWorker? worker = null)
         {
             Log = log;
-            Strategy = strategy ?? new DefaultBackupStrategy(Log);
+            Config = config.Clone<AllConfig>();
+            Strategy = strategy ?? new DefaultBackupStrategy(Log, config.Strategy);
             Worker = worker ?? new BackupIOWorker(log);
             var env = Environment.GetEnvironmentVariables();
 
@@ -35,9 +42,16 @@ public BackupService(ITlog log, IBackupStrategy? strategy = null, BackupIOWorker
                     TimeSpan.FromSeconds(
                         double.Parse(Environment.GetEnvironmentVariable(TdiffOverwriteThrottleTimeSpan)));
             }
+
+            Task.Factory.StartNew(CleanupScheduleLoop, _cancellationTokenSource.Token,
+                TaskCreationOptions.LongRunning | TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
         }
 
-        public TimeSpan ThrottleTimeSpan { get; set; } = TimeSpan.FromMinutes(1);
+        public TimeSpan ThrottleTimeSpan
+        {
+            get => Config.Internal.ThrottleTimeSpan;
+            set => Config.Internal.ThrottleTimeSpan = value;
+        }
 
         public bool ShouldThrottle =>
             ThrottleTimeSpan > TimeSpan.Zero && _saveDiffStopWatch.IsRunning &&
@@ -57,26 +71,30 @@ public async Task StartBackup(string path, DateTime? dateTime = null,
         public async Task<IList<BackupRepositoryEntry>> StartCleanup(string worldPath,
             CancellationToken cancellationToken = default)
         {
+            using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken,
+                _cancellationTokenSource.Token);
             var repo = new BackupRepository(BackupUtils.GetRepoFilePath(Path.GetFullPath(worldPath)));
-            return await Worker.IoScheduleFunction(() => Cleanup(repo), cancellationToken);
+            return await Worker.IoScheduleFunction(() => Cleanup(repo), cts.Token);
         }
 
 
         public List<DateTime> ListBackup(string path, CancellationToken cancellationToken)
         {
-            IEnumerable<DateTime> ListDate()
+            async Task<List<DateTime>> ListDate()
             {
+                using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken,
+                    _cancellationTokenSource.Token);
                 var repo = new BackupRepository(BackupUtils.GetRepoFilePath(path));
                 cancellationToken.ThrowIfCancellationRequested();
-                foreach (var entry in BackupUtils.ListBackup(repo.Entries))
-                {
-                    yield return entry.DateTime;
-                }
+                var entries =
+                    await Worker.IoScheduleFunction(() => BackupUtils.ListBackup(repo.Entries).ToList(), cts.Token);
+                return entries.Select(entry => entry.DateTime).ToList();
             }
 
             try
             {
-                return ListDate().ToList();
+                var task = Task.Run(ListDate, cancellationToken);
+                return task.Result;
             }
             catch (FileNotFoundException)
             {
@@ -84,8 +102,58 @@ IEnumerable<DateTime> ListDate()
             }
         }
 
-
         public bool Restore(string path, DateTime date, CancellationToken cancellationToken)
+        {
+            var res = Task.Run(
+                async () => await Worker.IoScheduleFunction(() => DoRestore(path, date, cancellationToken),
+                    cancellationToken), cancellationToken);
+            return res.Result;
+        }
+
+        public void Dispose()
+        {
+            Log.LogDebug($"{nameof(BackupService)} Dispose");
+            Worker.Dispose();
+            _saveDiffSemaphore.Dispose();
+            Strategy.Dispose();
+            _cancellationTokenSource.Cancel(false);
+        }
+
+        private async Task CleanupScheduleLoop()
+        {
+            var cancellationToken = _cancellationTokenSource.Token;
+            if (Config.Strategy.Cleanup.ScheduleTimeSpan <= TimeSpan.Zero)
+            {
+                Log.LogDebug("CleanupScheduleLoop no need to run");
+                return;
+            }
+
+            var random = new Random();
+            await Task.Delay(TimeSpan.FromSeconds(random.NextDouble() * 60), cancellationToken);
+
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    if (_scheduledCleanupStopWatch.Elapsed >= Config.Strategy.Cleanup.ScheduleTimeSpan)
+                    {
+                        await StartCleanup(Main.WorldPath, cancellationToken);
+                        _scheduledCleanupStopWatch.Restart();
+                    }
+
+                    await Task.Delay(
+                        Config.Strategy.Cleanup.ScheduleTimeSpan + TimeSpan.FromSeconds(random.NextDouble() * 60),
+                        cancellationToken);
+                }
+            }
+            catch (OperationCanceledException e)
+            {
+                Log.LogDebug("Loop cancelled");
+                Log.LogDebug(e.BuildExceptionString(), TraceLevel.Error);
+            }
+        }
+
+        private bool DoRestore(string path, DateTime date, CancellationToken cancellationToken)
         {
             var repo = new BackupRepository(BackupUtils.GetRepoFilePath(path));
             cancellationToken.ThrowIfCancellationRequested();
@@ -128,14 +196,6 @@ public bool Restore(string path, DateTime date, CancellationToken cancellationTo
             }
         }
 
-        public void Dispose()
-        {
-            Log.LogDebug($"{nameof(BackupService)} Dispose");
-            Worker.Dispose();
-            _saveDiffSemaphore.Dispose();
-            Strategy.Dispose();
-        }
-
         private IList<BackupRepositoryEntry> Cleanup(BackupRepository repo)
         {
             var res = new List<BackupRepositoryEntry>();
@@ -189,14 +249,20 @@ public async Task BackupSaveAsync(string path, DateTime? dateTime = null,
             CancellationToken cancellationToken = default)
         {
             using var timed = new CancellationTokenSource();
-            timed.CancelAfter(TimeSpan.FromMinutes(3));
+            if (Config.Internal.BackupTaskTimeoutTimeSpan > TimeSpan.Zero)
+            {
+                timed.CancelAfter(Config.Internal.BackupTaskTimeoutTimeSpan);
+            }
+
             using var tokenSource =
-                CancellationTokenSource.CreateLinkedTokenSource(Worker.Token, cancellationToken, timed.Token);
+                CancellationTokenSource.CreateLinkedTokenSource(Worker.Token, cancellationToken, timed.Token,
+                    _cancellationTokenSource.Token);
             tokenSource.Token.ThrowIfCancellationRequested();
             await _saveDiffSemaphore.WaitAsync(tokenSource.Token);
 
             async Task<T> IoSchedule<T>(Func<T> func)
             {
+                // ReSharper disable once AccessToDisposedClosure
                 return await IoScheduleFunction(func, tokenSource!.Token);
             }
 
diff --git a/DiffBackup/Backup/BackupStrategy.cs b/DiffBackup/Backup/BackupStrategy.cs
index 5d56f91..32a38d5 100644
--- a/DiffBackup/Backup/BackupStrategy.cs
+++ b/DiffBackup/Backup/BackupStrategy.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using DiffBackup.Backup.Config;
 using DiffBackup.Logger;
 
 #nullable enable
@@ -9,11 +10,13 @@ namespace DiffBackup.Backup
 {
     public class DefaultBackupStrategy : IBackupStrategy
     {
+        public readonly StrategyConfig Config;
         public readonly ITlog Log;
 
-        public DefaultBackupStrategy(ITlog log)
+        public DefaultBackupStrategy(ITlog log, StrategyConfig config)
         {
             Log = log;
+            Config = config.Clone<StrategyConfig>();
             var env = Environment.GetEnvironmentVariables();
 
             // ReSharper disable once InconsistentNaming
@@ -29,12 +32,21 @@ public DefaultBackupStrategy(ITlog log)
             const string TdiffOverwriteFillFactor = nameof(TdiffOverwriteFillFactor);
             if (env.Contains(TdiffOverwriteFillFactor))
             {
-                FillFactor = float.Parse(Environment.GetEnvironmentVariable(TdiffOverwriteFillFactor));
+                FillFactor = double.Parse(Environment.GetEnvironmentVariable(TdiffOverwriteFillFactor));
             }
         }
 
-        public TimeSpan ForceFullBackupTimeSpan { get; set; } = TimeSpan.FromDays(7);
-        public float FillFactor { get; set; } = 0.5f;
+        public TimeSpan ForceFullBackupTimeSpan
+        {
+            get => Config.EveryXTimeSpanDoFullBackup;
+            set => Config.EveryXTimeSpanDoFullBackup = value;
+        }
+
+        public double FillFactor
+        {
+            get => Config.DiffFillFactorToStartFullBackup;
+            set => Config.DiffFillFactorToStartFullBackup = value;
+        }
 
         public BackupRepositoryEntry? GetReference(BackupRepository repo, DateTime date)
         {
@@ -97,34 +109,30 @@ public IList<BackupRepositoryEntry> ListExpiredEntries(BackupRepository repo, Da
                 }
             }
 
-            CleanupTimeConfig[] worldCleanupTimeConfigs =
-            {
-                new CleanupTimeConfig("yearly", TimeSpan.FromDays(365.25), TimeSpan.FromDays(3)),
-                new CleanupTimeConfig("monthly", TimeSpan.FromDays(30.44), TimeSpan.FromHours(12)),
-                new CleanupTimeConfig("weekly", TimeSpan.FromDays(7), TimeSpan.FromHours(1))
-            };
 
-            CleanupTimeConfig[] diffCleanupTimeConfigs =
+            foreach (var config in Config.Cleanup.WldFiles)
             {
-                new CleanupTimeConfig("yearly", TimeSpan.FromDays(365.25), TimeSpan.MaxValue),
-                new CleanupTimeConfig("monthly", TimeSpan.FromDays(30.44), TimeSpan.FromMinutes(30)),
-                new CleanupTimeConfig("weekly", TimeSpan.FromDays(7), TimeSpan.FromMinutes(1))
-            };
-
+                if (config.AgeFilter <= TimeSpan.Zero)
+                {
+                    continue;
+                }
 
-            foreach (var config in worldCleanupTimeConfigs)
-            {
                 var marked = ConsumeIEnumerable(MarkOldEntries(backups.Where(backup => !backup.IsDiff),
                     config.AgeFilter,
                     config.KeepBackupEveryTimeSpan));
-                Log.LogDebug($"Marked {marked} entries for {config.Text.ToLower()} wld cleanup");
+                Log.LogDebug($"Marked {marked} entries for {config.Name} wld cleanup");
             }
 
-            foreach (var config in diffCleanupTimeConfigs)
+            foreach (var config in Config.Cleanup.DiffFiles)
             {
+                if (config.AgeFilter <= TimeSpan.Zero)
+                {
+                    continue;
+                }
+
                 var marked = ConsumeIEnumerable(MarkOldEntries(backups.Where(backup => backup.IsDiff), config.AgeFilter,
                     config.KeepBackupEveryTimeSpan));
-                Log.LogDebug($"Marked {marked} entries for {config.Text.ToLower()} diff cleanup");
+                Log.LogDebug($"Marked {marked} entries for {config.Name} diff cleanup");
             }
 
             foreach (var entry in backups.Where(backup => !backup.Valid))
@@ -143,19 +151,5 @@ internal static int ConsumeIEnumerable<T>(IEnumerable<T> enumerable)
         {
             return enumerable.Count();
         }
-
-        public readonly struct CleanupTimeConfig
-        {
-            public readonly string Text;
-            public readonly TimeSpan AgeFilter;
-            public readonly TimeSpan KeepBackupEveryTimeSpan;
-
-            public CleanupTimeConfig(string text, TimeSpan ageFilter, TimeSpan keepBackupEveryTimeSpan)
-            {
-                Text = text;
-                AgeFilter = ageFilter;
-                KeepBackupEveryTimeSpan = keepBackupEveryTimeSpan;
-            }
-        }
     }
 }
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/AllConfig.cs b/DiffBackup/Backup/Config/AllConfig.cs
new file mode 100644
index 0000000..4ca934e
--- /dev/null
+++ b/DiffBackup/Backup/Config/AllConfig.cs
@@ -0,0 +1,9 @@
+namespace DiffBackup.Backup.Config
+{
+    public class AllConfig : BaseConfig
+    {
+        public int Version { get; set; } = 1;
+        public StrategyConfig Strategy { get; set; } = new StrategyConfig();
+        public InternalConfig Internal { get; set; } = new InternalConfig();
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/BaseConfig.cs b/DiffBackup/Backup/Config/BaseConfig.cs
new file mode 100644
index 0000000..90f6457
--- /dev/null
+++ b/DiffBackup/Backup/Config/BaseConfig.cs
@@ -0,0 +1,42 @@
+using System;
+using Topten.JsonKit_tie_tdiff;
+
+namespace DiffBackup.Backup.Config
+{
+    public abstract class BaseConfig : IConfig
+    {
+        public BaseConfig()
+        {
+        }
+
+        public BaseConfig(BaseConfig copy)
+        {
+            Topten.JsonKit_tie_tdiff.Json.CloneInto(this, copy);
+        }
+
+        public IConfig Clone()
+        {
+            return Clone<IConfig>();
+        }
+
+        public T Clone<T>() where T : IConfig
+        {
+            if (this is T t)
+            {
+                return Topten.JsonKit_tie_tdiff.Json.Clone(t);
+            }
+
+            throw new TypeAccessException();
+        }
+
+        public string ToJson(JsonOptions options = JsonOptions.None)
+        {
+            return Topten.JsonKit_tie_tdiff.Json.Format(this, options);
+        }
+
+        public void SetFromJson(string data, JsonOptions options = JsonOptions.None)
+        {
+            Topten.JsonKit_tie_tdiff.Json.ParseInto(data, this, options);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/CleanupConfig.cs b/DiffBackup/Backup/Config/CleanupConfig.cs
new file mode 100644
index 0000000..433fd5c
--- /dev/null
+++ b/DiffBackup/Backup/Config/CleanupConfig.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+
+namespace DiffBackup.Backup.Config
+{
+    public class CleanupConfig : BaseConfig
+    {
+        public TimeSpanConfig ScheduleTimeSpan { get; set; } = TimeSpan.FromHours(12);
+
+        public List<CleanupTimeConfig> WldFiles { get; set; } = new List<CleanupTimeConfig>
+        {
+            new CleanupTimeConfig("yearly", TimeSpan.FromDays(365), TimeSpan.FromDays(3)),
+            new CleanupTimeConfig("monthly", TimeSpan.FromDays(30), TimeSpan.FromHours(12)),
+            new CleanupTimeConfig("weekly", TimeSpan.FromDays(7), TimeSpan.FromHours(1))
+        };
+
+        public List<CleanupTimeConfig> DiffFiles { get; set; } = new List<CleanupTimeConfig>
+        {
+            new CleanupTimeConfig("yearly", TimeSpan.FromDays(365), TimeSpan.FromDays(365)),
+            new CleanupTimeConfig("monthly", TimeSpan.FromDays(30), TimeSpan.FromMinutes(30)),
+            new CleanupTimeConfig("weekly", TimeSpan.FromDays(7), TimeSpan.FromMinutes(1))
+        };
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/CleanupTimeConfig.cs b/DiffBackup/Backup/Config/CleanupTimeConfig.cs
new file mode 100644
index 0000000..04a6d0e
--- /dev/null
+++ b/DiffBackup/Backup/Config/CleanupTimeConfig.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace DiffBackup.Backup.Config
+{
+    public class CleanupTimeConfig : BaseConfig
+    {
+        public CleanupTimeConfig()
+        {
+        }
+
+        public CleanupTimeConfig(string name, TimeSpan ageFilter, TimeSpan keepBackupEveryTimeSpan)
+        {
+            Name = name;
+            AgeFilter = ageFilter;
+            KeepBackupEveryTimeSpan = keepBackupEveryTimeSpan;
+        }
+
+        public CleanupTimeConfig(CleanupTimeConfig copy) : base(copy)
+        {
+        }
+
+        public string Name { get; set; } = "";
+
+        public TimeSpanConfig AgeFilter { get; set; } = TimeSpan.Zero;
+
+        public TimeSpanConfig KeepBackupEveryTimeSpan { get; set; } = TimeSpan.MaxValue;
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/Config.cs b/DiffBackup/Backup/Config/Config.cs
deleted file mode 100644
index f7d9d89..0000000
--- a/DiffBackup/Backup/Config/Config.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-namespace DiffBackup.Backup.Config
-{
-    public class InternalConfig
-    {
-        public double ThrottleSecond { get; set; } = 60;
-    }
-
-
-    public class StrategyConfig
-    {
-        public double EveryXDayDoFullBackup { get; set; } = 7;
-        public double FillFactorToStartFullBackup { get; set; } = 0.5;
-    }
-
-    public class Config
-    {
-        public StrategyConfig Strategy { get; set; } = new StrategyConfig();
-        public InternalConfig Internal { get; set; } = new InternalConfig();
-    }
-}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/IConfig.cs b/DiffBackup/Backup/Config/IConfig.cs
new file mode 100644
index 0000000..71e11b7
--- /dev/null
+++ b/DiffBackup/Backup/Config/IConfig.cs
@@ -0,0 +1,13 @@
+using Topten.JsonKit_tie_tdiff;
+
+namespace DiffBackup.Backup.Config
+{
+    public interface IConfig
+    {
+        IConfig Clone();
+        T Clone<T>() where T : IConfig;
+        string ToJson(JsonOptions options = JsonOptions.None);
+
+        void SetFromJson(string payload, JsonOptions options = JsonOptions.None);
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/InternalConfig.cs b/DiffBackup/Backup/Config/InternalConfig.cs
new file mode 100644
index 0000000..4f7482e
--- /dev/null
+++ b/DiffBackup/Backup/Config/InternalConfig.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace DiffBackup.Backup.Config
+{
+    public class InternalConfig : BaseConfig
+    {
+        public TimeSpanConfig ThrottleTimeSpan { get; set; } = TimeSpan.FromSeconds(60);
+
+        public TimeSpanConfig BackupTaskTimeoutTimeSpan { get; set; } = TimeSpan.FromMinutes(3);
+
+        public WorldSaveTrackingStrategy WorldSaveTrackingStrategy { get; set; } =
+            WorldSaveTrackingStrategy.Default;
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/Json/JsonConverters.cs b/DiffBackup/Backup/Config/Json/JsonConverters.cs
new file mode 100644
index 0000000..80137eb
--- /dev/null
+++ b/DiffBackup/Backup/Config/Json/JsonConverters.cs
@@ -0,0 +1,69 @@
+using System;
+using Topten.JsonKit_tie_tdiff;
+
+#nullable enable
+namespace DiffBackup.Backup.Config.Json
+{
+    public static class JsonConverters
+    {
+        /// <summary>
+        ///     Format: Days.Hours:Minutes:Seconds:Milliseconds
+        /// </summary>
+        public const string TimeSpanFormatString = @"d\.hh\:mm\:ss\:FFF";
+
+        private static readonly object Lock = new object();
+
+        static JsonConverters()
+        {
+            Install();
+        }
+
+        public static bool Installed { get; private set; }
+
+        public static bool Install()
+        {
+            if (!Installed)
+            {
+                lock (Lock)
+                {
+                    if (!Installed)
+                    {
+                        Topten.JsonKit_tie_tdiff.Json.RegisterFormatter<TimeSpanConfig>(WriteJson);
+                        Topten.JsonKit_tie_tdiff.Json.RegisterParser(TimeSpanParseJson);
+                        Topten.JsonKit_tie_tdiff.Json.RegisterFormatter<WorldSaveTrackingStrategy>(WriteJson);
+                        Topten.JsonKit_tie_tdiff.Json.RegisterParser(WorldSaveTrackingStrategyParseJson);
+                        Installed = true;
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static TimeSpanConfig TimeSpanParseJson(object literal)
+        {
+            return TimeSpanConfig.ParseJson(literal.ToString());
+        }
+
+        private static void WriteJson(IJsonWriter writer, TimeSpanConfig value)
+        {
+            writer.WriteStringLiteral(value.FormatJson());
+        }
+
+        private static void WriteJson(IJsonWriter writer, WorldSaveTrackingStrategy value)
+        {
+            writer.WriteStringLiteral(value.ToString());
+        }
+
+        private static WorldSaveTrackingStrategy WorldSaveTrackingStrategyParseJson(object literal)
+        {
+            if (Enum.TryParse((string) literal, out WorldSaveTrackingStrategy res))
+            {
+                return res;
+            }
+
+            return WorldSaveTrackingStrategy.SaveEventListener;
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/Json/TShockConfigHandler.cs b/DiffBackup/Backup/Config/Json/TShockConfigHandler.cs
new file mode 100644
index 0000000..ce08fc3
--- /dev/null
+++ b/DiffBackup/Backup/Config/Json/TShockConfigHandler.cs
@@ -0,0 +1,65 @@
+using System.IO;
+using System.Text;
+using Topten.JsonKit_tie_tdiff;
+using TShockAPI;
+
+#nullable enable
+namespace DiffBackup.Backup.Config.Json
+{
+    public class TShockConfigHandler
+    {
+        public readonly string BasePath;
+
+        public TShockConfigHandler(string basePath)
+        {
+            JsonConverters.Install();
+            BasePath = Path.GetFullPath(basePath);
+        }
+
+        public TShockConfigHandler() : this(TShock.SavePath)
+        {
+        }
+
+
+        public T LoadJson<T>(string fileName) where T : class?, new()
+        {
+            var path = Path.Combine(BasePath, fileName);
+            var content = File.ReadAllText(path, Encoding.UTF8);
+            return Topten.JsonKit_tie_tdiff.Json.Parse<T>(content, JsonOptions.NonStrictParser);
+        }
+
+        public bool TryLoadJson<T>(string fileName, out T result)
+            where T : new()
+        {
+            var path = GetFullPath(fileName);
+
+            if (!File.Exists(path))
+            {
+                result = new T();
+                return false;
+            }
+
+            var content = File.ReadAllText(path, Encoding.UTF8);
+            if (string.IsNullOrWhiteSpace(content))
+            {
+                result = new T();
+                return false;
+            }
+
+            result = Topten.JsonKit_tie_tdiff.Json.Parse<T>(content, JsonOptions.NonStrictParser);
+            return true;
+        }
+
+        public void SaveConfig<T>(T config, string fileName)
+        {
+            var path = GetFullPath(fileName);
+            var payload = Topten.JsonKit_tie_tdiff.Json.Format(config);
+            File.WriteAllText(path, payload, Encoding.UTF8);
+        }
+
+        public string GetFullPath(string fileName)
+        {
+            return Path.Combine(BasePath, fileName);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/StrategyConfig.cs b/DiffBackup/Backup/Config/StrategyConfig.cs
new file mode 100644
index 0000000..aa64db5
--- /dev/null
+++ b/DiffBackup/Backup/Config/StrategyConfig.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace DiffBackup.Backup.Config
+{
+    public class StrategyConfig : BaseConfig
+    {
+        public TimeSpanConfig EveryXTimeSpanDoFullBackup { get; set; } = TimeSpan.FromDays(7);
+
+        public double DiffFillFactorToStartFullBackup { get; set; } = 0.5;
+        public CleanupConfig Cleanup { get; set; } = new CleanupConfig();
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/TimeSpanConfig.cs b/DiffBackup/Backup/Config/TimeSpanConfig.cs
new file mode 100644
index 0000000..e42898d
--- /dev/null
+++ b/DiffBackup/Backup/Config/TimeSpanConfig.cs
@@ -0,0 +1,35 @@
+using System;
+using DiffBackup.Backup.Config.Json;
+
+namespace DiffBackup.Backup.Config
+{
+    public readonly struct TimeSpanConfig
+    {
+        public readonly TimeSpan Value;
+
+        public TimeSpanConfig(TimeSpan value)
+        {
+            Value = value;
+        }
+
+        public static implicit operator TimeSpan(TimeSpanConfig input)
+        {
+            return input.Value;
+        }
+
+        public static implicit operator TimeSpanConfig(TimeSpan input)
+        {
+            return new TimeSpanConfig(input);
+        }
+
+        public string FormatJson()
+        {
+            return Value.ToString(JsonConverters.TimeSpanFormatString);
+        }
+
+        public static TimeSpanConfig ParseJson(string literal)
+        {
+            return TimeSpan.ParseExact(literal, JsonConverters.TimeSpanFormatString, null);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/Backup/Config/WorldSaveTrackingStrategy.cs b/DiffBackup/Backup/Config/WorldSaveTrackingStrategy.cs
new file mode 100644
index 0000000..68dc03b
--- /dev/null
+++ b/DiffBackup/Backup/Config/WorldSaveTrackingStrategy.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace DiffBackup
+{
+    [Flags]
+    public enum WorldSaveTrackingStrategy : byte
+    {
+        None = 0,
+        FileSystemWatcher = 1,
+        SaveEventListener = 1 << 1,
+        All = FileSystemWatcher | SaveEventListener,
+        Default = SaveEventListener
+    }
+}
\ No newline at end of file
diff --git a/DiffBackup/DiffBackup.csproj b/DiffBackup/DiffBackup.csproj
index b9043fd..e45070b 100644
--- a/DiffBackup/DiffBackup.csproj
+++ b/DiffBackup/DiffBackup.csproj
@@ -41,6 +41,7 @@
         <Reference Include="System.Data" />
         <Reference Include="System.IO.Compression" />
         <Reference Include="System.IO.Compression.FileSystem" />
+        <Reference Include="System.Runtime.Serialization" />
         <Reference Include="System.Xml" />
         <Reference Include="TerrariaServer">
           <HintPath>..\TShock\TerrariaServer.exe</HintPath>
@@ -116,22 +117,112 @@
         <Compile Include="..\HumanDateParser\HumanDateParser\TokenKind.cs">
           <Link>HumanDateParser\TokenKind.cs</Link>
         </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\CancelReaderException.cs">
+          <Link>JsonKit\CancelReaderException.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\DecoratingActivator.cs">
+          <Link>JsonKit\DecoratingActivator.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\Emit.cs">
+          <Link>JsonKit\Emit.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IDictionaryExtensions.cs">
+          <Link>JsonKit\IDictionaryExtensions.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonLoaded.cs">
+          <Link>JsonKit\IJsonLoaded.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonLoadField.cs">
+          <Link>JsonKit\IJsonLoadField.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonLoading.cs">
+          <Link>JsonKit\IJsonLoading.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonReader.cs">
+          <Link>JsonKit\IJsonReader.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonWriter.cs">
+          <Link>JsonKit\IJsonWriter.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonWriting.cs">
+          <Link>JsonKit\IJsonWriting.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\IJsonWritten.cs">
+          <Link>JsonKit\IJsonWritten.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonAttribute.cs">
+          <Link>JsonKit\JsonAttribute.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonExcludeAttribute.cs">
+          <Link>JsonKit\JsonExcludeAttribute.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonKit.cs">
+          <Link>JsonKit\JsonKit.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonMemberInfo.cs">
+          <Link>JsonKit\JsonMemberInfo.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonOptions.cs">
+          <Link>JsonKit\JsonOptions.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonParseException.cs">
+          <Link>JsonKit\JsonParseException.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonReader.cs">
+          <Link>JsonKit\JsonReader.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonUnknownAttribute.cs">
+          <Link>JsonKit\JsonUnknownAttribute.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\JsonWriter.cs">
+          <Link>JsonKit\JsonWriter.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\LineOffset.cs">
+          <Link>JsonKit\LineOffset.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\LiteralKind.cs">
+          <Link>JsonKit\LiteralKind.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\ReflectionInfo.cs">
+          <Link>JsonKit\ReflectionInfo.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\ThreadSafeCache.cs">
+          <Link>JsonKit\ThreadSafeCache.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\Token.cs">
+          <Link>JsonKit\Token.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\Tokenizer.cs">
+          <Link>JsonKit\Tokenizer.cs</Link>
+        </Compile>
+        <Compile Include="..\JsonKit\Topten.JsonKit\Utils.cs">
+          <Link>JsonKit\Utils.cs</Link>
+        </Compile>
         <Compile Include="Backup\BackupIOWorker.cs" />
         <Compile Include="Backup\BackupRepository.cs" />
         <Compile Include="Backup\BackupRepositoryEntry.cs" />
         <Compile Include="Backup\BackupService.cs" />
         <Compile Include="Backup\BackupStrategy.cs" />
         <Compile Include="Backup\BackupUtils.cs" />
-        <Compile Include="Backup\Config\Config.cs" />
+        <Compile Include="Backup\Config\AllConfig.cs" />
+        <Compile Include="Backup\Config\CleanupConfig.cs" />
+        <Compile Include="Backup\Config\CleanupTimeConfig.cs" />
+        <Compile Include="Backup\Config\BaseConfig.cs" />
+        <Compile Include="Backup\Config\IConfig.cs" />
+        <Compile Include="Backup\Config\InternalConfig.cs" />
+        <Compile Include="Backup\Config\Json\JsonConverters.cs" />
+        <Compile Include="Backup\Config\Json\TShockConfigHandler.cs" />
+        <Compile Include="Backup\Config\StrategyConfig.cs" />
+        <Compile Include="Backup\Config\TimeSpanConfig.cs" />
+        <Compile Include="Backup\Config\WorldSaveTrackingStrategy.cs" />
         <Compile Include="Backup\IBackupService.cs" />
         <Compile Include="Backup\IBackupStrategy.cs" />
-        <Compile Include="Logger\DefaultTlog.cs" />
+        <Compile Include="Logger\BaseTlog.cs" />
         <Compile Include="Logger\ITlog.cs" />
         <Compile Include="Logger\LoggingExt.cs" />
         <Compile Include="Logger\TLog.cs" />
         <Compile Include="TdiffPlugin.cs" />
         <Compile Include="Properties\AssemblyInfo.cs" />
-        <Compile Include="WorldSaveTrackingStrategy.cs" />
     </ItemGroup>
     <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
     <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/DiffBackup/Logger/DefaultTlog.cs b/DiffBackup/Logger/BaseTlog.cs
similarity index 94%
rename from DiffBackup/Logger/DefaultTlog.cs
rename to DiffBackup/Logger/BaseTlog.cs
index ef3b579..6288119 100644
--- a/DiffBackup/Logger/DefaultTlog.cs
+++ b/DiffBackup/Logger/BaseTlog.cs
@@ -2,7 +2,7 @@
 
 namespace DiffBackup.Logger
 {
-    public abstract class DefaultTlog : ITlog
+    public abstract class BaseTlog : ITlog
     {
         public abstract void LogWriteLine(string text, TraceLevel level);
 
diff --git a/DiffBackup/Logger/TLog.cs b/DiffBackup/Logger/TLog.cs
index 30921d0..435ae65 100644
--- a/DiffBackup/Logger/TLog.cs
+++ b/DiffBackup/Logger/TLog.cs
@@ -4,7 +4,7 @@
 namespace DiffBackup.Logger
 {
     // ReSharper disable once InconsistentNaming
-    public class TLog : DefaultTlog
+    public class TLog : BaseTlog
     {
         private readonly TerrariaPlugin _plugin;
 
diff --git a/DiffBackup/TdiffPlugin.cs b/DiffBackup/TdiffPlugin.cs
index 661901d..02ebdc1 100644
--- a/DiffBackup/TdiffPlugin.cs
+++ b/DiffBackup/TdiffPlugin.cs
@@ -7,8 +7,10 @@
 using System.Threading;
 using System.Threading.Tasks;
 using DiffBackup.Backup;
+using DiffBackup.Backup.Config;
+using DiffBackup.Backup.Config.Json;
 using DiffBackup.Logger;
-using HumanDateParser_tie;
+using HumanDateParser_tie_tdiff;
 using Terraria;
 using TerrariaApi.Server;
 using TShockAPI;
@@ -26,7 +28,7 @@ public class DiffBackupPlugin : TerrariaPlugin
         private readonly IBackupService _backupService;
 
         private readonly FileSystemWatcher? _watcher;
-        public readonly WorldSaveTrackingStrategy TrackingStrategy = WorldSaveTrackingStrategy.SaveEventListener;
+        public readonly AllConfig Config;
         private Stopwatch _lastWriteStopwatch = new Stopwatch();
 
         private DateTime? _prevRestoreDate;
@@ -40,6 +42,7 @@ public class DiffBackupPlugin : TerrariaPlugin
         public DiffBackupPlugin(Main game) : base(game)
         {
             Order = 10;
+            Config = LoadOrCreateConfig();
             if (TrackingStrategy.HasFlag(WorldSaveTrackingStrategy.FileSystemWatcher))
             {
                 _watcher = new FileSystemWatcher {IncludeSubdirectories = false};
@@ -50,9 +53,11 @@ public DiffBackupPlugin(Main game) : base(game)
                 this.LogWarn("Tracking strategy set to none.");
             }
 
-            _backupService = new BackupService(this.Logger());
+            _backupService = new BackupService(this.Logger(), Config);
         }
 
+        public WorldSaveTrackingStrategy TrackingStrategy => Config.Internal.WorldSaveTrackingStrategy;
+
         /// <summary>
         ///     Gets the author(s) of this plugin
         /// </summary>
@@ -74,6 +79,20 @@ public DiffBackupPlugin(Main game) : base(game)
         /// </summary>
         public override Version Version => GetType().Assembly.GetName().Version;
 
+        private static AllConfig LoadOrCreateConfig()
+        {
+            var configHandler = new TShockConfigHandler();
+            var fileName = $"{Command.ToLower()}.json";
+            if (configHandler.TryLoadJson<AllConfig>(fileName, out var res))
+            {
+                return res;
+            }
+
+            res = new AllConfig();
+            configHandler.SaveConfig(res, fileName);
+            return res;
+        }
+
         /// <summary>
         ///     Handles plugin initialization.
         ///     Fired when the server is started and the plugin is being loaded.
@@ -130,7 +149,7 @@ private void DiffCmd(CommandArgs args)
             if (args.Parameters.Count == 0 || args.Parameters[0].ToLowerInvariant() == "help")
             {
                 args.Player.SendInfoMessage($"/{Command} ls <date> - list backups");
-                args.Player.SendInfoMessage($"/{Command} <date> - restore closest backup @ date");
+                args.Player.SendInfoMessage($"/{Command} restore <date> - restore closest backup @ date");
                 args.Player.SendInfoMessage($"/{Command} cleanup - to remove old backup entries");
                 return;
             }
@@ -176,77 +195,83 @@ List<DateTime> ListAndSortBackupDatetime()
                 return res;
             }
 
-            if (args.Parameters.Count > 0)
+            if (args.Parameters[0].ToLowerInvariant() == "ls" || args.Parameters[0].ToLowerInvariant() == "list")
             {
-                if (args.Parameters[0].ToLowerInvariant() == "ls" || args.Parameters[0].ToLowerInvariant() == "list")
-                {
-                    TryParseDate(out date, 1);
+                TryParseDate(out date, 1);
+
+                DisplayBackups(args, date, ListAndSortBackupDatetime());
+                return;
+            }
 
-                    DisplayBackups(args, date, ListAndSortBackupDatetime());
+            if (args.Parameters[0].ToLowerInvariant() == "cleanup")
+            {
+                if (TShock.ShuttingDown)
+                {
+                    this.LogWarn("TShock is Shutting Down.");
                     return;
                 }
 
-                if (args.Parameters[0].ToLowerInvariant() == "cleanup")
+                Task.Run(async () =>
                 {
-                    if (TShock.ShuttingDown)
+                    await _backupService.StartCleanup(Main.worldPathName).ContinueWith(task =>
                     {
-                        this.LogWarn("TShock is Shutting Down.");
-                        return;
-                    }
-
-                    Task.Factory.StartNew(async () =>
-                    {
-
-                        await _backupService.StartCleanup(Main.WorldPath).ContinueWith(task =>
+                        if (task.IsFaulted)
                         {
-                            if (task.IsFaulted)
+                            Exception exception = task.Exception;
+                            if (exception is AggregateException aggex && aggex.InnerExceptions.Count == 1)
                             {
-                                Exception exception = task.Exception;
-                                if (exception is AggregateException aggex && aggex.InnerExceptions.Count == 1)
-                                {
-                                    exception = aggex.InnerExceptions.First();
-                                }
-                                args.Player.SendErrorMessage($"Error: {exception.Message}");
-                                this.LogError(exception.BuildExceptionString());
+                                exception = aggex.InnerExceptions.First();
                             }
-                            else if (task.IsCompleted)
-                            {
-                                args.Player.SendSuccessMessage($"Deleted {task.Result.Count} old files");
-                                this.LogInfo($"Backup cleanup done with {task.Result.Count} files deleted");
-                            }
-                        });
+
+                            args.Player.SendErrorMessage($"Error: {exception.Message}");
+                            this.LogError(exception.BuildExceptionString());
+                        }
+                        else if (task.IsCompleted)
+                        {
+                            args.Player.SendSuccessMessage($"Deleted {task.Result.Count} old files");
+                            this.LogInfo($"Backup cleanup done with {task.Result.Count} files deleted");
+                        }
                     });
+                });
+                return;
+            }
+
+            if (args.Parameters[0].ToLowerInvariant() == "confirm")
+            {
+                if (_prevRestoreDate is null || !_prevRestoreStopwatch.IsRunning)
+                {
+                    args.Player.SendErrorMessage("There's nothing to confirm for now");
                     return;
                 }
 
-                if (args.Parameters[0].ToLowerInvariant() == "confirm")
+                if (_prevUserUuid != args.Player.UUID)
                 {
-                    if (_prevRestoreDate is null || !_prevRestoreStopwatch.IsRunning)
-                    {
-                        args.Player.SendErrorMessage("There's nothing to confirm for now");
-                        return;
-                    }
-
-                    if (_prevUserUuid != args.Player.UUID)
-                    {
-                        args.Player.SendErrorMessage("Someone else is trying to restore a backup !");
-                        return;
-                    }
-
-                    if (_prevRestoreStopwatch.Elapsed > TimeSpan.FromMinutes(2))
-                    {
-                        args.Player.SendErrorMessage("Confirmation timeout ! Try again");
-                        return;
-                    }
+                    args.Player.SendErrorMessage("Someone else is trying to restore a backup !");
+                    return;
+                }
 
-                    date = _prevRestoreDate.Value;
+                if (_prevRestoreStopwatch.Elapsed > TimeSpan.FromMinutes(2))
+                {
+                    args.Player.SendErrorMessage("Confirmation timeout ! Try again");
+                    return;
                 }
-                else if (!TryParseDate(out date) || date == default)
+
+                date = _prevRestoreDate.Value;
+            }
+            else if (args.Parameters[0].ToLowerInvariant() == "restore")
+            {
+                if (!TryParseDate(out date, 1) || date == default)
                 {
                     args.Player.SendErrorMessage("Unable to parse given date");
                     return;
                 }
             }
+            else
+            {
+                args.Player.SendErrorMessage($"Unknown command \"{args.Parameters[0]}\"");
+                return;
+            }
+
 
             var dates = ListAndSortBackupDatetime();
             if (!dates.Any())
@@ -384,7 +409,7 @@ async Task RecheckLaterAsync()
                 await _backupService.StartBackup(e.FullPath, now);
             }
 
-            Task.Factory.StartNew(async () => await RecheckLaterAsync());
+            Task.Run(RecheckLaterAsync);
         }
     }
 }
\ No newline at end of file
diff --git a/DiffBackup/WorldSaveTrackingStrategy.cs b/DiffBackup/WorldSaveTrackingStrategy.cs
deleted file mode 100644
index b78aece..0000000
--- a/DiffBackup/WorldSaveTrackingStrategy.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-
-namespace DiffBackup
-{
-    [Flags]
-    public enum WorldSaveTrackingStrategy : byte
-    {
-        None,
-        FileSystemWatcher,
-        SaveEventListener,
-        All = FileSystemWatcher | SaveEventListener
-    }
-}
\ No newline at end of file
diff --git a/DiffBackupTests/BackupServiceTests.cs b/DiffBackupTests/Backup/BackupServiceTests.cs
similarity index 96%
rename from DiffBackupTests/BackupServiceTests.cs
rename to DiffBackupTests/Backup/BackupServiceTests.cs
index e81da12..2702d7a 100644
--- a/DiffBackupTests/BackupServiceTests.cs
+++ b/DiffBackupTests/Backup/BackupServiceTests.cs
@@ -5,19 +5,23 @@
 using System.Net;
 using System.Threading;
 using DiffBackup.Backup;
+using DiffBackup.Backup.Config;
+using DiffBackup.Backup.Config.Json;
 using DiffBackup.Logger;
 using Moq;
 using Xunit;
 
-namespace DiffBackupTests
+namespace DiffBackupTests.Backup
 {
     public class BackupServiceTests : IDisposable
     {
         public BackupServiceTests()
         {
+            JsonConverters.Install();
             _temporaryPath = Path.Join(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
             Directory.CreateDirectory(_temporaryPath);
             _mockedLog = new Mock<ITlog>(MockBehavior.Loose);
+            _mockedConfig = new Mock<AllConfig>(MockBehavior.Loose){ CallBase = true };
             _worldFile = DownloadWorldFile();
             _worldFileHash = new Lazy<string>(() =>
             {
@@ -38,6 +42,7 @@ public void Dispose()
         private readonly string _worldFile;
         private readonly Lazy<string> _worldFileHash;
         private readonly Mock<ITlog> _mockedLog;
+        private readonly Mock<AllConfig> _mockedConfig;
         private readonly Random _random = new Random();
 
         private string DownloadWorldFile(
@@ -72,7 +77,7 @@ public void TestCreateDiff2xSameFile()
         {
             var originalHash = _worldFileHash.Value;
             using var cancellationTokenSource = new CancellationTokenSource();
-            using var service = new BackupService(_mockedLog.Object);
+            using var service = new BackupService(_mockedLog.Object, new AllConfig());
             var date = DateTime.Now;
             service.StartBackup(_worldFile, date, cancellationTokenSource.Token).Wait(cancellationTokenSource.Token);
             Assert.True(Directory.Exists(BackupUtils.GetRepoFilePath(_worldFile)));
@@ -105,7 +110,7 @@ public void TestCreateDiff2xSameFile()
         public void TestCreateDiffOnFreshNewRepo()
         {
             var originalHash = _worldFileHash.Value;
-            using var service = new BackupService(_mockedLog.Object);
+            using var service = new BackupService(_mockedLog.Object, new AllConfig());
             var date = DateTime.Now;
             service.StartBackup(_worldFile, date, CancellationToken.None).Wait();
             Assert.True(Directory.Exists(BackupUtils.GetRepoFilePath(_worldFile)));
@@ -131,7 +136,7 @@ public void TestRestoreUsingDirectCopy()
         {
             var originalHash = _worldFileHash.Value;
             using var cancellationTokenSource = new CancellationTokenSource();
-            using var service = new BackupService(_mockedLog.Object);
+            using var service = new BackupService(_mockedLog.Object, new AllConfig());
             var date = DateTime.Now;
             var originalDate = date;
             service.StartBackup(_worldFile, date, cancellationTokenSource.Token).Wait(cancellationTokenSource.Token);
@@ -190,7 +195,7 @@ public void TestRestoreUsingTheDiffFile()
         {
             var originalHash = _worldFileHash.Value;
             using var cancellationTokenSource = new CancellationTokenSource();
-            using var service = new BackupService(_mockedLog.Object);
+            using var service = new BackupService(_mockedLog.Object, new AllConfig());
             var date = DateTime.Now;
             service.StartBackup(_worldFile, date, cancellationTokenSource.Token).Wait(cancellationTokenSource.Token);
             var repo = new BackupRepository(BackupUtils.GetRepoFilePath(_worldFile));
diff --git a/DiffBackupTests/Backup/Config/Json/TShockConfigHandlerTests.cs b/DiffBackupTests/Backup/Config/Json/TShockConfigHandlerTests.cs
new file mode 100644
index 0000000..3ab1216
--- /dev/null
+++ b/DiffBackupTests/Backup/Config/Json/TShockConfigHandlerTests.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using DiffBackup;
+using DiffBackup.Backup;
+using DiffBackup.Backup.Config;
+using DiffBackup.Backup.Config.Json;
+using DiffBackup.Logger;
+using Equ;
+using Moq;
+using Topten.JsonKit_tie_tdiff;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace DiffBackupTests.Backup.Config.Json
+{
+    public class TShockConfigHandlerTests : IDisposable
+    {
+        private readonly ITestOutputHelper _testOutputHelper;
+
+        public TShockConfigHandlerTests(ITestOutputHelper testOutputHelper)
+        {
+            JsonConverters.Install();
+            _testOutputHelper = testOutputHelper;
+            _temporaryPath = Path.Join(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(_temporaryPath);
+            _mockedLog = new Mock<ITlog>(MockBehavior.Loose);
+            _mockedConfig = new Mock<AllConfig>(MockBehavior.Loose) {CallBase = true};
+        }
+
+        public void Dispose()
+        {
+            if (Directory.Exists(_temporaryPath))
+            {
+                Directory.Delete(_temporaryPath, true);
+            }
+        }
+
+        private readonly string _temporaryPath;
+        private readonly Mock<ITlog> _mockedLog;
+        private readonly Mock<AllConfig> _mockedConfig;
+        private readonly Random _random = new Random();
+
+        [Fact]
+        public void TestSaveDefaultConfig()
+        {
+            var configHandler = new TShockConfigHandler(_temporaryPath);
+            var fileName = $"{Guid.NewGuid():N}.json";
+            var path = configHandler.GetFullPath(fileName);
+            Assert.False(File.Exists(path));
+            configHandler.SaveConfig(new AllConfig(), fileName);
+            Assert.True(File.Exists(path));
+            var content = File.ReadAllText(path, Encoding.UTF8);
+            //_testOutputHelper.WriteLine(content);
+            Assert.False(string.IsNullOrWhiteSpace(content));
+        }
+
+        [Fact]
+        public void TestEnumSavedAsString()
+        {
+            var configHandler = new TShockConfigHandler(_temporaryPath);
+            var fileName = $"{Guid.NewGuid():N}.json";
+            var path = configHandler.GetFullPath(fileName);
+            var config = new AllConfig();
+            configHandler.SaveConfig(config, fileName);
+            var d = Topten.JsonKit_tie_tdiff.Json.ParseFile<IDictionary<string, object>>(path);
+            Assert.NotNull(d);
+            Assert.NotEmpty(d);
+            Assert.Equal(config.Internal.WorldSaveTrackingStrategy.ToString(),
+                d.GetPath<string>("internal.worldSaveTrackingStrategy"));
+        }
+        
+        [Fact]
+        public void TestTimeSpanSavedAsString()
+        {
+            var configHandler = new TShockConfigHandler(_temporaryPath);
+            var fileName = $"{Guid.NewGuid():N}.json";
+            var path = configHandler.GetFullPath(fileName);
+            var config = new AllConfig();
+            configHandler.SaveConfig(config, fileName);
+            var configReloaded = configHandler.LoadJson<AllConfig>(fileName);
+            var d = Topten.JsonKit_tie_tdiff.Json.ParseFile<IDictionary<string, object>>(path);
+            Assert.NotNull(d);
+            Assert.NotEmpty(d);
+            Assert.Equal("0.00:01:00:",
+                d.GetPath<string>("internal.throttleTimeSpan"));
+            Assert.Equal(config.Internal.ThrottleTimeSpan, configReloaded.Internal.ThrottleTimeSpan);
+        }
+
+        [Fact]
+        public void TestSaveLoad2x()
+        {
+            var configHandler = new TShockConfigHandler(_temporaryPath);
+            var fileName = $"{Guid.NewGuid():N}.json";
+            var path = configHandler.GetFullPath(fileName);
+            configHandler.SaveConfig(new AllConfig(), fileName);
+            var firstContent = File.ReadAllText(path, Encoding.UTF8);
+            var firstWriteTime = File.GetLastWriteTime(path);
+            var config = configHandler.LoadJson<AllConfig>(fileName);
+            configHandler.SaveConfig(config, fileName);
+            Assert.Equal(firstContent, File.ReadAllText(path, Encoding.UTF8));
+            Assert.True(File.GetLastWriteTime(path) > firstWriteTime);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DiffBackupTests/DefaultBackupStrategyTests.cs b/DiffBackupTests/Backup/DefaultBackupStrategyTests.cs
similarity index 91%
rename from DiffBackupTests/DefaultBackupStrategyTests.cs
rename to DiffBackupTests/Backup/DefaultBackupStrategyTests.cs
index 94a4b3c..7cac262 100644
--- a/DiffBackupTests/DefaultBackupStrategyTests.cs
+++ b/DiffBackupTests/Backup/DefaultBackupStrategyTests.cs
@@ -2,20 +2,24 @@
 using System.IO;
 using System.Linq;
 using DiffBackup.Backup;
+using DiffBackup.Backup.Config;
+using DiffBackup.Backup.Config.Json;
 using DiffBackup.Logger;
 using Moq;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace DiffBackupTests
+namespace DiffBackupTests.Backup
 {
     public class DefaultBackupStrategyTests : IDisposable
     {
         public DefaultBackupStrategyTests(ITestOutputHelper testOutputHelper)
         {
+            JsonConverters.Install();
             _testOutputHelper = testOutputHelper;
             _temporaryPath = Path.Join(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
             _mockedLog = new Mock<ITlog>(MockBehavior.Loose);
+            _mockedConfig = new Mock<StrategyConfig>(MockBehavior.Loose){ CallBase = true };
             Directory.CreateDirectory(_temporaryPath);
         }
 
@@ -30,6 +34,7 @@ public void Dispose()
         private readonly ITestOutputHelper _testOutputHelper;
         private readonly string _temporaryPath;
         private readonly Mock<ITlog> _mockedLog;
+        private Mock<StrategyConfig> _mockedConfig;
 
 
         private BackupRepository CreateEmptyRepo()
@@ -49,7 +54,7 @@ private BackupRepository CreateRepoWithOldEntry(DateTime dateTime, string fileNa
         [Fact]
         public void TestGetReferenceOnEmptyRepo()
         {
-            var strategy = new DefaultBackupStrategy(_mockedLog.Object);
+            var strategy = new DefaultBackupStrategy(_mockedLog.Object, new StrategyConfig());
             var repo = CreateEmptyRepo();
             Assert.Null(strategy.GetReference(repo, DateTime.Now));
         }
@@ -58,7 +63,7 @@ public void TestGetReferenceOnEmptyRepo()
         public void TestGetReferenceOnOldEntry()
         {
             var fname = $"{Guid.NewGuid():N}.test";
-            var strategy = new DefaultBackupStrategy(_mockedLog.Object);
+            var strategy = new DefaultBackupStrategy(_mockedLog.Object, new StrategyConfig());
             var dateTime = DateTime.Now;
             var repo = CreateRepoWithOldEntry(dateTime - strategy.ForceFullBackupTimeSpan, fname);
             Assert.Null(strategy.GetReference(repo, dateTime));
@@ -69,7 +74,7 @@ public void TestGetReferenceOnRecentEntry()
         {
             var dateTime = DateTime.Now;
             var fname = BackupUtils.FormatWorldFileName(dateTime, Guid.NewGuid().ToString("N"));
-            var strategy = new DefaultBackupStrategy(_mockedLog.Object);
+            var strategy = new DefaultBackupStrategy(_mockedLog.Object, new StrategyConfig());
             var repo = CreateRepoWithOldEntry(dateTime, fname);
             var res = strategy.GetReference(repo, dateTime);
             Assert.NotNull(res);
@@ -110,7 +115,7 @@ public void TestListExpiredEntriesOnFakeRepo()
                 }
             }
 
-            var strategy = new DefaultBackupStrategy(_mockedLog.Object);
+            var strategy = new DefaultBackupStrategy(_mockedLog.Object, new StrategyConfig());
 
             var res = strategy.ListExpiredEntries(repo, dateTime);
             _testOutputHelper.WriteLine(res.ToString());
diff --git a/DiffBackupTests/DiffBackupTests.csproj b/DiffBackupTests/DiffBackupTests.csproj
index 1b135ea..a3ac082 100644
--- a/DiffBackupTests/DiffBackupTests.csproj
+++ b/DiffBackupTests/DiffBackupTests.csproj
@@ -12,6 +12,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <PackageReference Include="Equ" Version="2.2.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
         <PackageReference Include="Moq" Version="4.14.4" />
         <PackageReference Include="xunit" Version="2.4.1" />
diff --git a/JsonKit b/JsonKit
new file mode 160000
index 0000000..8c640fd
--- /dev/null
+++ b/JsonKit
@@ -0,0 +1 @@
+Subproject commit 8c640fd5ce38440a93b4c0ad668fb0aa619a88f6
diff --git a/README.md b/README.md
index 01ec167..7b499ce 100644
--- a/README.md
+++ b/README.md
@@ -11,9 +11,9 @@ Terraria TShock World file backup system
 
 ## Commands
 ```
-/tdiff <date>    | restore wld backup at <date>
-/tdiff ls        | list most recent backups
-/tdiff ls <date> | list backups close to given date
+/tdiff restore <date>  | restore wld backup at <date>
+/tdiff ls              | list most recent backups
+/tdiff ls <date>       | list backups close to given date
 ```
 
 ## Permissions
@@ -25,8 +25,6 @@ tdiff    | allow user/group to issue tdiff commands
 - This plugin **only** backup the serving *wld* file. **No backup is made for sqlite, json, etc... tshock related files**. Ie if you use SSC you should backup the sqlite *db* files on your own.
 - In order to restore a backup the server shuts off and one has to restart it.
 
-## TODOs
-- As of now no backup cleanup logic implemented. The backup folder's size keep growing up (slowly thanks to the diff algorithm).
 
 ## How it work
 
@@ -91,5 +89,5 @@ assuming there's at **least 1 backup**:
 1. `copy` any *wld* file found in the backup folder to the *worlds folder*
 2. `rename` the copied file as the **exact** original *wld* file name.
 3. `start` tshock with the copied file (the world may be in a really old version that's not important for now)
-4. use `/tdiff <date>` commands to restore the backup you want
+4. use `/tdiff restore <date>` commands to restore the backup you want
 5. `restart` tshock
\ No newline at end of file
diff --git a/bootstrap.py b/bootstrap.py
index a54835b..8bed596 100644
--- a/bootstrap.py
+++ b/bootstrap.py
@@ -40,7 +40,7 @@ def submodule_init(name: str, remote_url:str, cwd: OptionalPath='./', version='l
     subprocess.check_call(shlex.split(cmd), cwd=str(cwd / name))
 
 
-def submodule_rename_namespace(name: str, namespaces: Collection[str], cwd: OptionalPath='./', suffix: str='tie'):
+def submodule_rename_namespace(name: str, namespaces: Collection[str], cwd: OptionalPath='./', suffix: str='tie_tdiff'):
     if cwd is None:
         cwd = './'
     cwd: Path = Path(cwd)
@@ -72,7 +72,12 @@ def human_date_parser_init(name: str='HumanDateParser', remote_url="https://gith
     submodule_init(name=name, remote_url=remote_url, version=version)
     submodule_rename_namespace(name=name, namespaces=namespaces)
 
+def json_kit_init(name: str='JsonKit', remote_url="https://github.com/toptensoftware/JsonKit.git", version='b1.1.121', namespaces=('Topten.JsonKit',)):
+    submodule_init(name=name, remote_url=remote_url, version=version)
+    submodule_rename_namespace(name=name, namespaces=namespaces)
+
 if __name__ == "__main__":
     download_tshock()
     deltaq_init()
     human_date_parser_init()
+    json_kit_init()