diff --git a/ChatAAC/Converters/StringToBitmapConverter.cs b/ChatAAC/Converters/StringToBitmapConverter.cs
index 2e08ac7..17cfeb2 100644
--- a/ChatAAC/Converters/StringToBitmapConverter.cs
+++ b/ChatAAC/Converters/StringToBitmapConverter.cs
@@ -1,4 +1,3 @@
-using Avalonia;
 using Avalonia.Data.Converters;
 using Avalonia.Media.Imaging;
 using System;
diff --git a/ChatAAC/Models/AiResponse.cs b/ChatAAC/Models/AiResponse.cs
index 10a4497..36be443 100644
--- a/ChatAAC/Models/AiResponse.cs
+++ b/ChatAAC/Models/AiResponse.cs
@@ -2,14 +2,8 @@
 
 namespace ChatAAC.Models;
 
-public class AiResponse
+public class AiResponse(string responseText)
 {
-    public string ResponseText { get; set; }
-    public DateTime Timestamp { get; set; }
-
-    public AiResponse(string responseText)
-    {
-        ResponseText = responseText;
-        Timestamp = DateTime.Now;
-    }
+    public string ResponseText { get; set; } = responseText;
+    public DateTime Timestamp { get; set; } = DateTime.Now;
 }
\ No newline at end of file
diff --git a/ChatAAC/Models/Obf/Button.cs b/ChatAAC/Models/Obf/Button.cs
index 72482f5..1f1a401 100644
--- a/ChatAAC/Models/Obf/Button.cs
+++ b/ChatAAC/Models/Obf/Button.cs
@@ -8,7 +8,7 @@ public class Button
 {
     [JsonPropertyName("id")]
     [JsonConverter(typeof(IntFromStringConverter))]
-    public int Id { get; set; }
+    public int? Id { get; set; }
 
     [JsonPropertyName("label")] public string Label { get; set; } = string.Empty;
 
@@ -20,36 +20,9 @@ public class Button
 
     [JsonPropertyName("vocalization")] public string Vocalization { get; set; } = string.Empty;
 
-    [JsonPropertyName("load_board")] public LoadBoard? LoadBoard { get; set; } 
+    [JsonPropertyName("load_board")] public LoadBoard? LoadBoard { get; set; }
 
     [JsonPropertyName("action")] public string Action { get; set; } = string.Empty;
 
     [JsonIgnore] public Image? Image { get; set; }
-
-    private const int ImageWidth = 260;
-    private const int ImageHeight = 290;
-
-    [JsonIgnore]
-    public int Width
-    {
-        get
-        {
-            var width = Image?.Width + 10;
-            if (width <= 10) width = ImageWidth;
-            if (width > ImageWidth) width = ImageWidth;
-            return width ?? ImageWidth;
-        }
-    }
-
-    [JsonIgnore]
-    public int Height
-    {
-        get
-        {
-            var height = Image?.Height + 30;
-            if (height <= 30) height = ImageHeight;
-            if (height > ImageHeight) height = ImageHeight;
-            return height ?? ImageHeight;
-        }
-    }
 }
\ No newline at end of file
diff --git a/ChatAAC/Models/Obf/ObfFile.cs b/ChatAAC/Models/Obf/ObfFile.cs
index 4bdf400..08a0b47 100644
--- a/ChatAAC/Models/Obf/ObfFile.cs
+++ b/ChatAAC/Models/Obf/ObfFile.cs
@@ -18,7 +18,7 @@ public class ObfFile
 
     [JsonPropertyName("description_html")] public string DescriptionHtml { get; set; } = string.Empty;
 
-    [JsonPropertyName("grid")] public Grid Grid { get; set; } = new();
+    [JsonPropertyName("grid")] public Grid? Grid { get; set; } 
     [JsonPropertyName("buttons")] public List<Button> Buttons { get; set; } = new();
     [JsonPropertyName("images")] public List<Image> Images { get; set; } = new();
 
diff --git a/ChatAAC/Models/Obf/ObfLoader.cs b/ChatAAC/Models/Obf/ObfLoader.cs
index 8ec7675..e8644bb 100644
--- a/ChatAAC/Models/Obf/ObfLoader.cs
+++ b/ChatAAC/Models/Obf/ObfLoader.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
-using System.IO.Compression;
 using System.Net.Http;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -10,282 +10,382 @@
 
 namespace ChatAAC.Models.Obf
 {
-    // Klasa do parsowania plików OBF
     public static partial class ObfLoader
     {
         private static readonly HttpClient HttpClient = new();
 
-        public static string ObfCacheDirectory { get; set; } 
-        public static string PictogramsCacheDirectory { get; set; }
-
-        static ObfLoader()
+        private static readonly JsonSerializerOptions JsonOptions = new()
         {
-            ObfCacheDirectory = Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-                "ChatAAC",
-                "Cache",
-                "Obf");
-
-            // Ścieżka do katalogu Cache/Pictograms
-            PictogramsCacheDirectory = Path.Combine(
-                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-                "ChatAAC",
-                "Cache",
-                "Pictograms");
-        }
+            PropertyNameCaseInsensitive = true,
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            Converters = { new IntFromStringConverter() }
+        };
+
+        public static string ObfCacheDirectory { get; } = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "ChatAAC", "Cache", "Obf");
+
+        public static string PictogramsCacheDirectory { get; } = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "ChatAAC", "Cache", "Pictograms");
+
         /// <summary>
-        /// Ładuje plik OBF, aktualizuje ścieżki obrazów i kopiuje plik do katalogu Cache/Obf, jeśli jeszcze tam nie istnieje.
+        /// Loads an OBF file, processes images, and returns the deserialized object.
         /// </summary>
-        /// <param name="filePath">Ścieżka do pliku OBF.</param>
-        /// <returns>Zaktualizowany obiekt ObfFile lub null w przypadku błędu.</returns>
         public static async Task<ObfFile?> LoadObfAsync(string filePath)
         {
-            var options = new JsonSerializerOptions
-            {
-                PropertyNameCaseInsensitive = true,
-                DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
-                Converters =
-                {
-                    new IntFromStringConverter()
-                }
-            };
-            
             if (string.IsNullOrWhiteSpace(filePath))
             {
-                Console.WriteLine("Ścieżka do pliku OBF jest pusta.");
+                LogError("The OBF file path is empty.");
                 return null;
             }
 
             try
             {
-                // Ścieżka do katalogu Cache/Obf
-             
+                // Ensure cache directories exist
+                EnsureDirectoryExists(ObfCacheDirectory);
+                EnsureDirectoryExists(PictogramsCacheDirectory);
 
-                // Upewnij się, że katalog Cache/Obf istnieje
-                Directory.CreateDirectory(ObfCacheDirectory);
+                // Copy OBF file to cache directory
+                var obfFileName = Path.GetFileName(filePath);
+                var cachedObfPath = Path.Combine(ObfCacheDirectory, obfFileName);
+                await CopyFileIfNeededAsync(filePath, cachedObfPath);
 
-                // Nazwa pliku
-                var fileName = Path.GetFileName(filePath);
-                var destinationPath = Path.Combine(ObfCacheDirectory, fileName);
-
-                // Kopiowanie pliku do Cache/Obf, jeśli nie istnieje
-                if (!File.Exists(destinationPath))
-                {
-                    File.Copy(filePath, destinationPath);
-                    Console.WriteLine($"Skopiowano plik OBF do {destinationPath}");
-                }
-                else
+                // Deserialize OBF file
+                var obfFile = await DeserializeObfFileAsync(cachedObfPath);
+                if (obfFile == null)
                 {
-                    Console.WriteLine($"Plik OBF już istnieje w {destinationPath}. Kopiowanie pominięte.");
+                    LogError("Failed to deserialize the OBF file.");
+                    return null;
                 }
 
-                // Wczytaj zawartość pliku OBF
-                var jsonString = await File.ReadAllTextAsync(destinationPath);
-                var obfFile = JsonSerializer.Deserialize<ObfFile>(jsonString, options);
+                
+                // Pobierz katalog bazowy oryginalnego pliku OBF
+                var obfBaseDirectory = Path.GetDirectoryName(filePath) ?? string.Empty;
+                
+                // Przetwarzaj obrazy w pliku OBF, przekazując katalog bazowy
+                await ProcessImagesAsync(obfFile, obfBaseDirectory);
 
-                if (obfFile != null) return await UpdateImagesInButtonsAsync(obfFile, PictogramsCacheDirectory);
-                Console.WriteLine("Deserializacja pliku OBF zakończyła się niepowodzeniem.");
-                return null;
 
-                // Aktualizuj ścieżki obrazów w przyciskach
+                foreach (var button in obfFile.Buttons)
+                {
+                    // Find the corresponding image
+                    button.Image = obfFile.Images.Find(image => image.Id == button.ImageId);
+                    if (button.Image is null)
+                    {
+                        Console.WriteLine($"Brak obrazu dla przycisku o ID: {button.Id}");
+                    }
+                }
+
+                return obfFile;
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas ładowania pliku OBF: {ex.Message}");
+                LogError($"Error loading OBF file: {ex.Message}");
                 return null;
             }
         }
 
         /// <summary>
-        /// Aktualizuje ścieżki obrazów w przyciskach, zapisuje obrazy do Cache/Pictograms i aktualizuje ścieżki lokalne.
+        /// Deserializes the OBF file to an ObfFile object.
         /// </summary>
