From 76ec44d4e6df866cc68cb820815bb9b73e91d7a1 Mon Sep 17 00:00:00 2001
From: zxq5 <zxq5@zxq5.dev>
Date: Tue, 15 Jul 2025 00:40:12 +0100
Subject: [PATCH] added notes, improved other features and removed most bugs

---
 Cargo.lock                                    |  13 +
 Cargo.toml                                    |   2 +
 .../ee0fa255-9a71-44b1-9556-e7b3157f1f77.json |   1 +
 .../1da3111e-717a-4452-8209-98c5443fc31a.json |  13 +
 .../67e29043-9aa8-4dd9-807c-cc7385eb6847.json |  16 +
 .../d1b10e0c-f6b4-4b9d-a96e-cb51213f0243.json |  22 +
 project/objects/zxq5.json                     |  28 --
 .../a24b3ab7-2572-4af4-8457-df26937fd773.json |  37 ++
 .../c96f5e87-7517-44cc-a5ab-42ffd537801d.json |  25 ++
 project/templates/character.json              |  48 --
 src/error.rs                                  |  22 +
 src/explorer.rs                               | 159 +++++++
 src/main.rs                                   | 163 ++-----
 src/main_editor.rs                            |   1 -
 src/note.rs                                   | 109 +++++
 src/object.rs                                 | 169 +++-----
 src/scene.rs                                  |  27 ++
 src/template.rs                               | 410 ++++++++++--------
 18 files changed, 777 insertions(+), 488 deletions(-)
 create mode 100644 project/notes/ee0fa255-9a71-44b1-9556-e7b3157f1f77.json
 create mode 100644 project/objects/1da3111e-717a-4452-8209-98c5443fc31a.json
 create mode 100644 project/objects/67e29043-9aa8-4dd9-807c-cc7385eb6847.json
 create mode 100644 project/objects/d1b10e0c-f6b4-4b9d-a96e-cb51213f0243.json
 delete mode 100644 project/objects/zxq5.json
 create mode 100644 project/templates/a24b3ab7-2572-4af4-8457-df26937fd773.json
 create mode 100644 project/templates/c96f5e87-7517-44cc-a5ab-42ffd537801d.json
 delete mode 100644 project/templates/character.json
 create mode 100644 src/error.rs
 create mode 100644 src/explorer.rs
 create mode 100644 src/note.rs
 create mode 100644 src/scene.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2c38be1..2a93bc6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3267,6 +3267,8 @@ dependencies = [
  "serde",
  "serde_json",
  "thiserror 2.0.12",
+ "uuid",
+ "walkdir",
 ]
 
 [[package]]
