diff --git a/.cargo/config.toml b/.cargo/config.toml
index 37bb90a..d1675c8 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,3 +1,3 @@
 [alias]
-runs = "run -- paper 1.19.4-545 --config data/config --backup data/backups --world data/worlds --jar data/paper-1.19.4-525.jar"
-runrs = "run --release -- paper 1.19.4-545 --config data/config --backup data/backups --world data/worlds --jar data/paper-1.19.4-525.jar"
+runs = "run -- paper 1.19.4-545 --config data/config --backup data/backups --world data/worlds --jar data/paper.jar"
+runrs = "run --release -- paper 1.19.4-545 --config data/config --backup data/backups --world data/worlds --jar data/paper.jar"
diff --git a/src/server/backups.rs b/src/server/backups.rs
index b117e22..e5fd4de 100644
--- a/src/server/backups.rs
+++ b/src/server/backups.rs
@@ -3,8 +3,6 @@ use flate2::Compression;
 use std::fs::File;
 use std::io;
 use std::path::{Path, PathBuf};
-use chrono::{Utc, Local};
-use std::collections::HashSet;
 
 #[link(name = "c")]
 extern "C" {
@@ -19,10 +17,8 @@ pub struct BackupManager {
     config_dir: PathBuf,
     world_dir: PathBuf,
     max_backups: u64,
-    /// Start time of the last successful backup
-    last_start_time: Option<chrono::DateTime<chrono::Utc>>,
-    /// Files contained in the last successful backup
-    last_files: HashSet<(PathBuf, PathBuf)>
+    start_time: Option<chrono::DateTime<chrono::Local>>,
+    files: Vec<(PathBuf, PathBuf)>
 }
 
 impl BackupManager {
@@ -37,17 +33,17 @@ impl BackupManager {
             config_dir,
             world_dir,
             max_backups,
-            last_start_time: None,
-            last_files: HashSet::new()
+            start_time: None,
+            files: Vec::new()
         }
     }
 
-    fn files_to_backup(&mut self) -> io::Result<HashSet<(PathBuf, PathBuf)>> {
+    fn set_files_to_backup(&mut self) -> io::Result<()> {
         let mut dirs = vec![
             (PathBuf::from("worlds"), self.world_dir.clone()),
             (PathBuf::from("config"), self.config_dir.clone()),
         ];
-        let mut files: HashSet<(PathBuf, PathBuf)> = HashSet::new();
+        self.files.clear();
 
         while let Some((path_in_tar, path)) = dirs.pop() {
             for res in path.read_dir()? {
@@ -64,49 +60,28 @@ impl BackupManager {
                 if entry.file_type()?.is_dir() {
                     dirs.push((new_path_in_tar, entry.path()));
                 } else {
-                    // Only add files that have been updated since the last backup (incremental backup)
-                    if let Some(last_start_time) = self.last_start_time {
-                        let last_modified = entry.path().metadata()?.modified();
-
-                        if let Ok(last_modified) = last_modified {
-                            let t: chrono::DateTime<Utc> = last_modified.into();
-                            let t = t.with_timezone(&Local);
-
-                            if t < last_start_time {
-                                continue
-                            }
-                        }
-                    }
-
-                    files.insert((new_path_in_tar, entry.path()));
+                    self.files.push((new_path_in_tar, entry.path()));
                 }
             }
         }
 
-        Ok(files)
+        Ok(())
     }
 
     pub fn create_archive(&mut self) -> io::Result<()> {
-        let start_time = chrono::offset::Utc::now();
+        let start_time = chrono::offset::Local::now();
+        self.start_time = Some(start_time);
 
         let filename = format!("{}", start_time.format(FILENAME_FORMAT));
         let path = self.backup_dir.join(filename);
         let tar_gz = File::create(path)?;
         let enc = GzEncoder::new(tar_gz, Compression::default());
-        let mut ar = tar::Builder::new(enc);
+        let mut tar = tar::Builder::new(enc);
 
-        let files = self.files_to_backup()?;
+        self.set_files_to_backup()?;
 
-        for (path_in_tar, path) in &files {
-            ar.append_path_with_name(path, path_in_tar)?;
-        }
-
-        let deleted_files = self.last_files.difference(&files);
-
-        println!("{} {}", files.len(), self.last_files.len());
-
-        for (path_in_tar, path) in deleted_files {
-            println!("{path_in_tar:?}: {path:?}");
+        for (path_in_tar, path) in &self.files {
+            tar.append_path_with_name(path, path_in_tar)?;
         }
 
         // TODO re-add this info file in some way
@@ -123,10 +98,6 @@ impl BackupManager {
         // }
 
         // tar.append_data(&mut header, "info.txt", info_bytes)?;
-        
-        // After a successful backup, we store the original metadata
-        self.last_start_time = Some(start_time);
-        self.last_files = files;
 
         Ok(())
     }
diff --git a/src/server/process.rs b/src/server/process.rs
index 7555aa3..f503c84 100644
--- a/src/server/process.rs
+++ b/src/server/process.rs
@@ -88,7 +88,7 @@ impl ServerProcess {
         // We wait some time to (hopefully) ensure the save-all call has completed
         std::thread::sleep(std::time::Duration::from_secs(10));
 
-        let start_time = chrono::offset::Utc::now();
+        let start_time = chrono::offset::Local::now();
         let res = self.backups.create_archive();
 
         if res.is_ok() {
@@ -98,7 +98,7 @@ impl ServerProcess {
         // The server's save feature needs to be enabled again even if the archive failed to create
         self.custom("save-on")?;
 
-        let duration = chrono::offset::Utc::now() - start_time;
+        let duration = chrono::offset::Local::now() - start_time;
         let duration_str = format!(
             "{}m{}s",
             duration.num_seconds() / 60,