-        /// <param name="obfFile">Obiekt ObfFile do zaktualizowania.</param>
-        /// <param name="cacheDirectory">Katalog Cache/Pictograms.</param>
-        /// <returns>Zaktualizowany obiekt ObfFile lub null w przypadku błędu.</returns>
-        private static async Task<ObfFile?> UpdateImagesInButtonsAsync(ObfFile? obfFile, string cacheDirectory)
+        private static async Task<ObfFile?> DeserializeObfFileAsync(string obfFilePath)
         {
-            if (obfFile == null)
-            {
-                Console.WriteLine("Obiekt ObfFile jest null.");
-                return null;
-            }
-
             try
             {
-                // Upewnij się, że katalog Cache/Pictograms istnieje
-                Directory.CreateDirectory(cacheDirectory);
-
-                foreach (var button in obfFile.Buttons)
-                {
-                    // Znajdź odpowiadający obraz
-                    button.Image = obfFile.Images.Find(image => image.Id == button.ImageId);
-                    if (button.Image != null)
-                    {
-                        // Zapisz obraz do pliku i zaktualizuj ścieżkę
-                        button.Image.ImagePath = await SaveImageToFileAsync(button.Image, cacheDirectory);
-                    }
-                    else
-                    {
-                        Console.WriteLine($"Brak obrazu dla przycisku o ID: {button.Id}");
-                    }
-                }
-
-                return obfFile;
+                var jsonString = await File.ReadAllTextAsync(obfFilePath);
+                return JsonSerializer.Deserialize<ObfFile>(jsonString, JsonOptions);
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas aktualizacji obrazów w przyciskach: {ex.Message}");
+                LogError($"Error deserializing OBF file: {ex.Message}");
                 return null;
             }
         }
 
         /// <summary>
-        /// Zapisuje obraz do pliku w katalogu Cache/Pictograms, jeśli jeszcze tam nie istnieje.
+        /// Processes images in the OBF file, saving them to the cache directory.
         /// </summary>
-        /// <param name="image">Obiekt Image do zapisania.</param>
-        /// <param name="cacheDirectory">Katalog Cache/Pictograms.</param>
-        /// <returns>Ścieżka do zapisanego obrazu.</returns>
-        private static async Task<string> SaveImageToFileAsync(Image image, string cacheDirectory)
+        private static async Task ProcessImagesAsync(ObfFile obfFile, string obfBaseDirectory)
         {
-            try
+            foreach (var image in obfFile.Images)
             {
-                // Określ rozszerzenie pliku
-                var extension = GetFileExtension(image);
-                var fileName = $"{image.Id}{extension}";
-                var filePath = Path.Combine(cacheDirectory, fileName);
+                // Generate a unique filename for the image
+                var imageFileName = GenerateImageFileName(image);
 
-                // Sprawdź, czy plik już istnieje
-                if (File.Exists(filePath))
-                {
-                    Console.WriteLine($"Plik obrazu już istnieje: {filePath}. Pomijanie zapisu.");
-                    return filePath;
-                }
+                // Set the ImagePath to the cached image path
+                image.ImagePath = Path.Combine(PictogramsCacheDirectory, imageFileName);
 
-                // Zapisz obraz na podstawie danych lub URL
-                if (!string.IsNullOrEmpty(image.Data) && image.Data.StartsWith("data:image/", StringComparison.OrdinalIgnoreCase))
+                // Skip if the image is already cached
+                if (File.Exists(image.ImagePath))
                 {
-                    await SaveImageFromBase64Async(image, filePath);
+                    Log($"Image already cached: {image.ImagePath}");
+                    continue;
                 }
-                else if (!string.IsNullOrEmpty(image.Url))
-                {
-                    await SaveImageFromUrlAsync(image, filePath);
-                }
-                else
+
+                // Próba zapisania obrazu z różnych źródeł
+                if (!await SaveImageFromDataAsync(image, image.ImagePath))
                 {
-                    Console.WriteLine($"Brak danych do zapisania dla obrazu o ID: {image.Id}");
+                    if (!await SaveImageFromUrlAsync(image, image.ImagePath))
+                    {
+                        if (!await SaveImageFromPathAsync(image, image.ImagePath, obfBaseDirectory))
+                        {
+                            LogError($"Nie udało się zapisać obrazu: {image.Id}");
+                        }
+                    }
                 }
-
-                return filePath;
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Błąd podczas zapisywania obrazu: {ex.Message}");
-                return string.Empty;
             }
         }
 
         /// <summary>
-        /// Zapisuje obraz z danych Base64 do pliku.
+        /// Generates a unique filename for the image based on its ID.
         /// </summary>
-        /// <param name="image">Obiekt Image zawierający dane Base64.</param>
-        /// <param name="filePath">Ścieżka do pliku docelowego.</param>
-        /// <returns>Task reprezentujący operację.</returns>
-        private static async Task SaveImageFromBase64Async(Image image, string filePath)
+        private static string GenerateImageFileName(Image image)
         {
+            var extension = GetFileExtension(image);
+            var imageIdSanitized = Regex.Replace(image.Id, @"[^\w\-]", "_");
+            return $"{imageIdSanitized}{extension}";
+        }
+
+        /// <summary>
+        /// Attempts to save the image from Base64 data.
+        /// </summary>
+        private static async Task<bool> SaveImageFromDataAsync(Image image, string destinationPath)
+        {
+            if (string.IsNullOrEmpty(image.Data))
+                return false;
+
             try
             {
                 var base64Data = ExtractBase64Data(image.Data);
                 var imageBytes = Convert.FromBase64String(base64Data);
-                await File.WriteAllBytesAsync(filePath, imageBytes);
-                Console.WriteLine($"Zapisano obraz Base64 do {filePath}");
+                await File.WriteAllBytesAsync(destinationPath, imageBytes);
+                Log($"Saved image from Base64 data: {destinationPath}");
+                return true;
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas zapisywania obrazu z Base64: {ex.Message}");
+                LogError($"Error saving image from Base64 data: {ex.Message}");
+                return false;
             }
         }
 
         /// <summary>
-        /// Zapisuje obraz z URL do pliku.
+        /// Attempts to save the image by downloading it from a URL.
         /// </summary>