@@ -3611,6 +3613,17 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
+[[package]]
+name = "uuid"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
+dependencies = [
+ "getrandom 0.3.3",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "v_frame"
 version = "0.3.9"
diff --git a/Cargo.toml b/Cargo.toml
index ea783f5..d67336c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,3 +20,5 @@ serde_json = "1.0.140"
 chrono = { version = "0.4.41", features = ["serde"] }
 thiserror = "2.0.12"
 egui_commonmark = { version = "0.20.0", features = ["embedded_image"] }
+walkdir = "2.5.0"
+uuid = { version = "1.17.0", features = ["v4"] }
diff --git a/project/notes/ee0fa255-9a71-44b1-9556-e7b3157f1f77.json b/project/notes/ee0fa255-9a71-44b1-9556-e7b3157f1f77.json
new file mode 100644
index 0000000..cd0118f
--- /dev/null
+++ b/project/notes/ee0fa255-9a71-44b1-9556-e7b3157f1f77.json
@@ -0,0 +1 @@
+{"name":"Note","content":"this is the note! gfjh gfdhgj fgfjhghfd iughuifghuifghuifghuifghuifdg"}
\ No newline at end of file
diff --git a/project/objects/1da3111e-717a-4452-8209-98c5443fc31a.json b/project/objects/1da3111e-717a-4452-8209-98c5443fc31a.json
new file mode 100644
index 0000000..88a8990
--- /dev/null
+++ b/project/objects/1da3111e-717a-4452-8209-98c5443fc31a.json
@@ -0,0 +1,13 @@
+{
+  "id": "1da3111e-717a-4452-8209-98c5443fc31a",
+  "template_id": "c96f5e87-7517-44cc-a5ab-42ffd537801d",
+  "name": "sword",
+  "fields": {
+    "description": {
+      "value": "idk, it probably looks cool"
+    },
+    "durability": {
+      "value": "13.1"
+    }
+  }
+}
\ No newline at end of file
diff --git a/project/objects/67e29043-9aa8-4dd9-807c-cc7385eb6847.json b/project/objects/67e29043-9aa8-4dd9-807c-cc7385eb6847.json
new file mode 100644
index 0000000..d23a7e2
--- /dev/null
+++ b/project/objects/67e29043-9aa8-4dd9-807c-cc7385eb6847.json
@@ -0,0 +1,16 @@
+{
+  "id": "67e29043-9aa8-4dd9-807c-cc7385eb6847",
+  "template_id": "c96f5e87-7517-44cc-a5ab-42ffd537801d",
+  "name": "sword",
+  "fields": {
+    "durability": {
+      "value": "8.6"
+    },
+    "Icon": {
+      "value": "/home/zxq5/Projects/Minecraft/Packs/ZXQ5 projects/ZXQ5 x/ZXQ5 x-512/ZXQ5 x Release/classic.pack.png"
+    },
+    "description": {
+      "value": "idk"
+    }
+  }
+}
\ No newline at end of file
diff --git a/project/objects/d1b10e0c-f6b4-4b9d-a96e-cb51213f0243.json b/project/objects/d1b10e0c-f6b4-4b9d-a96e-cb51213f0243.json
new file mode 100644
index 0000000..7b96f6a
--- /dev/null
+++ b/project/objects/d1b10e0c-f6b4-4b9d-a96e-cb51213f0243.json
@@ -0,0 +1,22 @@
+{
+  "id": "d1b10e0c-f6b4-4b9d-a96e-cb51213f0243",
+  "template_id": "a24b3ab7-2572-4af4-8457-df26937fd773",
+  "name": "zxq5",
+  "fields": {
+    "Appearance": {
+      "value": "taller than panic"
+    },
+    "Date of Birth": {
+      "value": "2025-07-15"
+    },
+    "Portrait / Image": {
+      "value": "/home/zxq5/Pictures/logos and pfps/YT profile picture background.png"
+    },
+    "Age": {
+      "value": "19"
+    },
+    "Personality": {
+      "value": "coder"
+    }
+  }
+}
\ No newline at end of file
diff --git a/project/objects/zxq5.json b/project/objects/zxq5.json
deleted file mode 100644
index 39b12b4..0000000
--- a/project/objects/zxq5.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "template_name": "Character",
-  "template_path": "templates/character.json",
-  "name": "zxq5",
-  "fields": {
-    "Age": {
-      "value": "19"
-    },
-    "Birth Date": {
-      "value": "2025-07-11"
-    },
-    "Name": {
-      "value": "zxq5"
-    },
-    "Backstory": {
-      "value": "zxq5"
-    },
-    "Profile Picture": {
-      "value": "/home/zxq5/Pictures/logos and pfps/YT profile picture.png"
-    },
-    "Personality": {
-      "value": "zxq5"
-    },
-    "Appearance": {
-      "value": "zxq5"
-    }
-  }
-}
\ No newline at end of file
diff --git a/project/templates/a24b3ab7-2572-4af4-8457-df26937fd773.json b/project/templates/a24b3ab7-2572-4af4-8457-df26937fd773.json
new file mode 100644
index 0000000..74366b9
--- /dev/null
+++ b/project/templates/a24b3ab7-2572-4af4-8457-df26937fd773.json
@@ -0,0 +1,37 @@
+{
+  "name": "Character",
+  "id": "a24b3ab7-2572-4af4-8457-df26937fd773",
+  "description": "character",
+  "fields": [
+    {
+      "name": "Portrait / Image",
+      "field_type": "Image",
+      "required": true,
+      "description": "image of character"
+    },
+    {
+      "name": "Date of Birth",
+      "field_type": "Date",
+      "required": false,
+      "description": "date of birth"
+    },
+    {
+      "name": "Age",
+      "field_type": "Number",
+      "required": false,
+      "description": "age"
+    },
+    {
+      "name": "Appearance",
+      "field_type": "MultiLine",
+      "required": false,
+      "description": "character's appearance"
+    },
+    {
+      "name": "Personality",
+      "field_type": "MultiLine",
+      "required": false,
+      "description": "character's personality"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/project/templates/c96f5e87-7517-44cc-a5ab-42ffd537801d.json b/project/templates/c96f5e87-7517-44cc-a5ab-42ffd537801d.json
new file mode 100644
index 0000000..ebcd7bf
--- /dev/null
+++ b/project/templates/c96f5e87-7517-44cc-a5ab-42ffd537801d.json
@@ -0,0 +1,25 @@
+{
+  "name": "Item",
+  "id": "c96f5e87-7517-44cc-a5ab-42ffd537801d",
+  "description": "an in-game item",
+  "fields": [
+    {
+      "name": "durability",
+      "field_type": "Number",
+      "required": false,
+      "description": "the item's durability"
+    },
+    {
+      "name": "description",
+      "field_type": "MultiLine",
+      "required": true,
+      "description": "the item's description"
+    },
+    {
+      "name": "Icon",
+      "field_type": "Image",
+      "required": false,
+      "description": "yes"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/project/templates/character.json b/project/templates/character.json
deleted file mode 100644
index 6c88655..0000000
--- a/project/templates/character.json
+++ /dev/null
@@ -1,48 +0,0 @@
-{
-  "name": "Character",
-  "description": "character template!",
-  "fields": [
-    {
-      "name": "Profile Picture",
-      "field_type": "Image",
-      "required": false,
-      "description": "Path to character's profile picture"
-    },
-    {
-      "name": "Name",
-      "field_type": "SingleLine",
-      "required": true,
-      "description": "The full name of the character"
-    },
-    {
-      "name": "Age",
-      "field_type": "Number",
-      "required": false,
-      "description": "Character's age in years"
-    },
-    {
-      "name": "Birth Date",
-      "field_type": "Date",
-      "required": false,
-      "description": "Date of birth (YYYY-MM-DD)"
-    },
-    {
-      "name": "Appearance",
-      "field_type": "MultiLine",
-      "required": false,
-      "description": "Physical description of the character"
-    },
-    {
-      "name": "Personality",
-      "field_type": "MultiLine",
-      "required": false,
-      "description": "Personality traits and behavior"
-    },
-    {
-      "name": "Backstory",
-      "field_type": "MultiLine",
-      "required": false,
-      "description": "Character's history and background"
-    }
-  ]
-}
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..441e43c
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,22 @@
+pub struct Error {
+    message: String,
+    visible: bool,
+}
+
+impl Error {
+    pub fn new(message: String) -> Self {
+        Self {
+            message,
+            visible: true,
+        }
+    }
+
+    pub fn show(&mut self, ui: &mut egui::Ui) {
+        egui::Window::new("Error")
+            .open(&mut self.visible)
+            .fixed_size([200.0, 100.0])
+            .show(ui.ctx(), |ui| {
+                ui.label(self.message.clone());
+            });
+    }
+}
diff --git a/src/explorer.rs b/src/explorer.rs
new file mode 100644
index 0000000..95c3fe3
--- /dev/null
+++ b/src/explorer.rs
@@ -0,0 +1,159 @@
+use egui::RichText;
+
+use crate::{
+    PROJECT_FOLDER, RightPanelContent,
+    note::Note,
+    object::ObjectInstance,
+    template::{FieldType, Template},
+};
+
+pub struct Explorer {}
+
+impl Explorer {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn ui(&mut self, to_load: &mut Option<RightPanelContent>, ui: &mut egui::Ui) {
+        let (templates, objects) = match Self::load_templates() {
+            Ok((templates, objects)) => (templates, objects),
+            Err(e) => {
+                eprintln!("Failed to load project: {e}");
+                ui.label(RichText::new("Failed to load project").color(egui::Color32::RED));
+                return;
+            }
+        };
+
+        ui.vertical(|ui| {
+            egui::collapsing_header::CollapsingState::load_with_default_open(
+                ui.ctx(),
+                ui.make_persistent_id("templates"),
+                true,
+            )
+            .show_header(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label("Templates");
+                    if ui.button("+").clicked() {
+                        *to_load = Some(RightPanelContent::Template {
+                            template: Box::new(Template::default()),
+                            new_field_name: Default::default(),
+                            new_field_type: FieldType::SingleLine,
+                            new_field_required: false,
+                            new_field_description: Default::default(),
+                        });
+                    }
+                });
+            })
+            .body(|ui| {
+                for template in &templates {
+                    let id = ui.make_persistent_id(template.name.clone());
+                    egui::collapsing_header::CollapsingState::load_with_default_open(
+                        ui.ctx(),
+                        id,
+                        true,
+                    )
+                    .show_header(ui, |ui| {
+                        // load the template
+                        if ui.selectable_label(false, template.name.clone()).clicked() {
+                            *to_load = Some(RightPanelContent::template(Some(template.clone())));
+                        }
+
+                        // create a new object based on this template
+                        if ui.button("+").clicked() {
+                            *to_load = Some(RightPanelContent::Object {
+                                object: Box::new(ObjectInstance::new(template)),
+                            });
+                        }
+                    })
+                    .body(|ui| {
+                        for object in &objects {
+                            if object.template_id == template.id {
+                                ui.horizontal(|ui| {
+                                    ui.add_space(10.0);
+
+                                    // load the object
+                                    if ui.selectable_label(false, &object.name).clicked() {
+                                        *to_load = Some(RightPanelContent::Object {
+                                            object: Box::new(object.clone()),
+                                        });
+                                    }
+                                });
+                            }
+                        }
+                    });
+                }
+            });
+
+            let notes = Self::load_notes().unwrap();
+
+            egui::collapsing_header::CollapsingState::load_with_default_open(
+                ui.ctx(),
+                ui.make_persistent_id("notes"),
+                true,
+            )
+            .show_header(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.label("Notes");
+                    if ui.button("+").clicked() {
+                        *to_load = Some(RightPanelContent::Note {
+                            note: Box::new(Note::default()),
+                        });
+                    }
+                });
+            })
+            .body(|ui| {
+                for note in &notes {
+                    ui.horizontal(|ui| {
+                        ui.add_space(10.0);
+
+                        // load the note
+                        if ui.selectable_label(false, &note.name).clicked() {
+                            *to_load = Some(RightPanelContent::Note {
+                                note: Box::new(note.clone()),
+                            });
+                        }
+                    });
+                }
+            });
+
+            egui::CollapsingHeader::new("Projects").show(ui, |ui| {});
+        });
+    }
+
+    fn load_templates() -> std::io::Result<(Vec<Template>, Vec<ObjectInstance>)> {
+        let mut templates = Vec::new();
+        let mut objects = Vec::new();
+
+        for entry in std::fs::read_dir(PROJECT_FOLDER.join("templates")).unwrap() {
+            let path = entry.unwrap().path();
+            match Template::load(path.file_stem().unwrap().to_str().unwrap()) {
+                Ok(t) => templates.push(t),
+                Err(err) => eprintln!("Could not parse file {path:?}: {err}"),
+            }
+        }
+
+        for entry in std::fs::read_dir(PROJECT_FOLDER.join("objects")).unwrap() {
+            let path = entry.unwrap().path();
+            match ObjectInstance::load(path.file_stem().unwrap().to_str().unwrap()) {
+                Ok(o) => objects.push(o),
+                Err(err) => eprintln!("Could not parse file {path:?}: {err}"),
+            }
+        }
+
+        Ok((templates, objects))
+    }
+
+    fn load_notes() -> std::io::Result<Vec<Note>> {
+        let mut notes = Vec::new();
+
+        for entry in std::fs::read_dir(PROJECT_FOLDER.join("notes")).unwrap() {
+            let path = entry.unwrap().path();
+            match Note::load(path.file_stem().unwrap().to_str().unwrap()) {
+                Ok(note) => notes.push(note),
+                Err(err) => eprintln!("Could not parse file {path:?}: {err}"),
+            }
+        }
+
+        Ok(notes)
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index e2121bb..f4e96de 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,13 +2,19 @@ use std::{fs, path::PathBuf, sync::LazyLock};
 
 use egui::{RichText, ScrollArea};
 
+mod error;
+mod explorer;
 mod main_editor;
+mod note;
 mod object;
+mod scene;
 mod template;
 use egui_file::DialogType;
 use object::ObjectInstance;
 use template::{FieldType, Template};
 
+use crate::{explorer::Explorer, note::Note};
+
 static PROJECT_FOLDER: LazyLock<PathBuf> = LazyLock::new(|| {
     let mut path = std::env::current_dir().unwrap();
     path.push("project");
@@ -27,98 +33,24 @@ fn main() {
 }
 
 pub struct Interface {
-    text: String,
     dialog: Option<egui_file::FileDialog>,
     right_panel_content: RightPanelContent,
     editor: main_editor::MainEditor,
+    scene: scene::EditorScene,
+    explorer: Explorer,
 }
 
 impl Interface {
     #[must_use]
     pub fn new() -> Self {
         Self {
-            text: "".to_string(),
             dialog: None,
             right_panel_content: RightPanelContent::None,
             editor: main_editor::MainEditor::new(),
+            scene: scene::EditorScene::new(),
+            explorer: Explorer::new(),
         }
     }
-
-    fn show_directory(
-        &mut self,
-        ui: &mut egui::Ui,
-        path: &PathBuf,
-        depth: usize,
-    ) -> std::io::Result<()> {
-        if !path.exists() {
-            return Ok(());
-        }
-
-        let indent = "    ".repeat(depth);
-        let entries = fs::read_dir(path)?;
-        let mut dirs = Vec::new();
-        let mut files = Vec::new();
-
-        for entry in entries {
-            let entry = entry?;
-            let path = entry.path();
-            if path.is_dir() {
-                dirs.push(path);
-            } else if let Some(ext) = path.extension() {
-                if ext == "json" {
-                    // Only show JSON files
-                    files.push(path);
-                }
-            }
-        }
-
-        // Sort directories and files alphabetically
-        dirs.sort();
-        files.sort();
-
-        // Show directories first
-        for dir in dirs {
-            let dir_name = dir
-                .file_name()
-                .and_then(|n| n.to_str())
-                .unwrap_or("<invalid>")
-                .to_owned()
-                + "/";
-
-            if egui::CollapsingHeader::new(dir_name.clone())
-                .default_open(depth < 1)
-                .show(ui, |ui| self.show_directory(ui, &dir, depth + 1))
-                .body_returned
-                .is_none()
-            {
-                ui.label(RichText::new(format!(
-                    "{indent}❌ Error reading {dir_name}"
-                )));
-            }
-        }
-
-        // Then show files
-        for file in files {
-            if let Some(file_name) = file.file_name().and_then(|n| n.to_str()) {
-                let response = ui.horizontal(|ui| {
-                    ui.label("  ".repeat(depth));
-                    ui.selectable_label(false, file_name)
-                });
-
-                if response.inner.clicked() {
-                    if let Ok(instance) = ObjectInstance::load(file.clone()) {
-                        self.right_panel_content =
-                            RightPanelContent::instance(Some(file.clone()), Some(instance));
-                    } else if let Ok(template) = Template::load(file.clone()) {
-                        self.right_panel_content =
-                            RightPanelContent::template(Some(file.clone()), Some(template));
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
 }
 
 impl Default for Interface {
@@ -145,29 +77,25 @@ impl eframe::App for Interface {
                 if let Some(path) = dialog.path() {
                     if dialog.dialog_type() == DialogType::OpenFile {
                         // Handle file dialog for loading templates/instances
-                        if let Ok(instance) = ObjectInstance::load(path.to_path_buf()) {
+                        if let Ok(object) =
+                            ObjectInstance::load(path.file_stem().unwrap().to_str().unwrap())
+                        {
                             // Instance
-                            self.right_panel_content = RightPanelContent::instance(
-                                Some(path.to_path_buf()),
-                                Some(instance),
-                            );
+                            self.right_panel_content = RightPanelContent::instance(Some(object));
                             self.dialog = None;
-                        } else if let Ok(template) = Template::load(path.to_path_buf()) {
+                        } else if let Ok(template) =
+                            Template::load(path.file_stem().unwrap().to_str().unwrap())
+                        {
                             // Template
-                            self.right_panel_content = RightPanelContent::template(
-                                Some(path.to_path_buf()),
-                                Some(template),
-                            );
+                            self.right_panel_content = RightPanelContent::template(Some(template));
                             self.dialog = None;
                         }
                     } else if dialog.dialog_type() == DialogType::SaveFile {
                         // Handle file dialog for saving templates/instances
-
                         if let RightPanelContent::Template { template, .. } =
                             &mut self.right_panel_content
                         {
                             // set the save location and save
-                            template.path = Some(path.to_path_buf());
                             if template.save().is_err() {
                                 eprintln!("Failed to save template");
                             } else {
@@ -218,14 +146,15 @@ impl eframe::App for Interface {
                 ui.heading("Project Files");
                 ui.separator();
 
+                let mut to_load: Option<RightPanelContent> = None;
+
                 ScrollArea::vertical().show(ui, |ui| {
-                    if let Err(e) = self.show_directory(ui, &PROJECT_FOLDER, 0) {
-                        ui.label(
-                            RichText::new(format!("Error reading directory: {e}"))
-                                .color(egui::Color32::RED),
-                        );
-                    }
+                    self.explorer.ui(&mut to_load, ui);
                 });
+
+                if let Some(to_load) = to_load {
+                    self.right_panel_content = to_load;
+                }
             });
 
         // Main content area
@@ -234,19 +163,11 @@ impl eframe::App for Interface {
 
             match &mut self.right_panel_content {
                 // an instance of a template
-                RightPanelContent::Instance { instance, path: _ } => {
+                RightPanelContent::Object { object } => {
                     // load template from path
-
-                    let mut temp_path = instance.template_path.clone();
-
-                    // check if path is relative
-                    if !temp_path.is_absolute() {
-                        temp_path = PROJECT_FOLDER.join(temp_path);
-                    }
-
-                    let template = Template::load(temp_path).unwrap();
+                    let template = Template::load(&object.template_id).unwrap();
                     ScrollArea::vertical().show(ui, |ui| {
-                        instance.ui(ui, &template);
+                        object.ui(ui, &template);
                     });
                 }
 
@@ -266,6 +187,8 @@ impl eframe::App for Interface {
                     new_field_description,
                 ),
 
+                RightPanelContent::Note { note } => note.ui(ui),
+
                 RightPanelContent::None => {
                     ui.centered_and_justified(|ui| {
                         ui.label("No template loaded to edit.");
@@ -283,6 +206,7 @@ impl eframe::App for Interface {
         });
 
         self.editor.ui(ctx);
+        self.scene.ui(ctx);
     }
 }
 
@@ -295,15 +219,17 @@ pub enum RightPanelContent {
         new_field_required: bool,
         new_field_description: String,
     },
-    Instance {
-        instance: Box<ObjectInstance>,
-        path: Option<PathBuf>,
+    Object {
+        object: Box<ObjectInstance>,
+    },
+    Note {
+        note: Box<Note>,
     },
     None,
 }
 
 impl RightPanelContent {
-    fn template(path: Option<PathBuf>, template: Option<Template>) -> Self {
+    fn template(template: Option<Template>) -> Self {
         Self::Template {
             template: Box::new(template.unwrap_or_default()),
             new_field_name: String::new(),
@@ -313,18 +239,9 @@ impl RightPanelContent {
         }
     }
 
-    fn instance(path: Option<PathBuf>, instance: Option<ObjectInstance>) -> Self {
-        Self::Instance {
-            instance: Box::new(instance.unwrap_or_default()),
-            path,
-        }
-    }
-
-    fn is_saved(&self) -> bool {
-        match self {
-            RightPanelContent::Instance { instance, path: _ } => instance.saved,
-            RightPanelContent::Template { template, .. } => template.path.is_some(),
-            RightPanelContent::None => false,
+    fn instance(instance: Option<ObjectInstance>) -> Self {
+        Self::Object {
+            object: Box::new(instance.unwrap_or_default()),
         }
     }
 }
diff --git a/src/main_editor.rs b/src/main_editor.rs
index bd94c85..d598572 100644
--- a/src/main_editor.rs
+++ b/src/main_editor.rs
@@ -25,7 +25,6 @@ impl MainEditor {
                 .resizable(true)
                 .default_width(1000.0)
                 .default_height(800.0)
-                .max_height(800.0)
                 .open(&mut self.show_editor)
                 .show(ctx, |ui| {
                     ui.horizontal(|ui| {
diff --git a/src/note.rs b/src/note.rs
new file mode 100644
index 0000000..cca2495
--- /dev/null
+++ b/src/note.rs
@@ -0,0 +1,109 @@
+use std::fs;
+
+use egui::RichText;
+use serde::{Deserialize, Serialize};
+
+use crate::PROJECT_FOLDER;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct Note {
+    pub name: String,
+    pub content: String,
+
+    #[serde(skip)]
+    pub id: String,
+
+    #[serde(skip)]
+    pub saved: bool,
+}
+
+impl Default for Note {
+    fn default() -> Self {
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            name: "New Note".to_string(),
+            content: "".to_string(),
+            saved: false,
+        }
+    }
+}
+
+impl Note {
+    pub fn new(name: String, content: String) -> Self {
+        Self {
+            id: uuid::Uuid::new_v4().to_string(),
+            name,
+            content,
+            saved: false,
+        }
+    }
+
+    pub fn save(&mut self) -> std::io::Result<()> {
+        let id = &self.id;
+        let path = PROJECT_FOLDER.join("notes").join(format!("{id}.json"));
+        fs::write(path, serde_json::to_string(&self)?)?;
+        self.saved = true;
+        Ok(())
+    }
+
+    pub fn load(id: &str) -> std::io::Result<Self> {
+        let path = PROJECT_FOLDER.join("notes").join(format!("{id}.json"));
+        let content = fs::read_to_string(path)?;
+        let mut note: Note = serde_json::from_str(&content)?;
+        note.id = id.to_string();
+        note.saved = true;
+        Ok(note)
+    }
+
+    pub fn ui(&mut self, ui: &mut egui::Ui) {
+        if ui.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl) {
+            if let Err(e) = self.save() {
+                eprintln!("Failed to save: {e}");
+            }
+        }
+
+        ui.group(|ui| {
+            ui.horizontal(|ui| {
+                if self.saved {
+                    ui.label(RichText::new("✓ Saved").color(egui::Color32::GREEN));
+                } else {
+                    ui.label(RichText::new("* Unsaved").color(egui::Color32::YELLOW));
+                }
+                ui.label(format!("id: {}", self.id));
+            });
+        });
+
+        if ui.button("Save").clicked() {
+            if let Err(e) = self.save() {
+                eprintln!("Failed to save: {e}");
+            }
+        }
+
+        egui::Grid::new("note_grid")
+            .striped(true)
+            .num_columns(2)
+            .show(ui, |ui| {
+                ui.label("Name:");
+                if ui
+                    .add(egui::TextEdit::singleline(&mut self.name).frame(false))
+                    .changed()
+                {
+                    self.saved = false;
+                }
+                ui.end_row();
+
+                ui.label("Content:");
+                if ui
+                    .add(
+                        egui::TextEdit::multiline(&mut self.content)
+                            .desired_rows(1)
+                            .frame(false),
+                    )
+                    .changed()
+                {
+                    self.saved = false;
+                }
+                ui.end_row();
+            });
+    }
+}
diff --git a/src/object.rs b/src/object.rs
index b291f31..72fb3c2 100644
--- a/src/object.rs
+++ b/src/object.rs
@@ -1,9 +1,7 @@
 use core::f32;
-use std::path::PathBuf;
 
 use chrono::NaiveDate;
 use egui::{CollapsingHeader, RichText, TextEdit, Ui, vec2};
-use egui_file::DialogType;
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -14,32 +12,41 @@ use crate::{
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ObjectInstance {
     // template info
-    pub template_name: String,
-    pub template_path: PathBuf,
+    pub id: String,
+    pub template_id: String,
 
     // instance info
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
+    pub name: String,
     pub fields: std::collections::HashMap<String, FieldValue>,
 
-    // state (ignore)
     #[serde(skip)]
     pub saved: bool,
-    #[serde(skip)]
-    pub path: Option<PathBuf>,
+
     #[serde(skip)]
     pub dialog: Option<egui_file::FileDialog>,
 }
 
+impl Clone for ObjectInstance {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id.clone(),
+            template_id: self.template_id.clone(),
+            name: self.name.clone(),
+            fields: self.fields.clone(),
+            saved: self.saved,
+            dialog: None,
+        }
+    }
+}
+
 impl Default for ObjectInstance {
     fn default() -> Self {
         Self {
-            template_name: "New Template Instance".to_string(),
-            name: None,
-            template_path: PathBuf::new(),
+            id: uuid::Uuid::new_v4().to_string(),
+            template_id: "new_template_instance".to_string(),
+            name: "new_object".to_string(),
             fields: std::collections::HashMap::new(),
             saved: false,
-            path: None,
             dialog: None,
         }
     }
@@ -54,124 +61,84 @@ impl ObjectInstance {
         }
 
         Self {
-            template_name: template.name.clone(),
-            name: None,
+            id: uuid::Uuid::new_v4().to_string(),
+            template_id: template.id.clone(),
+            name: "new_object".to_string(),
             fields,
-            template_path: template
-                .path
-                .clone()
-                .expect("expected the template to have a path!"),
             saved: false,
-            path: None,
             dialog: None,
         }
     }
 
-    pub fn save(&self, path: PathBuf) -> Result<(), Box<dyn std::error::Error>> {
+    pub fn save(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+        let path = PROJECT_FOLDER
+            .join("objects")
+            .join(format!("{}.json", &self.id));
+
         let content = serde_json::to_string_pretty(self)?;
         std::fs::write(&path, content)?;
+        self.saved = true;
         Ok(())
     }
 
-    pub fn load(path: PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
+    pub fn load(id: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let path = PROJECT_FOLDER.join("objects").join(format!("{id}.json"));
+
         let content = std::fs::read_to_string(&path)?;
-        let mut instance: Self = serde_json::from_str(&content)?;
-
-        // Set the name from the filename (without extension)
-        if let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
-            instance.name = Some(stem.to_string());
-        }
-
-        instance.path = Some(path);
+        let mut instance: ObjectInstance = serde_json::from_str(&content)?;
         instance.saved = true;
         Ok(instance)
     }
 
-    fn handle_dialogs(&mut self, ui: &mut Ui) {
-        let path = if let Some(dialog) = &mut self.dialog {
-            match dialog.dialog_type() {
-                DialogType::SaveFile => {
-                    if dialog.show(ui.ctx()).selected() {
-                        dialog.path().map(|path| (path.to_path_buf(), true))
-                    } else {
-                        None
-                    }
-                }
-                // Handle other dialog types...
-                _ => None,
-            }
-        } else {
-            None
-        };
-
-        if let Some((path, should_save)) = path {
-            if should_save {
-                if let Err(err) = self.save(path.clone()) {
-                    println!("Save error: {err}");
-                } else {
-                    // Update the name from the filename when saving
-                    if let Some(stem) = path.file_stem().and_then(|s| s.to_str()) {
-                        self.name = Some(stem.to_string());
-                    }
-                    self.path = Some(path);
-                    self.saved = true;
-                    self.dialog = None;
-                }
+    pub fn ui(&mut self, ui: &mut Ui, template: &Template) {
+        if ui.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl) {
+            if let Err(e) = self.save() {
+                eprintln!("Failed to save: {e}");
             }
         }
-    }
 
-    pub fn ui(&mut self, ui: &mut Ui, template: &Template) {
         ui.vertical(|ui| {
-            self.handle_dialogs(ui);
-
             // Show save status and button
-            ui.horizontal(|ui| {
-                if self.saved {
-                    ui.label(RichText::new("✓ Saved").color(egui::Color32::GREEN));
-                } else {
-                    ui.label(RichText::new("* Unsaved").color(egui::Color32::YELLOW));
-                }
 
-                // Show current save path or "Not saved yet"
-                let path_display = self
-                    .path
-                    .as_ref()
-                    .and_then(|p| p.to_str())
-                    .unwrap_or("Not saved yet");
-                ui.label(path_display);
-
-                // File picker button
-                if ui.button("Save As").clicked() && self.dialog.is_none() {
-                    self.dialog = Some(egui_file::FileDialog::save_file(Some(
-                        PROJECT_FOLDER.clone(),
-                    )));
-                    self.dialog.as_mut().unwrap().open();
-                }
-
-                if ui.button("Save").clicked() {
-                    if let Some(path) = &self.path {
-                        if let Err(e) = self.save(path.clone()) {
-                            eprintln!("Failed to save: {e}");
-                        } else {
-                            self.saved = true;
-                        }
+            ui.group(|ui| {
+                ui.horizontal(|ui| {
+                    if self.saved {
+                        ui.label(RichText::new("✓ Saved").color(egui::Color32::GREEN));
                     } else {
-                        // If no path is set, request one
-                        if self.dialog.is_none() {
-                            self.dialog = Some(egui_file::FileDialog::save_file(Some(
-                                PROJECT_FOLDER.clone(),
-                            )));
-                            self.dialog.as_mut().unwrap().open();
-                        }
+                        ui.label(RichText::new("* Unsaved").color(egui::Color32::YELLOW));
                     }
-                }
+                    ui.label(format!("id: {}", self.id));
+                });
             });
 
+            if ui.button("Save").clicked() {
+                if let Err(e) = self.save() {
+                    eprintln!("Failed to save: {e}");
+                }
+            }
+
             ui.separator();
 
             egui::ScrollArea::vertical().show(ui, |ui| {
                 // Render each field
+
+                // allow name to be edited
+                CollapsingHeader::new("Name")
+                    .default_open(true)
+                    .show(ui, |ui| {
+                        ui.heading(RichText::new("Name").size(14.0).strong());
+
+                        ui.separator();
+
+                        let _ = TextEdit::singleline(&mut self.name)
+                            .desired_width(f32::INFINITY)
+                            .frame(false)
+                            .show(ui)
+                            .response;
+
+                        ui.separator();
+                    });
+
                 for field_def in &template.fields {
                     if let Some(field_value) = self.fields.get_mut(&field_def.name) {
                         CollapsingHeader::new(&field_def.name)
diff --git a/src/scene.rs b/src/scene.rs
new file mode 100644
index 0000000..9a89469
--- /dev/null
+++ b/src/scene.rs
@@ -0,0 +1,27 @@
+pub struct EditorScene {
+    rect: egui::Rect,
+}
+
+impl EditorScene {
+    pub fn new() -> Self {
+        Self {
+            rect: egui::Rect::ZERO,
+        }
+    }
+
+    pub fn ui(&mut self, ctx: &egui::Context) {
+        egui::CentralPanel::default()
+            .frame(egui::Frame::NONE)
+            .show(ctx, |ui| {
+                egui::Scene::default()
+                    .zoom_range(0.1..=10.0)
+                    .show(ui, &mut self.rect, |ui| {
+                        egui::Resize::default().auto_sized().show(ui, |ui| {
+                            ui.group(|ui| {
+                                ui.label("Scene");
+                            });
+                        });
+                    });
+            });
+    }
+}
diff --git a/src/template.rs b/src/template.rs
index ff95d2e..de5e17e 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -1,8 +1,9 @@
+use core::fmt;
+
 use egui::{RichText, ScrollArea};
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
 
-use crate::{PROJECT_FOLDER, RightPanelContent, object::ObjectInstance};
+use crate::{PROJECT_FOLDER, RightPanelContent, error::Error, object::ObjectInstance};
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum FieldType {
@@ -21,57 +22,77 @@ pub struct FieldDefinition {
     pub description: Option<String>,
 }
 
-#[derive(Debug, Clone, Default)]
-pub enum EditorMode {
-    #[default]
-    View,
-    EditTemplate,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Serialize, Deserialize)]
 pub struct Template {
     pub name: String,
+    pub id: String,
+
     pub description: Option<String>,
     pub fields: Vec<FieldDefinition>,
 
-    #[serde(skip)]
-    pub path: Option<PathBuf>,
-
     #[serde(skip)]
     pub saved: bool,
 
     #[serde(skip)]
-    pub editor_mode: EditorMode,
+    pub error: Option<Error>,
+}
 
-    #[serde(skip)]
-    pub dialog: Option<egui_file::FileDialog>,
+impl fmt::Debug for Template {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Template")
+            .field("name", &self.name)
+            .field("id", &self.id)
+            .field("description", &self.description)
+            .field("fields", &self.fields)
+            .field("saved", &self.saved)
+            .finish()
+    }
+}
+
+impl Clone for Template {
+    fn clone(&self) -> Self {
+        Self {
+            name: self.name.clone(),
+            id: self.id.clone(),
+            description: self.description.clone(),
+            fields: self.fields.clone(),
+            saved: self.saved,
+            error: None,
+        }
+    }
 }
 
 impl Default for Template {
     fn default() -> Self {
         Self {
             name: "New Template".to_string(),
+            id: uuid::Uuid::new_v4().to_string(),
             description: Some(String::from("Placeholder description")),
             fields: Vec::new(),
             saved: false,
-            path: None,
-            editor_mode: EditorMode::default(),
-            dialog: None,
+            error: None,
         }
     }
 }
 
 impl Template {
-    pub fn load(path: PathBuf) -> Result<Self, Box<dyn std::error::Error>> {
+    pub fn load(id: &str) -> Result<Self, Box<dyn std::error::Error>> {
+        let path = PROJECT_FOLDER.join("templates").join(format!("{id}.json"));
+
         let content = std::fs::read_to_string(&path)?;
         let mut template: Self = serde_json::from_str(&content)?;
-        template.path = Some(path);
+        template.saved = true;
         Ok(template)
     }
 
     pub fn save(&mut self) -> Result<(), Box<dyn std::error::Error>> {
+        let path = PROJECT_FOLDER
+            .join("templates")
+            .join(format!("{}.json", &self.id));
+
         let content = serde_json::to_string_pretty(self)?;
-        std::fs::write(self.path.as_ref().ok_or("no path")?, content)?;
+        std::fs::write(path, content)?;
+        self.saved = true;
         Ok(())
     }
 
@@ -84,110 +105,64 @@ impl Template {
         new_field_required: &mut bool,
         new_field_description: &mut String,
     ) {
-        match self.editor_mode {
-            EditorMode::View => {
-                ScrollArea::vertical().show(ui, |ui| {
-                    if ui.button("Edit Template").clicked() {
-                        self.editor_mode = EditorMode::EditTemplate;
-                    }
+        if let Some(error) = &mut self.error {
+            error.show(ui);
+        }
 
-                    if ui.button("New Instance").clicked() {
-                        *new_instance = RightPanelContent::Instance {
-                            instance: Box::new(ObjectInstance::new(self)),
-                            path: None,
-                        };
-                    }
-                });
-
-                self.viewer_ui(ui, new_instance);
-
-                if self.saved {
-                    ui.label(RichText::new("✓ Saved").color(egui::Color32::GREEN));
-                } else {
-                    ui.label(RichText::new("* Unsaved").color(egui::Color32::YELLOW));
-                }
-
-                // Show current save path or "Not saved yet"
-                let path_display = self
-                    .path
-                    .as_ref()
-                    .and_then(|p| p.to_str())
-                    .unwrap_or("Not saved yet");
-                ui.label(path_display);
-            }
-            EditorMode::EditTemplate => {
-                ScrollArea::vertical().show(ui, |ui| {
-                    ui.vertical_centered(|ui| {
-                        self.editor_ui(
-                            ui,
-                            new_field_name,
-                            new_field_type,
-                            new_field_required,
-                            new_field_description,
-                        );
-
-                        // Save/Cancel buttons
-                        ui.horizontal(|ui| {
-                            if ui.button("Save Template").clicked() {
-                                if let Some(_path) = &self.path {
-                                    if let Err(e) = self.save() {
-                                        eprintln!("Failed to save: {e}");
-                                    }
-                                } else {
-                                    // Open save dialog
-                                    let mut dialog = egui_file::FileDialog::save_file(Some(
-                                        PROJECT_FOLDER.clone(),
-                                    ));
-                                    dialog.open();
-                                    self.dialog = Some(dialog);
-                                }
-                            }
-
-                            if ui.button("Cancel").clicked() {
-                                self.editor_mode = EditorMode::View;
-                            }
-                        });
-                    });
-                });
+        if ui.input(|i| i.key_pressed(egui::Key::S) && i.modifiers.ctrl) {
+            if let Err(e) = self.save() {
+                eprintln!("Failed to save: {e}");
             }
         }
-    }
 
-    pub fn viewer_ui(&self, ui: &mut egui::Ui, new_instance: &mut RightPanelContent) {
-        // Show template view
-        ui.vertical_centered(|ui| {
-            ui.heading(&self.name);
+        ScrollArea::vertical().show(ui, |ui| {
+            ui.vertical(|ui| {
+                ui.group(|ui| {
+                    ui.horizontal(|ui| {
+                        if self.saved {
+                            ui.label(RichText::new("✓ Saved").color(egui::Color32::GREEN));
+                        } else {
+                            ui.label(RichText::new("* Unsaved").color(egui::Color32::YELLOW));
+                        }
+                        ui.label(format!("id: {}", self.id));
+                    });
+                });
 
-            if let Some(description) = &self.description {
-                ui.separator();
-                ui.label(description);
-            }
-
-            ui.separator();
-            ui.heading("Fields");
-
-            for field in &self.fields {
-                ui.separator();
+                // Save/Cancel buttons
                 ui.horizontal(|ui| {
-                    ui.strong(&field.name);
-                    ui.label(format!("({:?})", field.field_type));
-                    if field.required {
-                        ui.label("*");
+                    if ui.button("Save Template").clicked() {
+                        if let Err(e) = self.save() {
+                            eprintln!("Failed to save: {e}");
+                        }
+                    }
+
+                    if ui.button("Cancel").clicked() {
+                        // load default state
+                        *self = Self::load(&self.id).unwrap();
+                    }
+
+                    if ui.button("Create New Instance").clicked() {
+                        if self.saved {
+                            *new_instance = RightPanelContent::Object {
+                                object: Box::new(ObjectInstance::new(self)),
+                            };
+                        } else {
+                            self.error = Some(Error::new(
+                                "You must save the template before creating a new instance!"
+                                    .to_string(),
+                            ));
+                        }
                     }
                 });
 
-                if let Some(desc) = &field.description {
-                    ui.label(desc);
-                }
-            }
-
-            ui.separator();
-            if ui.button("Create New Instance").clicked() {
-                *new_instance = RightPanelContent::Instance {
-                    instance: Box::new(ObjectInstance::new(self)),
-                    path: None,
-                };
-            }
+                self.editor_ui(
+                    ui,
+                    new_field_name,
+                    new_field_type,
+                    new_field_required,
+                    new_field_description,
+                );
+            });
         });
     }
 
@@ -199,19 +174,57 @@ impl Template {
         new_field_required: &mut bool,
         new_field_description: &mut String,
     ) {
-        // Template name and description
-        ui.horizontal(|ui| {
-            ui.label("Template Name:");
-            ui.text_edit_singleline(&mut self.name);
-        });
+        egui::Grid::new("template_grid")
+            .num_columns(2)
+            .striped(true)
+            .show(ui, |ui| {
+                ui.label("Template Name:");
+                if ui
+                    .add(egui::TextEdit::singleline(&mut self.name).frame(false))
+                    .changed()
+                {
+                    self.saved = false;
+                }
+                ui.end_row();
 
-        ui.horizontal(|ui| {
-            ui.label("Description:");
-            ui.text_edit_multiline(self.description.get_or_insert_with(String::new));
-        });
+                ui.label("Description:");
+                if ui
+                    .add(
+                        egui::TextEdit::multiline(self.description.get_or_insert_with(String::new))
+                            .desired_rows(1)
+                            .frame(false),
+                    )
+                    .changed()
+                {
+                    self.saved = false;
+                }
+                ui.end_row();
+            });
 
         ui.separator();
-        ui.heading("Fields");
+
+        egui::CollapsingHeader::new("Name").show(ui, |ui: &mut egui::Ui| {
+            egui::Grid::new("field_grid")
+                .num_columns(2)
+                .striped(true)
+                .show(ui, |ui| {
+                    ui.label("Name:");
+                    ui.label("Name");
+                    ui.end_row();
+
+                    ui.label("Type:");
+                    ui.label("SingleLine");
+                    ui.end_row();
+
+                    ui.label("Required");
+                    ui.label("✓");
+                    ui.end_row();
+
+                    ui.label("Description:");
+                    ui.label("Object name");
+                    ui.end_row();
+                });
+        });
 
         // List of fields
         let mut to_remove = None;
@@ -220,52 +233,73 @@ impl Template {
 
             egui::collapsing_header::CollapsingState::load_with_default_open(ui.ctx(), id, true)
                 .show_header(ui, |ui| {
-                    ui.label(field.name.clone());
                     if ui.button("❌").clicked() {
                         to_remove = Some(i);
                     }
+                    ui.label(field.name.clone());
                 })
                 .body(|ui| {
-                    ui.horizontal(|ui| {
-                        ui.label("Name:");
-                        ui.text_edit_singleline(&mut field.name);
-                    });
+                    ui.separator();
+                    egui::Grid::new("field_grid")
+                        .num_columns(2)
+                        .striped(true)
+                        .show(ui, |ui| {
+                            ui.label("Name:");
+                            if ui.text_edit_singleline(&mut field.name).changed() {
+                                self.saved = false;
+                            }
+                            ui.end_row();
 
-                    ui.horizontal(|ui| {
-                        ui.label("Type:");
-                        egui::ComboBox::from_id_salt(format!("field_type_{i}"))
-                            .selected_text(format!("{:?}", field.field_type))
-                            .show_ui(ui, |ui| {
-                                for variant in [
-                                    FieldType::SingleLine,
-                                    FieldType::MultiLine,
-                                    FieldType::Number,
-                                    FieldType::Date,
-                                    FieldType::Image,
-                                ] {
-                                    ui.selectable_value(
-                                        &mut field.field_type,
-                                        variant.clone(),
-                                        format!("{variant:?}"),
-                                    );
-                                }
-                            });
-                    });
+                            ui.label("Type:");
+                            egui::ComboBox::from_id_salt(format!("field_type_{i}"))
+                                .selected_text(format!("{:?}", field.field_type))
+                                .show_ui(ui, |ui| {
+                                    for variant in [
+                                        FieldType::SingleLine,
+                                        FieldType::MultiLine,
+                                        FieldType::Number,
+                                        FieldType::Date,
+                                        FieldType::Image,
+                                    ] {
+                                        if ui
+                                            .selectable_value(
+                                                &mut field.field_type,
+                                                variant.clone(),
+                                                format!("{variant:?}"),
+                                            )
+                                            .changed()
+                                        {
+                                            self.saved = false;
+                                        }
+                                    }
+                                });
+                            ui.end_row();
 
-                    ui.horizontal(|ui| {
-                        ui.checkbox(&mut field.required, "Required");
-                    });
+                            ui.label("Required:");
+                            if ui.checkbox(&mut field.required, "").clicked() {
+                                self.saved = false;
+                            }
+                            ui.end_row();
 
-                    ui.horizontal(|ui| {
-                        ui.label("Description:");
-                        ui.text_edit_singleline(field.description.get_or_insert_with(String::new));
-                    });
+                            ui.label("Description:");
+                            if ui
+                                .text_edit_singleline(
+                                    field.description.get_or_insert_with(String::new),
+                                )
+                                .changed()
+                            {
+                                self.saved = false;
+                            }
+                            ui.end_row();
+                            ui.separator();
+                        });
                 });
         }
 
         // Remove field if needed
         if let Some(index) = to_remove {
             self.fields.remove(index);
+            self.saved = false;
         }
 
         // Add new field
@@ -273,13 +307,14 @@ impl Template {
         ui.heading("Add New Field");
 
         ui.horizontal(|ui| {
-            ui.vertical(|ui| {
-                ui.horizontal(|ui| {
+            egui::Grid::new("field_grid")
+                .num_columns(2)
+                .striped(true)
+                .show(ui, |ui| {
                     ui.label("Name:");
                     ui.text_edit_singleline(new_field_name);
-                });
+                    ui.end_row();
 
-                ui.horizontal(|ui| {
                     ui.label("Type:");
                     egui::ComboBox::from_id_salt("new_field_type")
                         .selected_text(format!("{new_field_type:?}"))
@@ -298,35 +333,36 @@ impl Template {
                                 );
                             }
                         });
-                });
+                    ui.end_row();
 
-                ui.horizontal(|ui| {
-                    ui.checkbox(new_field_required, "Required");
-                });
+                    ui.label("Required:");
+                    ui.checkbox(new_field_required, "");
+                    ui.end_row();
 
-                ui.horizontal(|ui| {
                     ui.label("Description:");
                     ui.text_edit_singleline(new_field_description);
+                    ui.end_row();
+
+                    if ui.button("Add Field").clicked() && !new_field_name.is_empty() {
+                        self.fields.push(FieldDefinition {
+                            name: new_field_name.clone(),
+                            field_type: new_field_type.clone(),
+                            required: *new_field_required,
+                            description: if new_field_description.is_empty() {
+                                None
+                            } else {
+                                Some(new_field_description.clone())
+                            },
+                        });
+
+                        self.saved = false;
+
+                        // Reset new field form
+                        new_field_name.clear();
+                        *new_field_required = false;
+                        new_field_description.clear();
+                    }
                 });
-
-                if ui.button("Add Field").clicked() && !new_field_name.is_empty() {
-                    self.fields.push(FieldDefinition {
-                        name: new_field_name.clone(),
-                        field_type: new_field_type.clone(),
-                        required: *new_field_required,
-                        description: if new_field_description.is_empty() {
-                            None
-                        } else {
-                            Some(new_field_description.clone())
-                        },
-                    });
-
-                    // Reset new field form
-                    new_field_name.clear();
-                    *new_field_required = false;
-                    new_field_description.clear();
-                }
-            });
         });
     }
 }