-        /// <param name="image">Obiekt Image zawierający URL.</param>
-        /// <param name="filePath">Ścieżka do pliku docelowego.</param>
-        /// <returns>Task reprezentujący operację.</returns>
-        private static async Task SaveImageFromUrlAsync(Image image, string filePath)
+        private static async Task<bool> SaveImageFromUrlAsync(Image image, string destinationPath)
         {
+            if (string.IsNullOrEmpty(image.Url))
+                return false;
+
             try
             {
                 var response = await HttpClient.GetAsync(image.Url);
                 if (response.IsSuccessStatusCode)
                 {
                     var imageBytes = await response.Content.ReadAsByteArrayAsync();
-                    await File.WriteAllBytesAsync(filePath, imageBytes);
-                    Console.WriteLine($"Pobrano i zapisano obraz z URL: {filePath}");
+                    await File.WriteAllBytesAsync(destinationPath, imageBytes);
+                    Log($"Downloaded and saved image from URL: {destinationPath}");
+                    return true;
+                }
+                else
+                {
+                    LogError($"Failed to download image from URL: {image.Url}. Status code: {response.StatusCode}");
+                    return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                LogError($"Error downloading image from URL: {ex.Message}");
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Attempts to save the image from a file path, using only the filename.
+        /// </summary>
+        private static async Task<bool> SaveImageFromPathAsync(Image image, string destinationPath,
+            string obfBaseDirectory)
+        {
+            if (string.IsNullOrEmpty(image.Path))
+                return false;
+
+            try
+            {
+                // Sanitizuj ścieżkę obrazu, aby zapobiec atakom typu directory traversal
+                var sanitizedImagePath = SanitizeImagePath(image.Path);
+
+                // Buduj pełną ścieżkę do obrazu względem katalogu bazowego OBF
+                var fullImagePath = Path.Combine(obfBaseDirectory, sanitizedImagePath);
+                fullImagePath = Path.GetFullPath(fullImagePath);
+
+                // Upewnij się, że ścieżka obrazu znajduje się w katalogu bazowym OBF
+                var fullObfBaseDirectory = Path.GetFullPath(obfBaseDirectory);
+                if (!fullImagePath.StartsWith(fullObfBaseDirectory, StringComparison.OrdinalIgnoreCase))
+                {
+                    LogError($"Wykryto niebezpieczną ścieżkę obrazu: {image.Path}");
+                    return false;
+                }
+
+                if (File.Exists(fullImagePath))
+                {
+                    File.Copy(fullImagePath, destinationPath);
+                    Log($"Skopiowano obraz z {fullImagePath} do {destinationPath}");
+                    return true;
                 }
                 else
                 {
-                    Console.WriteLine($"Nie udało się pobrać obrazu z URL: {image.Url}. Status code: {response.StatusCode}");
+                    // Spróbuj użyć tylko nazwy pliku w znanych katalogach
+                    var imageFileName = Path.GetFileName(sanitizedImagePath);
+
+                    var potentialPaths = new[]
+                    {
+                        Path.Combine(PictogramsCacheDirectory, imageFileName),
+                        Path.Combine(ObfCacheDirectory, imageFileName)
+                    };
+
+                    foreach (var path in potentialPaths)
+                    {
+                        if (File.Exists(path))
+                        {
+                            File.Copy(path, destinationPath);
+                            Log($"Skopiowano obraz z {path} do {destinationPath}");
+                            return true;
+                        }
+                    }
+
+                    LogError($"Plik obrazu nie został znaleziony: {fullImagePath}");
+                    return false;
                 }
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas pobierania obrazu z URL: {ex.Message}");
+                LogError($"Błąd podczas zapisywania obrazu z ścieżki: {ex.Message}");
+                return false;
             }
         }
+        
+        private static string SanitizeImagePath(string imagePath)
+        {
+            // Zamień backslashes na slashe
+            imagePath = imagePath.Replace('\\', '/');
+
+            // Usuń wszelkie niebezpieczne komponenty ścieżki, takie jak '../' lub './'
+            var segments = imagePath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
+            var sanitizedSegments = new List<string>();
+            foreach (var segment in segments)
+            {
+                if (segment == "." || segment == "..")
+                {
+                    // Pomijamy niebezpieczne segmenty
+                    continue;
+                }
+                sanitizedSegments.Add(segment);
+            }
+
+            // Ponownie łączymy zsanityzowane segmenty
+            return Path.Combine(sanitizedSegments.ToArray());
+        }
 
         /// <summary>
-        /// Ekstrahuje dane Base64 z danych obrazu.
+        /// Extracts Base64 data from a data URI.
         /// </summary>
-        /// <param name="data">Dane obrazu w formacie Base64.</param>
-        /// <returns>String zawierający czyste dane Base64.</returns>
         private static string ExtractBase64Data(string data)
         {
-            var match = MyRegex().Match(data);
+            var match = DataUriRegex().Match(data);
             if (match.Success)
             {
                 return match.Groups["base64"].Value;
             }
 
-            throw new ArgumentException("Nie udało się wyodrębnić danych Base64 z obrazu.");
+            throw new ArgumentException("Failed to extract Base64 data from image.");
         }
 
         /// <summary>
-        /// Określa rozszerzenie pliku na podstawie typu obrazu.
+        /// Determines the file extension for the image.
         /// </summary>
-        /// <param name="image">Obiekt Image.</param>
-        /// <returns>Rozszerzenie pliku jako string.</returns>
         private static string GetFileExtension(Image image)
         {
             if (!string.IsNullOrEmpty(image.Data))
             {
-                var match = MyRegex().Match(image.Data);
+                var match = DataUriRegex().Match(image.Data);
                 if (match.Success)
                 {
-                    var type = match.Groups["type"].Value.ToLower();
-                    return type switch
-                    {
-                        "png" => ".png",
-                        "jpeg" => ".jpg",
-                        "jpg" => ".jpg",
-                        "svg+xml" => ".svg",
-                        _ => throw new ArgumentException($"Nieobsługiwany typ obrazu: {type}")
-                    };
+                    return GetExtensionFromMimeType(match.Groups["type"].Value);
                 }
             }
 
             if (!string.IsNullOrEmpty(image.Url))
             {
-                var extension = Path.GetExtension(new Uri(image.Url).AbsolutePath);
-                if (!string.IsNullOrEmpty(extension))
-                {
-                    return extension;
-                }
+                return Path.GetExtension(new Uri(image.Url).AbsolutePath) ?? ".png";
+            }
+
+            if (!string.IsNullOrEmpty(image.Path))
+            {
+                return Path.GetExtension(image.Path) ?? ".png";
+            }
+
+            return ".png"; // Default extension
+        }
+
+        /// <summary>
+        /// Maps MIME types to file extensions.
+        /// </summary>
+        private static string GetExtensionFromMimeType(string mimeType)
+        {
+            return mimeType.ToLower() switch
+            {
+                "png" => ".png",
+                "jpeg" or "jpg" => ".jpg",
+                "svg+xml" => ".svg",
+                _ => ".png" // Default to .png if unknown
+            };
+        }
+
+        /// <summary>
+        /// Ensures a directory exists.
+        /// </summary>
+        private static void EnsureDirectoryExists(string path)
+        {
+            Directory.CreateDirectory(path);
+        }
+
+        /// <summary>
+        /// Copies a file to the destination if it doesn't already exist there.
+        /// </summary>
+        private static async Task CopyFileIfNeededAsync(string sourcePath, string destinationPath)
+        {
+            if (!File.Exists(destinationPath))
+            {
+                await Task.Run(() => File.Copy(sourcePath, destinationPath));
+                Log($"Copied file to {destinationPath}");
             }
+            else
+            {
+                Log($"File already exists at {destinationPath}. Copying skipped.");
+            }
+        }
 
-            throw new ArgumentException("Nie można określić rozszerzenia pliku obrazu.");
+        /// <summary>
+        /// Logs a message to the console.
+        /// </summary>
+        private static void Log(string message)
+        {
+            Console.WriteLine(message);
+        }
+
+        /// <summary>
+        /// Logs an error message to the console.
+        /// </summary>
+        private static void LogError(string message)
+        {
+            Console.Error.WriteLine(message);
         }
 
+        /// <summary>
+        /// Regular expression to extract data from data URIs.
+        /// </summary>
         [GeneratedRegex(@"data:image/(?<type>\w+);base64,(?<base64>.+)")]
-        private static partial Regex MyRegex();
+        private static partial Regex DataUriRegex();
     }
 }
\ No newline at end of file
diff --git a/ChatAAC/Services/OllamaClient.cs b/ChatAAC/Services/OllamaClient.cs
index efb9bb9..bf3df22 100644
--- a/ChatAAC/Services/OllamaClient.cs
+++ b/ChatAAC/Services/OllamaClient.cs
@@ -42,11 +42,14 @@ 5.	Nie zmieniaj znaczenia ani nie wprowadzaj informacji spoza podanych słów kl
 			6.	Sformułuj zdanie w trybie {request.Form}.
 			7.	Użyj czasu {request.Tense}.
 			8.	Przyjmij, że jeśli występuje liczba, jest to: {request.Quantity}.
-			9.	Zachowaj prostotę i klarowność wypowiedzi.
+			9.	Zachowaj prostotę i klarowność wypowiedzi nie pomijając słów kluczowych.
 
 			Odpowiedź:
 
-			Podaj tylko jedno wygenerowane zdanie, bez żadnych dodatkowych komentarzy czy wyjaśnień.";
+			Podaj tylko jedno wygenerowane zdanie, bez żadnych dodatkowych komentarzy czy wyjaśnień.
+			Przygotuj odpowiedź do odczytania dla osoby z którą rozmawia osoba niepełnosprawna w języku: {ConfigViewModel.Instance.SelectedLanguage}.";
+		
+        
 
         Console.WriteLine(prompt);
         
diff --git a/ChatAAC/Services/PictogramService.cs b/ChatAAC/Services/PictogramService.cs
index 38bbd50..725b9a9 100644
--- a/ChatAAC/Services/PictogramService.cs
+++ b/ChatAAC/Services/PictogramService.cs
@@ -5,8 +5,6 @@
 using System.Text.Json;
 using System.IO;
 using System.Linq;
-using System.Text.Json.Serialization;
-using ChatAAC.Converters;
 using ChatAAC.Models;
 
 namespace ChatAAC.Services;
diff --git a/ChatAAC/ViewModels/ButtonViewModel.cs b/ChatAAC/ViewModels/ButtonViewModel.cs
new file mode 100644
index 0000000..c1ea300
--- /dev/null
+++ b/ChatAAC/ViewModels/ButtonViewModel.cs
@@ -0,0 +1,12 @@
+using ChatAAC.Models.Obf;
+using ReactiveUI;
+
+namespace ChatAAC.ViewModels
+{
+    public class ButtonViewModel(Button button, int row, int column) : ReactiveObject
+    {
+        public Button Button { get; set; } = button;
+        public int Row { get; set; } = row;
+        public int Column { get; set; } = column;
+    }
+}
\ No newline at end of file
diff --git a/ChatAAC/ViewModels/MainViewModel.cs b/ChatAAC/ViewModels/MainViewModel.cs
index fbec963..c0edb58 100644
--- a/ChatAAC/ViewModels/MainViewModel.cs
+++ b/ChatAAC/ViewModels/MainViewModel.cs
@@ -1,8 +1,4 @@
-using Avalonia.Threading;
-using ChatAAC.Models;
-using ChatAAC.Services;
-using ReactiveUI;
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -10,596 +6,716 @@
 using System.IO.Compression;
 using System.Linq;
 using System.Reactive;
-using System.Text;
-using System.Threading.Tasks;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Threading;
 using Avalonia.VisualTree;
+using ChatAAC.Models;
 using ChatAAC.Models.Obf;
+using ChatAAC.Services;
 using ChatAAC.Views;
+using ReactiveUI;
 using Button = ChatAAC.Models.Obf.Button;
 
-namespace ChatAAC.ViewModels;
-
-public class MainViewModel : ViewModelBase
+namespace ChatAAC.ViewModels
 {
-    public ObservableCollection<Button> Buttons { get; set; } = new();
-    public ObservableCollection<Button> SelectedButtons { get; set; } = new();
-
-    private string _selectedTense = "Teraźniejszy";
-
-    public string SelectedTense
-    {
-        get => _selectedTense;
-        set => this.RaiseAndSetIfChanged(ref _selectedTense, value);
-    }
+    public class MainViewModel : ViewModelBase
+    {
+        #region Fields
+
+        private readonly OllamaClient _ollamaClient = new();
+        private readonly ITtsService _ttsService;
+        private readonly ConcurrentDictionary<string, ObfFile> _obfCache = new();
+
+        private string _selectedTense = "Teraźniejszy";
+        private string _selectedForm = "Oznajmująca";
+        private int _quantity = 1;
+        private bool _isConfigBarVisible;
+        private string _constructedSentence = string.Empty;
+        private string _aiResponse = string.Empty;
+        private bool _isLoading;
+        private bool _isFullScreen;
+        private ObfFile? _obfData;
+        private int _currentBoardIndex;
+        private int _gridRows;
+        private int _gridColumns;
+        private bool _isInitialized;
+        private readonly string _historyFilePath = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            "ChatAAC",
+            "ai_response_history.json");
+
+        #endregion
+
+        #region Properties
+
+        public ObservableCollection<ButtonViewModel> Buttons { get; } = new();
+        public ObservableCollection<Button> SelectedButtons { get; } = new();
+        public ObservableCollection<AiResponse> AiResponseHistory { get; } = new();
+
+        public string SelectedTense
+        {
+            get => _selectedTense;
+            set => this.RaiseAndSetIfChanged(ref _selectedTense, value);
+        }
 
-    private string _selectedForm = "Oznajmująca";
+        public string SelectedForm
+        {
+            get => _selectedForm;
+            set => this.RaiseAndSetIfChanged(ref _selectedForm, value);
+        }
 
-    public string SelectedForm
-    {
-        get => _selectedForm;
-        set => this.RaiseAndSetIfChanged(ref _selectedForm, value);
-    }
+        public int Quantity
+        {
+            get => _quantity;
+            set => this.RaiseAndSetIfChanged(ref _quantity, value);
+        }
 
-    private int _quantity = 1;
+        public bool IsConfigBarVisible
+        {
+            get => _isConfigBarVisible;
+            set => this.RaiseAndSetIfChanged(ref _isConfigBarVisible, value);
+        }
 
-    public int Quantity
-    {
-        get => _quantity;
-        set => this.RaiseAndSetIfChanged(ref _quantity, value);
-    }
+        public string ConstructedSentence
+        {
+            get => _constructedSentence;
+            private set => this.RaiseAndSetIfChanged(ref _constructedSentence, value);
+        }
 
-    private bool _isConfigBarVisible;
+        public string AiResponse
+        {
+            get => _aiResponse;
+            set => this.RaiseAndSetIfChanged(ref _aiResponse, value);
+        }
 
-    public bool IsConfigBarVisible
-    {
-        get => _isConfigBarVisible;
-        set => this.RaiseAndSetIfChanged(ref _isConfigBarVisible, value);
-    }
+        public bool IsLoading
+        {
+            get => _isLoading;
+            set => this.RaiseAndSetIfChanged(ref _isLoading, value);
+        }
 
-    public ReactiveCommand<Unit, Unit> OpenSettingsCommand { get; }
-    public ReactiveCommand<Unit, Unit> LoadMainBoardCommand { get; }
-    public ReactiveCommand<Unit, Unit> ClearSelectedCommand { get; }
-    public ReactiveCommand<Button, Unit> ButtonClickedCommand { get; }
-    public ReactiveCommand<Button, Unit> RemoveButtonCommand { get; }
-    public ReactiveCommand<Unit, Unit> SpeakCommand { get; }
-    public ReactiveCommand<Unit, Unit> SendToAiCommand { get; }
-    public ReactiveCommand<Unit, Unit> SpeakAiResponseCommand { get; }
-    public ReactiveCommand<Unit, Unit> CopySentenceCommand { get; }
-    public ReactiveCommand<string, Unit> CopyHistoryItemCommand { get; }
-    public ReactiveCommand<Unit, Unit> ClearHistoryCommand { get; }
-    public ReactiveCommand<Unit, Unit> CopyAiResponseCommand { get; }
+        public bool IsFullScreen
+        {
+            get => _isFullScreen;
+            set => this.RaiseAndSetIfChanged(ref _isFullScreen, value);
+        }
 
-    private readonly OllamaClient _ollamaClient = new();
-    private readonly ITtsService _ttsService;
+        public ObfFile? ObfData
+        {
+            get => _obfData;
+            set => this.RaiseAndSetIfChanged(ref _obfData, value);
+        }
 
-    public ObservableCollection<AiResponse> AiResponseHistory { get; }
+        public int CurrentBoardIndex
+        {
+            get => _currentBoardIndex;
+            set => this.RaiseAndSetIfChanged(ref _currentBoardIndex, value);
+        }
 
-    private string _constructedSentence = string.Empty;
+        public int GridRows
+        {
+            get => _gridRows;
+            set => this.RaiseAndSetIfChanged(ref _gridRows, value);
+        }
 
-    public string ConstructedSentence
-    {
-        get => _constructedSentence;
-        private set => this.RaiseAndSetIfChanged(ref _constructedSentence, value);
-    }
+        public int GridColumns
+        {
+            get => _gridColumns;
+            set => this.RaiseAndSetIfChanged(ref _gridColumns, value);
+        }
 
-    private string _aiResponse = string.Empty;
+        #endregion
 
-    public string AiResponse
-    {
-        get => _aiResponse;
-        set => this.RaiseAndSetIfChanged(ref _aiResponse, value);
-    }
+        #region Commands
 
-    private bool _isLoading;
+        public ReactiveCommand<Unit, Unit> OpenSettingsCommand { get; }
+        public ReactiveCommand<Unit, Unit> LoadMainBoardCommand { get; }
+        public ReactiveCommand<Unit, Unit> ClearSelectedCommand { get; }
+        public ReactiveCommand<Button, Unit> ButtonClickedCommand { get; }
+        public ReactiveCommand<Button, Unit> RemoveButtonCommand { get; }
+        public ReactiveCommand<Unit, Unit> SpeakCommand { get; }
+        public ReactiveCommand<Unit, Unit> SendToAiCommand { get; }
+        public ReactiveCommand<Unit, Unit> SpeakAiResponseCommand { get; }
+        public ReactiveCommand<Unit, Unit> CopySentenceCommand { get; }
+        public ReactiveCommand<string, Unit> CopyHistoryItemCommand { get; }
+        public ReactiveCommand<Unit, Unit> ClearHistoryCommand { get; }
+        public ReactiveCommand<Unit, Unit> CopyAiResponseCommand { get; }
+        public ReactiveCommand<Unit, Unit> NextBoardCommand { get; }
+        public ReactiveCommand<Unit, Unit> PreviousBoardCommand { get; }
 
-    public bool IsLoading
-    {
-        get => _isLoading;
-        set => this.RaiseAndSetIfChanged(ref _isLoading, value);
-    }
+        #endregion
 
-    private bool _isFullScreen = false;
+        #region Constructor
 
-    public bool IsFullScreen
-    {
-        get => _isFullScreen;
-        set => this.RaiseAndSetIfChanged(ref _isFullScreen, value);
-    }
+        public MainViewModel()
+        {
+            // Initialize TTS service based on the platform
+            _ttsService = InitializeTtsService();
+
+            // Initialize commands
+            OpenSettingsCommand = ReactiveCommand.Create(OpenSettings);
+            LoadMainBoardCommand = ReactiveCommand.CreateFromTask(LoadInitialFileAsync);
+            ClearSelectedCommand = ReactiveCommand.Create(ClearSelected);
+            ButtonClickedCommand = ReactiveCommand.CreateFromTask<Button>(OnButtonClickedAsync);
+            RemoveButtonCommand = ReactiveCommand.Create<Button>(RemoveSelectedButton);
+            SpeakCommand = ReactiveCommand.Create(SpeakConstructedSentence);
+            SendToAiCommand = ReactiveCommand.CreateFromTask(SendToAiAsync);
+            SpeakAiResponseCommand = ReactiveCommand.CreateFromTask(SpeakAiResponseAsync);
+            CopySentenceCommand = ReactiveCommand.Create(CopyConstructedSentenceToClipboard);
+            CopyHistoryItemCommand = ReactiveCommand.Create<string>(CopyToClipboard);
+            ClearHistoryCommand = ReactiveCommand.Create(ClearHistory);
+            CopyAiResponseCommand = ReactiveCommand.Create(CopyAiResponseToClipboard);
+            NextBoardCommand = ReactiveCommand.CreateFromTask(LoadNextBoardAsync);
+            PreviousBoardCommand = ReactiveCommand.CreateFromTask(LoadPreviousBoardAsync);
+
+            // Subscribe to changes in SelectedButtons
+            SelectedButtons.CollectionChanged += (_, _) => UpdateConstructedSentence();
+
+            // Load AI response history
+            LoadHistory();
+
+            // Load initial OBF or OBZ file
+            _ = LoadInitialFileAsync();
+        }
 
-    private ObfFile? _obfData;
+        #endregion
 
-    public ObfFile? ObfData
-    {
-        get => _obfData;
-        set => this.RaiseAndSetIfChanged(ref _obfData, value);
-    }
+        #region Initialization Methods
 
-    // Bufor dla wczytanych plików OBF
-    private readonly ConcurrentDictionary<string, ObfFile> _obfCache = new();
+        private ITtsService InitializeTtsService()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                return new MacTtsService();
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                return new WindowsTtsService();
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                return new LinuxTtsService();
+
+            throw new PlatformNotSupportedException("The platform is not supported for TTS.");
+        }
 
-    // Nowe właściwości
-    private int _currentBoardIndex = 0;
+        private async Task LoadInitialFileAsync()
+        {
+            if (_isInitialized || string.IsNullOrEmpty(ConfigViewModel.Instance.DefaultBoardPath))
+                return;
 
-    public int CurrentBoardIndex
-    {
-        get => _currentBoardIndex;
-        set => this.RaiseAndSetIfChanged(ref _currentBoardIndex, value);
-    }
+            IsLoading = true;
+            try
+            {
+                var defaultBoardPath = ConfigViewModel.Instance.DefaultBoardPath;
 
-    public ReactiveCommand<Unit, Unit> NextBoardCommand { get; }
-    public ReactiveCommand<Unit, Unit> PreviousBoardCommand { get; }
+                if (!string.IsNullOrEmpty(defaultBoardPath))
+                {
+                    await LoadObfOrObzFileAsync(defaultBoardPath);
+                }
+                else if (ConfigViewModel.Instance.BoardPaths.Count > 0)
+                {
+                    await LoadObfOrObzFileAsync(ConfigViewModel.Instance.BoardPaths[0]);
+                }
+                else
+                {
+                    Console.WriteLine("No default board or additional boards to load.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error loading initial file: {ex.Message}");
+            }
+            finally
+            {
+                IsLoading = false;
+                _isInitialized = true;
+            }
+        }
 
-    public MainViewModel()
-    {
-        AiResponseHistory = new();
-        LoadHistory();
-
-        // Inicjalizacja TTS w zależności od platformy
-        _ttsService = RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? new MacTtsService()
-            : RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? new WindowsTtsService()
-            : RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? new LinuxTtsService()
-            : throw new PlatformNotSupportedException("Platforma nie jest wspierana przez TTS.");
-
-        LoadMainBoardCommand = ReactiveCommand.CreateFromTask(LoadInitialFile);
-        ClearSelectedCommand = ReactiveCommand.Create(ClearSelected);
-        ButtonClickedCommand = ReactiveCommand.CreateFromTask<Button>(OnButtonClickedAsync);
-        RemoveButtonCommand = ReactiveCommand.Create<Button>(OnRemoveButton);
-        SpeakCommand = ReactiveCommand.Create(OnSpeak);
-        OpenSettingsCommand = ReactiveCommand.Create(OnOpenSettings);
-
-        SendToAiCommand = ReactiveCommand.CreateFromTask(OnSendToAiAsync, outputScheduler: RxApp.MainThreadScheduler);
-        SpeakAiResponseCommand =
-            ReactiveCommand.CreateFromTask(OnSpeakAiResponseAsync, outputScheduler: RxApp.MainThreadScheduler);
-        CopySentenceCommand = ReactiveCommand.Create(OnCopySentence);
-        CopyHistoryItemCommand = ReactiveCommand.Create<string>(CopyToClipboard);
-        ClearHistoryCommand = ReactiveCommand.Create(ClearHistory);
-        CopyAiResponseCommand = ReactiveCommand.Create(OnCopyAiResponse);
-
-        NextBoardCommand = ReactiveCommand.CreateFromTask(LoadNextBoardAsync);
-        PreviousBoardCommand = ReactiveCommand.CreateFromTask(LoadPreviousBoardAsync);
-
-        SelectedButtons.CollectionChanged += (_, _) => UpdateConstructedSentence();
-
-        _ = LoadInitialFile();
-    }
+        #endregion
 
-    private bool _isInitialized;
+        #region Board Navigation Methods
 
-    private async Task LoadNextBoardAsync()
-    {
-        var boardPaths = ConfigViewModel.Instance.BoardPaths;
-        if (boardPaths.Count == 0)
+        private async Task LoadNextBoardAsync()
         {
-            Console.WriteLine("Brak dodatkowych tablic do załadowania.");
-            return;
-        }
+            var boardPaths = ConfigViewModel.Instance.BoardPaths;
+            if (boardPaths.Count == 0)
+            {
+                Console.WriteLine("No additional boards to load.");
+                return;
+            }
 
-        CurrentBoardIndex = (CurrentBoardIndex + 1) % boardPaths.Count;
-        var nextBoardPath = boardPaths[CurrentBoardIndex];
-        await LoadObfOrObzFileAsync(nextBoardPath);
-    }
+            CurrentBoardIndex = (CurrentBoardIndex + 1) % boardPaths.Count;
+            var nextBoardPath = boardPaths[CurrentBoardIndex];
+            await LoadObfOrObzFileAsync(nextBoardPath);
+        }
 
-    private async Task LoadPreviousBoardAsync()
-    {
-        var boardPaths = ConfigViewModel.Instance.BoardPaths;
-        if (boardPaths.Count == 0)
+        private async Task LoadPreviousBoardAsync()
         {
-            Console.WriteLine("Brak dodatkowych tablic do załadowania.");
-            return;
+            var boardPaths = ConfigViewModel.Instance.BoardPaths;
+            if (boardPaths.Count == 0)
+            {
+                Console.WriteLine("No additional boards to load.");
+                return;
+            }
+
+            CurrentBoardIndex = (CurrentBoardIndex - 1 + boardPaths.Count) % boardPaths.Count;
+            var previousBoardPath = boardPaths[CurrentBoardIndex];
+            await LoadObfOrObzFileAsync(previousBoardPath);
         }
 
-        CurrentBoardIndex = (CurrentBoardIndex - 1 + boardPaths.Count) % boardPaths.Count;
-        var previousBoardPath = boardPaths[CurrentBoardIndex];
-        await LoadObfOrObzFileAsync(previousBoardPath);
-    }
+        #endregion
 
-    private async Task LoadInitialFile()
-    {
-        if (_isInitialized || string.IsNullOrEmpty(ConfigViewModel.Instance.DefaultBoardPath))
-            return;
+        #region File Loading Methods
 
-        IsLoading = true;
-        try
+        private async Task LoadObfOrObzFileAsync(string filePath)
         {
-            var defaultBoardPath = ConfigViewModel.Instance.DefaultBoardPath;
-
-            if (!string.IsNullOrEmpty(defaultBoardPath))
+            if (filePath.EndsWith(".obz", StringComparison.OrdinalIgnoreCase))
             {
-                await LoadObfOrObzFileAsync(defaultBoardPath);
+                await LoadObzFileAsync(filePath);
             }
-            else if (ConfigViewModel.Instance.BoardPaths.Count > 0)
+            else if (filePath.EndsWith(".obf", StringComparison.OrdinalIgnoreCase))
             {
-                await LoadObfOrObzFileAsync(ConfigViewModel.Instance.BoardPaths[0]);
+                await LoadObfFileAsync(filePath);
             }
             else
             {
-                Console.WriteLine("Brak domyślnej tablicy lub dodatkowych tablic do załadowania.");
+                Console.WriteLine("Nieobsługiwany typ pliku. Podaj plik z rozszerzeniem .obf lub .obz.");
             }
         }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Błąd podczas wczytywania pliku początkowego: {ex.Message}");
-        }
-        finally
-        {
-            IsLoading = false;
-            _isInitialized = true;
-        }
-    }
-
-    private async Task LoadObfOrObzFileAsync(string filePath)
-    {
-        if (filePath.EndsWith(".obz"))
-            await LoadObzFileAsync(filePath);
-        else if (filePath.EndsWith(".obf"))
-            await LoadObfFileAsync(filePath);
-        else
-            Console.WriteLine("Nieobsługiwany typ pliku. Podaj plik z rozszerzeniem .obf lub .obz.");
-    }
 
-    private async Task LoadObfFileAsync(string filePath)
-    {
-        try
+        private async Task LoadObfFileAsync(string filePath)
         {
             IsLoading = true;
-            Console.WriteLine($"Wczytywanie pliku OBF: {filePath}");
+            try
+            {
+                var obfFile = await ObfLoader.LoadObfAsync(filePath);
+                if (obfFile == null)
+                {
+                    Console.WriteLine("The OBF file is empty or invalid.");
+                    return;
+                }
+
+                ObfData = obfFile;
 
-            if (_obfCache.TryGetValue(filePath, out var cachedObf))
+                // Load buttons from ObfData
+                LoadButtonsFromObfData(ObfData);
+            }
+            catch (Exception ex)
             {
-                Console.WriteLine($"Plik OBF załadowany z bufora: {filePath}");
-                ObfData = cachedObf;
+                Console.WriteLine($"Error loading OBF file: {ex.Message}");
             }
-            else
+            finally
+            {
+                IsLoading = false;
+            }
+        }
+
+        private async Task LoadObzFileAsync(string filePath)
+        {
+            IsLoading = true;
+            var tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+
+            try
             {
-                var obfData = await ObfLoader.LoadObfAsync(filePath);
-                if (obfData != null)
+                Directory.CreateDirectory(tempDirectory);
+
+                await ExtractObzArchiveAsync(filePath, tempDirectory);
+
+                var manifestPath = Path.Combine(tempDirectory, "manifest.json");
+                if (File.Exists(manifestPath))
                 {
-                    _obfCache[filePath] = obfData;
-                    ObfData = obfData;
-                    Console.WriteLine("Plik OBF został wczytany i dodany do bufora.");
+                    var manifestJson = await File.ReadAllTextAsync(manifestPath);
+                    var manifest = JsonSerializer.Deserialize<Manifest>(manifestJson);
+
+                    var rootObfPath = Path.Combine(tempDirectory, manifest?.Root ?? "root.obf");
+                    if (File.Exists(rootObfPath))
+                    {
+                        await LoadObfFileAsync(rootObfPath);
+                    }
+                    else
+                    {
+                        Console.WriteLine("root.obf file not found in the OBZ package.");
+                    }
                 }
                 else
                 {
-                    Console.WriteLine("Plik OBF jest pusty lub niepoprawny.");
-                    return;
+                    Console.WriteLine("manifest.json file not found in the OBZ package.");
                 }
             }
-
-            await Dispatcher.UIThread.InvokeAsync(() =>
+            catch (Exception ex)
             {
-                Buttons.Clear();
-                foreach (var button in ObfData.Buttons)
+                Console.WriteLine($"Error loading OBZ file: {ex.Message}");
+            }
+            finally
+            {
+                IsLoading = false;
+                // Remove the temporary directory after use
+                if (Directory.Exists(tempDirectory))
                 {
-                    Buttons.Add(button);
+                    Directory.Delete(tempDirectory, true);
                 }
-            });
+            }
         }
-        catch (Exception ex)
+
+        private async Task ExtractObzArchiveAsync(string filePath, string extractPath)
         {
-            Console.WriteLine($"Błąd podczas wczytywania pliku OBF: {ex.Message}");
+            await Task.Run(() =>
+            {
+                using var archive = ZipFile.OpenRead(filePath);
+                foreach (var entry in archive.Entries)
+                {
+                    // Sanitize the entry name
+                    var sanitizedEntryName = SanitizeEntryName(entry.FullName);
+
+                    // Build the destination path
+                    var destinationPath = Path.GetFullPath(Path.Combine(extractPath, sanitizedEntryName));
+
+                    if (!destinationPath.StartsWith(extractPath, StringComparison.Ordinal))
+                    {
+                        // Skip dangerous entries
+                        Console.WriteLine($"Skipped unsafe entry: {entry.FullName}");
+                        continue;
+                    }
+
+                    if (string.IsNullOrEmpty(entry.Name))
+                    {
+                        // This is a directory, create it
+                        Directory.CreateDirectory(destinationPath);
+                    }
+                    else
+                    {
+                        // Ensure the destination directory exists
+                        Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
+                        entry.ExtractToFile(destinationPath, overwrite: true);
+                    }
+                }
+            });
         }
-        finally
+
+        private string SanitizeEntryName(string entryName)
         {
-            IsLoading = false;
+            // Replace backslashes with slashes
+            entryName = entryName.Replace('\\', '/');
+
+            // Remove drive letters or root indicators
+            entryName = Regex.Replace(entryName, @"^[a-zA-Z]:/", "");
+
+            // Remove any leading slashes
+            entryName = entryName.TrimStart('/');
+
+            // Remove "../" and "./" components
+            var segments = entryName.Split('/');
+            var sanitizedSegments = segments.Where(segment => segment != ".." && segment != ".").ToArray();
+
+            return Path.Combine(sanitizedSegments);
         }
-    }
 
-    private async Task LoadObzFileAsync(string filePath)
-    {
-        IsLoading = true;
-        var tempDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        #endregion
+
+        #region Button Handling Methods
 
-        try
+        private void LoadButtonsFromObfData(ObfFile obfFile)
         {
-            Directory.CreateDirectory(tempDirectory);
+            // Clear existing buttons
+            Buttons.Clear();
 
-            using var archive = ZipFile.OpenRead(filePath);
-            foreach (var entry in archive.Entries)
-            {
-                // Bezpieczna ekstrakcja każdego wpisu
-                var destinationPath = Path.GetFullPath(Path.Combine(tempDirectory, entry.FullName));
+            // Map buttons from OBF to a dictionary for quick access by ID
+            var buttonDictionary = obfFile.Buttons.ToDictionary(b => b.Id ?? 0);
 
-                if (!destinationPath.StartsWith(tempDirectory, StringComparison.Ordinal))
+            if (obfFile.Grid != null)
+            {
+                var rowIndex = 0;
+                foreach (var row in obfFile.Grid.Order)
                 {
-                    // Ostrzeżenie lub pominięcie niebezpiecznego wpisu
-                    Console.WriteLine($"Pominięto niebezpieczny wpis: {entry.FullName}");
-                    continue;
+                    var columnIndex = 0;
+                    foreach (var buttonId in row)
+                    {
+                        if (buttonId.HasValue && buttonDictionary.TryGetValue(buttonId.Value, out var button))
+                        {
+                            var buttonViewModel = new ButtonViewModel(button, rowIndex, columnIndex);
+                            Buttons.Add(buttonViewModel);
+                        }
+                        columnIndex++;
+                    }
+                    rowIndex++;
                 }
 
-                if (string.IsNullOrEmpty(entry.Name))
-                {
-                    // To jest katalog, utwórz go
-                    Directory.CreateDirectory(destinationPath);
-                }
-                else
-                {
-                    // Upewnij się, że katalog docelowy istnieje
-                    Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
-                    entry.ExtractToFile(destinationPath, overwrite: true);
-                }
+                GridRows = obfFile.Grid.Rows;
+                GridColumns = obfFile.Grid.Columns;
             }
-
-            var manifestPath = Path.Combine(tempDirectory, "manifest.json");
-            if (File.Exists(manifestPath))
+            else
             {
-                var manifestJson = await File.ReadAllTextAsync(manifestPath);
-                var manifest = JsonSerializer.Deserialize<Manifest>(manifestJson);
-
-                var rootObfPath = Path.Combine(tempDirectory, manifest?.Root ?? "root.obf");
-                if (File.Exists(rootObfPath))
-                {
-                    await LoadObfFileAsync(rootObfPath);
-                }
-                else
+                foreach (var button in obfFile.Buttons)
                 {
-                    Console.WriteLine("Plik root.obf nie został znaleziony w paczce OBZ.");
+                    var buttonViewModel = new ButtonViewModel(button, 0, 0);
+                    Buttons.Add(buttonViewModel);
                 }
-            }
-            else
-            {
-                Console.WriteLine("Plik manifest.json nie został znaleziony w paczce OBZ.");
+
+                GridRows = 1;
+                GridColumns = Buttons.Count;
             }
         }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Błąd podczas wczytywania pliku OBZ: {ex.Message}");
-        }
-        finally
+
+        private async Task OnButtonClickedAsync(Button button)
         {
-            IsLoading = false;
-            // Usuwamy tymczasowy katalog po użyciu
-            if (Directory.Exists(tempDirectory))
+            Console.WriteLine($"Kliknięto przycisk: {button.Label}");
+
+            if (button.LoadBoard != null && !string.IsNullOrEmpty(button.LoadBoard.Path))
+            {
+                await LoadObfOrObzFileAsync(button.LoadBoard.Path);
+            }
+            else
             {
-                Directory.Delete(tempDirectory, true);
+                if (SelectedButtons.Contains(button)) return;
+                SelectedButtons.Add(button);
             }
         }
-    }
-
-    private void OnOpenSettings()
-    {
-        var configWindow = new ConfigWindow
-        {
-            DataContext = new ConfigViewModel()
-        };
-        var mainWindow = (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)
-            ?.MainWindow;
-        if (mainWindow != null)
-            configWindow.ShowDialog(mainWindow);
-        else
-            configWindow.Show();
-    }
-
-    private void ClearSelected() => SelectedButtons.Clear();
-
-    private async Task OnButtonClickedAsync(Button button)
-    {
-        Console.WriteLine($"Kliknięto przycisk: {button.Label}");
 
-        if (button.LoadBoard != null)
+        private async Task LoadBoardAsync(string boardPath)
         {
-            var boardPath = Path.Combine(
-                ObfLoader.ObfCacheDirectory,
-                button.LoadBoard.Path);
+            var fullBoardPath = Path.Combine(ObfLoader.ObfCacheDirectory, boardPath);
 
-
-            if (_obfCache.TryGetValue(boardPath, out ObfFile? value))
+            if (_obfCache.TryGetValue(fullBoardPath, out var cachedObf))
             {
-                Console.WriteLine($"Ładowanie tablicy z bufora: {boardPath}");
-                ObfData = value;
+                Console.WriteLine($"Loading board from cache: {fullBoardPath}");
+                ObfData = cachedObf;
                 await Dispatcher.UIThread.InvokeAsync(() =>
                 {
-                    Buttons.Clear();
-                    foreach (var btn in ObfData.Buttons)
+                    if (ObfData != null)
                     {
-                        Buttons.Add(btn);
+                        LoadButtonsFromObfData(ObfData);
                     }
                 });
             }
             else
             {
-                await LoadObfOrObzFileAsync(boardPath);
+                await LoadObfOrObzFileAsync(fullBoardPath);
             }
         }
-        else
+
+        private void RemoveSelectedButton(Button button)
         {
-            if (SelectedButtons.Contains(button)) return;
-            SelectedButtons.Add(button);
-            UpdateConstructedSentence();
+            if (SelectedButtons.Contains(button))
+            {
+                SelectedButtons.Remove(button);
+            }
         }
-    }
 
-    private void OnRemoveButton(Button button)
-    {
-        if (SelectedButtons.Contains(button))
+        private void ClearSelected() => SelectedButtons.Clear();
+
+        #endregion
+
+        #region Sentence Construction Methods
+
+        private void UpdateConstructedSentence()
         {
-            SelectedButtons.Remove(button);
-            UpdateConstructedSentence();
+            ConstructedSentence = string.Join(" ", SelectedButtons.Select(p => p.Label));
+            Console.WriteLine($"Constructed sentence: {ConstructedSentence}");
         }
-    }
 
-    private void UpdateConstructedSentence()
-    {
-        ConstructedSentence = string.Join(" ", SelectedButtons.Select(p => p.Label));
-        Console.WriteLine($"Skonstruowane zdanie: {ConstructedSentence}");
-    }
+        private void SpeakConstructedSentence()
+        {
+            var sentence = ConstructedSentence;
+            Task.Run(async () =>
+            {
+                try
+                {
+                    await _ttsService.SpeakAsync(sentence).ConfigureAwait(false);
+                    Console.WriteLine($"Spoken sentence: {sentence}");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error speaking text: {ex.Message}");
+                }
+            });
+        }
 
-    private void OnSpeak()
-    {
-        var sentence = ConstructedSentence;
-        Task.Run(async () =>
+        #endregion
+
+        #region AI Interaction Methods
+
+        private async Task SendToAiAsync()
         {
+            if (string.IsNullOrWhiteSpace(ConstructedSentence))
+            {
+                AiResponse = "No buttons selected.";
+                return;
+            }
+
             try
             {
-                await _ttsService.SpeakAsync(sentence).ConfigureAwait(false);
-                Console.WriteLine($"Odczytano zdanie: {sentence}");
+                IsLoading = true;
+                AiResponse = "Generating response...";
+                Console.WriteLine($"Sending query: {ConstructedSentence}");
+
+                var chatRequest = new ChatRequest
+                {
+                    Model = ConfigViewModel.Instance.SelectedModel,
+                    Prompt = ConstructedSentence,
+                    Form = SelectedForm,
+                    Tense = SelectedTense,
+                    Quantity = Quantity
+                };
+
+                var response = await _ollamaClient.ChatAsync(chatRequest).ConfigureAwait(false);
+                AiResponse = await CombineAsyncEnumerableAsync(response).ConfigureAwait(false);
+
+                Console.WriteLine($"AI Response: {AiResponse}");
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas odczytywania tekstu: {ex.Message}");
+                AiResponse = $"Error: {ex.Message}";
+                Console.WriteLine($"Error communicating with AI: {ex.Message}");
             }
-        });
-    }
+            finally
+            {
+                IsLoading = false;
+                AddAiResponseToHistory(AiResponse);
+                CopyAiResponseToClipboard();
+                await SpeakAiResponseAsync();
+            }
+        }
 
-    private async Task OnSendToAiAsync()
-    {
-        if (string.IsNullOrWhiteSpace(ConstructedSentence))
+        private async Task<string> CombineAsyncEnumerableAsync(IAsyncEnumerable<string> asyncStrings)
         {
-            AiResponse = "Nie wybrano żadnych przycisków.";
-            return;
+            var stringBuilder = new StringBuilder();
+            await foreach (var str in asyncStrings.ConfigureAwait(false))
+            {
+                stringBuilder.Append(str);
+            }
+            return stringBuilder.ToString();
         }
 
-        try
+        private async Task SpeakAiResponseAsync()
         {
-            IsLoading = true;
-            AiResponse = "Generowanie odpowiedzi...";
-            Console.WriteLine($"Wysyłanie zapytania: {ConstructedSentence}");
-
-            var chatRequest = new ChatRequest
+            if (!string.IsNullOrEmpty(AiResponse))
             {
-                Model = ConfigViewModel.Instance.SelectedModel,
-                Prompt = ConstructedSentence,
-                Form = SelectedForm,
-                Tense = SelectedTense,
-                Quantity = Quantity
-            };
+                try
+                {
+                    await _ttsService.SpeakAsync(AiResponse).ConfigureAwait(false);
+                    Console.WriteLine($"Spoken AI response: {AiResponse}");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error speaking AI response: {ex.Message}");
+                }
+            }
+        }
 
-            var response = await _ollamaClient.ChatAsync(chatRequest).ConfigureAwait(false);
-            AiResponse = await CombineAsyncEnumerableAsync(response).ConfigureAwait(false);
+        #endregion
 
-            Console.WriteLine($"Odpowiedź AI: {AiResponse}");
-        }
-        catch (Exception ex)
+        #region Clipboard Methods
+
+        private void CopyAiResponseToClipboard()
         {
-            AiResponse = $"Błąd: {ex.Message}";
-            Console.WriteLine($"Błąd podczas komunikacji z AI: {ex.Message}");
+            if (!string.IsNullOrEmpty(AiResponse))
+            {
+                CopyToClipboard(AiResponse);
+            }
         }
-        finally
+
+        private void CopyConstructedSentenceToClipboard()
         {
-            IsLoading = false;
-            AddAiResponseToHistory(AiResponse);
-            OnCopyAiResponse();
-            await OnSpeakAiResponseAsync();
+            if (!string.IsNullOrEmpty(ConstructedSentence))
+            {
+                CopyToClipboard(ConstructedSentence);
+            }
         }
-    }
 
-    private async Task<string> CombineAsyncEnumerableAsync(IAsyncEnumerable<string> asyncStrings)
-    {
-        var stringBuilder = new StringBuilder();
-        await foreach (var str in asyncStrings.ConfigureAwait(false))
+        private void CopyToClipboard(string textToClipboard)
         {
-            stringBuilder.Append(str);
+            Dispatcher.UIThread.Post(() =>
+            {
+                switch (Application.Current?.ApplicationLifetime)
+                {
+                    case IClassicDesktopStyleApplicationLifetime { MainWindow: { } window }:
+                        window.Clipboard?.SetTextAsync(textToClipboard);
+                        break;
+                    case ISingleViewApplicationLifetime { MainView: { } mainView }:
+                        if (mainView.GetVisualRoot() is TopLevel topLevel)
+                            topLevel.Clipboard?.SetTextAsync(textToClipboard);
+                        break;
+                    default:
+                        Console.WriteLine("Clipboard is not available.");
+                        break;
+                }
+            });
         }
 
-        return stringBuilder.ToString();
-    }
+        #endregion
 
-    private async Task OnSpeakAiResponseAsync()
-    {
-        if (!string.IsNullOrEmpty(AiResponse))
+        #region History Methods
+
+        private void AddAiResponseToHistory(string response)
+        {
+            if (string.IsNullOrWhiteSpace(response)) return;
+            AiResponseHistory.Add(new AiResponse(response));
+            SaveHistory();
+        }
+
+        private void SaveHistory()
         {
             try
             {
-                await _ttsService.SpeakAsync(AiResponse).ConfigureAwait(false);
-                Console.WriteLine($"Odczytano odpowiedź AI: {AiResponse}");
+                var directory = Path.GetDirectoryName(_historyFilePath);
+                if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
+                    Directory.CreateDirectory(directory);
+
+                var options = new JsonSerializerOptions { WriteIndented = true };
+                var json = JsonSerializer.Serialize(AiResponseHistory, options);
+                File.WriteAllText(_historyFilePath, json);
             }
             catch (Exception ex)
             {
-                Console.WriteLine($"Błąd podczas odczytywania odpowiedzi AI: {ex.Message}");
+                Console.WriteLine($"Error saving history: {ex.Message}");
             }
         }
-    }
 
-    private void OnCopyAiResponse()
-    {
-        if (!string.IsNullOrEmpty(AiResponse))
+        private void LoadHistory()
         {
-            CopyToClipboard(AiResponse);
+            try
+            {
+                if (!File.Exists(_historyFilePath)) return;
+                var json = File.ReadAllText(_historyFilePath);
+                var history = JsonSerializer.Deserialize<ObservableCollection<AiResponse>>(json);
+                if (history == null) return;
+                foreach (var response in history)
+                    AiResponseHistory.Add(response);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error loading history: {ex.Message}");
+            }
         }
-    }
 
-    private void OnCopySentence()
-    {
-        if (!string.IsNullOrEmpty(ConstructedSentence))
+        private void ClearHistory()
         {
-            CopyToClipboard(ConstructedSentence);
+            AiResponseHistory.Clear();
+            SaveHistory();
         }
-    }
-
-    private void CopyToClipboard(string textToClipboard)
-    {
-        Dispatcher.UIThread.Post(() =>
-        {
-            switch (Application.Current?.ApplicationLifetime)
-            {
-                case IClassicDesktopStyleApplicationLifetime { MainWindow: { } window }:
-                    window.Clipboard?.SetTextAsync(textToClipboard);
-                    break;
-                case ISingleViewApplicationLifetime { MainView: { } mainView }:
-                    if (mainView.GetVisualRoot() is TopLevel topLevel)
-                        topLevel.Clipboard?.SetTextAsync(textToClipboard);
-                    break;
-                default:
-                    Console.WriteLine("Clipboard nie jest dostępny.");
-                    break;
-            }
-        });
-    }
 
-    private void AddAiResponseToHistory(string response)
-    {
-        if (string.IsNullOrWhiteSpace(response)) return;
-        AiResponseHistory.Add(new AiResponse(response));
-        SaveHistory();
-    }
-
-    private readonly string _historyFilePath = Path.Combine(
-        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-        "ChatAAC",
-        "ai_response_history.json");
+        #endregion
 
-    private void SaveHistory()
-    {
-        try
-        {
-            var directory = Path.GetDirectoryName(_historyFilePath);
-            if (!Directory.Exists(directory) && directory != null)
-                Directory.CreateDirectory(directory);
-
-            var options = new JsonSerializerOptions { WriteIndented = true };
-            var json = JsonSerializer.Serialize(AiResponseHistory, options);
-            File.WriteAllText(_historyFilePath, json);
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Błąd podczas zapisywania historii: {ex.Message}");
-        }
-    }
+        #region Settings
 
-    private void LoadHistory()
-    {
-        try
+        private void OpenSettings()
         {
-            if (!File.Exists(_historyFilePath)) return;
-            var json = File.ReadAllText(_historyFilePath);
-            var history = JsonSerializer.Deserialize<ObservableCollection<AiResponse>>(json);
-            if (history == null) return;
-            foreach (var response in history)
-                AiResponseHistory.Add(response);
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Błąd podczas ładowania historii: {ex.Message}");
+            var configWindow = new ConfigWindow
+            {
+                DataContext = new ConfigViewModel()
+            };
+            var mainWindow = (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)
+                ?.MainWindow;
+            if (mainWindow != null)
+                configWindow.ShowDialog(mainWindow);
+            else
+                configWindow.Show();
         }
-    }
 
-    private void ClearHistory()
-    {
-        AiResponseHistory.Clear();
-        SaveHistory();
+        #endregion
     }
 }
\ No newline at end of file
diff --git a/ChatAAC/Views/MainWindow.axaml b/ChatAAC/Views/MainWindow.axaml
index d1cf786..f46130f 100644
--- a/ChatAAC/Views/MainWindow.axaml
+++ b/ChatAAC/Views/MainWindow.axaml
@@ -18,12 +18,15 @@
     <Window.Styles>
         <!-- Styl dla przycisków symboli -->
         <Style Selector="Button.symbol">
-            <Setter Property="Width" Value="120" />
-            <Setter Property="Height" Value="120" />
-            <Setter Property="CornerRadius" Value="10" />
+            <Setter Property="MinWidth" Value="120" />
+            <Setter Property="MinHeight" Value="120" />
+            <Setter Property="HorizontalAlignment" Value="Stretch" />
+            <Setter Property="VerticalAlignment" Value="Stretch" />
             <Setter Property="Margin" Value="5" />
-            <Setter Property="BorderBrush" Value="Transparent" />
-            <Setter Property="BorderThickness" Value="0" />
+            <Setter Property="Padding" Value="5" />
+            <Setter Property="BorderBrush" Value="Gray" />
+            <Setter Property="BorderThickness" Value="1" />
+            <Setter Property="CornerRadius" Value="10" />
         </Style>
 
         <Style Selector="Button.action">
@@ -37,7 +40,7 @@
                 <ScaleTransform ScaleX="1.05" ScaleY="1.05" />
             </Setter>
         </Style>
-        
+
         <!-- Styl dla przycisków kontrolnych -->
         <Style Selector="Button.control">
             <Setter Property="CornerRadius" Value="5" />
@@ -67,7 +70,7 @@
                             <Image
                                 Source="{Binding Image.ImagePath, Converter={StaticResource StringToBitmapConverter}}"
                                 Width="80" Height="80" Margin="5"
-                                AutomationProperties.HelpText="{Binding Label, StringFormat='Wybrany piktogram: {0}'}"/>
+                                AutomationProperties.HelpText="{Binding Label, StringFormat='Wybrany piktogram: {0}'}" />
                         </DataTemplate>
                     </ItemsControl.ItemTemplate>
                 </ItemsControl>
@@ -77,57 +80,55 @@
         <!-- Main Content Grid -->
         <Grid Grid.Row="2" ColumnDefinitions="*,Auto">
             <!-- Symbols Grid -->
-            <ScrollViewer Grid.Column="0">
+            <Viewbox Grid.Column="0" Stretch="Uniform" UseLayoutRounding="True">
                 <ItemsControl ItemsSource="{Binding Buttons}">
                     <ItemsControl.ItemsPanel>
                         <ItemsPanelTemplate>
-                            <WrapPanel />
+                            <UniformGrid Columns="{Binding GridColumns}" Rows="{Binding GridRows}" />
                         </ItemsPanelTemplate>
                     </ItemsControl.ItemsPanel>
                     <ItemsControl.ItemTemplate>
-                        <DataTemplate>
-                            <Button x:DataType="obf:Button" x:CompileBindings="False"
-                                    Background="{Binding BackgroundColor, Converter={StaticResource ColorConverter}}"
+                        <DataTemplate x:DataType="vm:ButtonViewModel">
+                            <Button x:CompileBindings="False"
+                                    Background="{Binding Button.BackgroundColor, Converter={StaticResource ColorConverter}}"
                                     Command="{Binding DataContext.ButtonClickedCommand, RelativeSource={RelativeSource AncestorType=Window}}"
-                                    Width="{Binding Width}"
-                                    Height="{Binding Height}"
                                     Classes="symbol"
-                                    AutomationProperties.HelpText="{Binding Label}"
+                                    AutomationProperties.HelpText="{Binding Button.Label}"
                                     Focusable="True"
-                                    local:ButtonStyleHelper.Action="{Binding LoadBoard}"
-                                    CommandParameter="{Binding}">
+                                    local:ButtonStyleHelper.Action="{Binding Button.LoadBoard}"
+                                    CommandParameter="{Binding Button}">
                                 <StackPanel>
-                                    <TextBlock Text="{Binding Label}" HorizontalAlignment="Center" FontSize="14" Margin="0,5,0,0" />
-                                    <Image Source="{Binding Image.ImagePath, Converter={StaticResource StringToBitmapConverter}}"
-                                           Width="{Binding Width}"
-                                           Height="{Binding Height}"
-                                           AutomationProperties.HelpText ="{Binding Label}"/>
+                                    <TextBlock Text="{Binding Button.Label}" HorizontalAlignment="Center" FontSize="14"
+                                               Margin="0,5,0,0" />
+                                    <Image
+                                        Source="{Binding Button.Image.ImagePath, Converter={StaticResource StringToBitmapConverter}}"
+                                        AutomationProperties.HelpText="{Binding Button.Label}" />
                                 </StackPanel>
                             </Button>
                         </DataTemplate>
                     </ItemsControl.ItemTemplate>
                 </ItemsControl>
-            </ScrollViewer>
+            </Viewbox>
 
             <!-- Side Panel -->
             <StackPanel Grid.Column="1" Width="200" Margin="20,0,0,0" Spacing="10">
                 <!-- Grammar Controls -->
                 <Border BorderBrush="Gray" BorderThickness="1" CornerRadius="10" Padding="10">
                     <StackPanel Spacing="10">
-                        <TextBlock Text="Ustawienia Gramatyczne" FontWeight="Bold" FontSize="16" 
+                        <TextBlock Text="Ustawienia Gramatyczne" FontWeight="Bold" FontSize="16"
                                    AutomationProperties.Name="Ustawienia gramatyczne" />
 
                         <!-- Tense Selection -->
                         <StackPanel>
                             <TextBlock Text="Czas:" FontSize="14" />
                             <StackPanel Orientation="Vertical" Spacing="5">
-                                <RadioButton Content="Teraźniejszy" 
+                                <RadioButton Content="Teraźniejszy"
                                              IsChecked="{Binding SelectedTense, Converter={StaticResource EqualityConverter}, ConverterParameter=Teraźniejszy}"
                                              AutomationProperties.Name="Czas teraźniejszy" />
-                                <RadioButton Content="Przeszły" 
+                                <RadioButton Content="Przeszły"
                                              IsChecked="{Binding SelectedTense, Converter={StaticResource EqualityConverter}, ConverterParameter=Przeszły}"
                                              AutomationProperties.Name="Czas przeszły" />
-                                <RadioButton Content="Przyszły" 
+                                <RadioButton Content="Przyszły"
                                              IsChecked="{Binding SelectedTense, Converter={StaticResource EqualityConverter}, ConverterParameter=Przyszły}"
                                              AutomationProperties.Name="Czas przyszły" />
                             </StackPanel>
@@ -137,10 +138,10 @@
                         <StackPanel>
                             <TextBlock Text="Forma:" FontSize="14" />
                             <StackPanel Orientation="Vertical" Spacing="5">
-                                <RadioButton Content="Oznajmująca" 
+                                <RadioButton Content="Oznajmująca"
                                              IsChecked="{Binding SelectedForm, Converter={StaticResource EqualityConverter}, ConverterParameter=Oznajmująca}"
                                              AutomationProperties.Name="Forma oznajmująca" />
-                                <RadioButton Content="Pytająca" 
+                                <RadioButton Content="Pytająca"
                                              IsChecked="{Binding SelectedForm, Converter={StaticResource EqualityConverter}, ConverterParameter=Pytająca}"
                                              AutomationProperties.Name="Forma pytająca" />
                             </StackPanel>
@@ -150,39 +151,40 @@
 
                 <!-- Control Buttons -->
                 <StackPanel Spacing="10">
-                    <Button Content="Poprzednia Tablica" Classes="control" Background="#FFC107" 
-                            Command="{Binding PreviousBoardCommand}" 
+                    <Button Content="Poprzednia Tablica" Classes="control" Background="#FFC107"
+                            Command="{Binding PreviousBoardCommand}"
                             HorizontalContentAlignment="Stretch" Width="200" Height="50"
                             AutomationProperties.Name="Przycisk poprzedniej tablicy" />
 
-                    <Button Content="Następna Tablica" Classes="control" Background="#03A9F4" 
-                            Command="{Binding NextBoardCommand}" 
+                    <Button Content="Następna Tablica" Classes="control" Background="#03A9F4"
+                            Command="{Binding NextBoardCommand}"
                             HorizontalContentAlignment="Stretch" Width="200" Height="50"
                             AutomationProperties.Name="Przycisk następnej tablicy" />
-                    
-                    <Button Content="Powrót" Classes="control" Background="#2196F3" 
-                            Command="{Binding LoadMainBoardCommand}" 
+
+                    <Button Content="Powrót" Classes="control" Background="#2196F3"
+                            Command="{Binding LoadMainBoardCommand}"
                             HorizontalContentAlignment="Stretch" Width="200" Height="100"
                             AutomationProperties.Name="Przycisk powrotu do głównego widoku" />
-                    <Button Content="Wyczyść" Classes="control" Background="#4CAF50" 
-                            Command="{Binding ClearSelectedCommand}" 
+                    <Button Content="Wyczyść" Classes="control" Background="#4CAF50"
+                            Command="{Binding ClearSelectedCommand}"
                             HorizontalContentAlignment="Stretch" Width="200" Height="100"
                             AutomationProperties.Name="Przycisk wyczyść wybrane piktogramy" />
-                    <Button Content="Ustawienia" Classes="control" Background="#9C27B0" 
-                            Command="{Binding OpenSettingsCommand}" 
+                    <Button Content="Ustawienia" Classes="control" Background="#9C27B0"
+                            Command="{Binding OpenSettingsCommand}"
                             HorizontalContentAlignment="Stretch" Width="200" Height="100"
                             AutomationProperties.Name="Przycisk otwarcia ustawień" />
                 </StackPanel>
             </StackPanel>
         </Grid>
-        
+
         <!-- Indykator Ładowania -->
         <Border Grid.Row="0" Background="#80000000"
                 IsVisible="{Binding IsLoading}"
                 IsHitTestVisible="{Binding IsLoading}">
-            <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center" >
-                <ProgressBar IsIndeterminate="True" Width="200" Height="20"/>
-                <TextBlock Text="Ładowanie..." Foreground="White" FontSize="16" Margin="10,10,0,0" HorizontalAlignment="Center"/>
+            <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
+                <ProgressBar IsIndeterminate="True" Width="200" Height="20" />
+                <TextBlock Text="Ładowanie..." Foreground="White" FontSize="16" Margin="10,10,0,0"
+                           HorizontalAlignment="Center" />
             </StackPanel>
         </Border>
     </Grid>
diff --git a/ChatAAC/obj/Debug/net8.0/ChatAAC.AssemblyInfo.cs b/ChatAAC/obj/Debug/net8.0/ChatAAC.AssemblyInfo.cs
index 3fb5c9a..fcf659b 100644
--- a/ChatAAC/obj/Debug/net8.0/ChatAAC.AssemblyInfo.cs
+++ b/ChatAAC/obj/Debug/net8.0/ChatAAC.AssemblyInfo.cs
@@ -13,7 +13,7 @@
 [assembly: System.Reflection.AssemblyCompanyAttribute("ChatAAC")]
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+1207864c0e78abfae0c22d69c0a2a8a9e023684a")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+a26ef6339e1218527925af0375570d12f74caba4")]
 [assembly: System.Reflection.AssemblyProductAttribute("ChatAAC")]
 [assembly: System.Reflection.AssemblyTitleAttribute("ChatAAC")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]