diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f0a3ef0..ed7114e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,16 +1,12 @@
 name: Wails Build
 
 on:
+  # Only run on version tags (releases)
   push:
-    branches:
-      - main
-      - master
     tags:
       - 'v*'
-  pull_request:
-    branches:
-      - main
-      - master
+  # Allow manual trigger
+  workflow_dispatch:
 
 env:
   # Necessary for most environments
@@ -69,9 +65,21 @@ jobs:
           fi
         shell: bash
 
-      # Optional: Upload build artifacts
+      # Upload build artifacts
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: Wails-Build-${{ matrix.os }}
+          name: Wails-Build-${{ matrix.os }}-${{ github.ref_name }}
           path: build/bin/*
+
+      # Create Release and upload assets (only on tags)
+      - name: Create Release
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: softprops/action-gh-release@v1
+        with:
+          files: build/bin/*
+          draft: false
+          prerelease: false
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..d227f7a
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,90 @@
+name: Tests & Build Verification
+
+on:
+  pull_request:
+    branches:
+      - main
+      - master
+    paths:
+      - '**.go'
+      - 'go.mod'
+      - 'go.sum'
+      - '**.js'
+      - '**.jsx'
+      - '**.ts'
+      - '**.tsx'
+      - 'package.json'
+      - 'bun.lockb'
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - '**.go'
+      - 'go.mod'
+      - 'go.sum'
+      - '**.js'
+      - '**.jsx'
+      - '**.ts'
+      - '**.tsx'
+      - 'package.json'
+      - 'bun.lockb'
+
+jobs:
+  go-tests:
+    name: Go Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24.0'
+          check-latest: true
+
+      - name: Download Dependencies
+        run: go mod download
+
+      - name: Run Go Tests
+        run: go test ./internal/converter/... -v -race
+
+      - name: Run Tests with Coverage
+        run: go test ./internal/converter/... -coverprofile=coverage.out
+
+      - name: Upload Coverage Report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage.out
+
+  frontend-build:
+    name: Frontend Build (Bun)
+    runs-on: ubuntu-latest
+    needs: go-tests
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install Dependencies
+        run: bun install
+
+      - name: Build Web Application
+        run: bun run build
+
+      - name: Verify Build Output
+        run: |
+          if [ ! -d "dist" ]; then
+            echo "Error: dist directory not found after build"
+            exit 1
+          fi
+          echo "Build successful - dist directory created"
+          ls -la dist/
diff --git a/README.md b/README.md
index 1100b22..80e916a 100644
--- a/README.md
+++ b/README.md
@@ -1,118 +1,110 @@
 # Developer Toolbox
 
-## Overview
+[![Tests & Build](https://github.com/vuon9/dev-toolbox/actions/workflows/tests.yml/badge.svg)](https://github.com/vuon9/dev-toolbox/actions/workflows/tests.yml)
+[![Wails Build](https://github.com/vuon9/dev-toolbox/actions/workflows/build.yml/badge.svg)](https://github.com/vuon9/dev-toolbox/actions/workflows/build.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Go Version](https://img.shields.io/badge/Go-1.24+-00ADD8?style=flat&logo=go&logoColor=white)](https://go.dev)
 
-The **Developer Toolbox** is a modern, lightweight web‑based utility suite for developers. It bundles a collection of everyday tools—JSON/YAML/CSV conversion, Base64 encoding/decoding, UUID/ULID generation, QR code creation, JWT debugging, code formatting, Lorem Ipsum generation, and many more—into a single, cohesive UI.
+A modern, all-in-one desktop application for developers featuring 40+ utilities for encoding, encryption, hashing, and data format conversions.
 
-All UI components are built with the **Carbon Design System** (`@carbon/react`) to ensure a consistent, accessible, and premium look across the entire application. The app supports dark, light, and system‑preferred themes and includes a theme‑switcher in the top‑right corner.
-
-> **Why this toolbox?**
-> - No need to install a dozen separate CLI tools.
-> - Works offline in a desktop‑like environment powered by **Wails** (Go + Vite + React).
-> - Extensible: new tools can be added by simply creating a React component that follows the UI conventions.
-
----
+![Developer Toolbox Screenshot](screenshot.png)
 
 ## Features
 
-| Category | Tool | Description |
-|----------|------|-------------|
-| **Data Conversion** | **Data Converter** | Convert between JSON, YAML, CSV, and PHP array formats. |
-| | **CSV ↔ JSON** | Convert CSV files to JSON and vice‑versa. |
-| **Encoding / Decoding** | **Base64 Converter** | Encode/decode text and images to/from Base64. |
-| | **URL Tools** | Parse URLs, encode/decode components. |
-| **Generators** | **UUID / ULID Generator** | Generate random UUID v4 or ULID values. |
-| | **Lorem Ipsum Generator** | Produce placeholder paragraphs, sentences, or words. |
-| | **QR Code Generator** | Generate QR codes from arbitrary text/URLs with preview and download. |
-| **Debuggers** | **JWT Debugger** | Decode JWT header and payload, view errors. |
-| **Formatters** | **Code Formatter** | Beautify HTML, CSS, JavaScript, XML. |
-| | **JSON Formatter** | Pretty‑print or minify JSON. |
-| | **Hex / ASCII Converter** | Convert between hexadecimal strings and ASCII text. |
-| **Utilities** | **String Inspector** | Show character, word, line, byte, and sentence counts. |
-| | **Line Sort / Dedupe** | Sort, deduplicate, trim, reverse lists of lines. |
-| | **Hash Generator** | Compute MD5, SHA‑1, SHA‑256, SHA‑512 hashes. |
-| | **Random String Generator** | Generate random alphanumeric strings. |
-| | **Uuid Generator** | Generate UUIDs and ULIDs. |
-| | **...** | Additional tools can be found in the sidebar.
-
----
-
-## Installation & Running
-
-### Prerequisites
-- **Node.js** (>= 18)
-- **Go** (>= 1.22)
-- **Wails** CLI (`go install github.com/wailsapp/wails/v2/cmd/wails@latest`)
-
-### Steps
+### **Text Based Converter** (Unified Tool)
+The central hub with 40+ algorithms across 4 categories:
+
+| Category | Algorithms |
+|----------|------------|
+| **🔐 Encrypt / Decrypt** | AES, AES-GCM, DES, Triple DES, ChaCha20, Salsa20, XOR, RC4 |
+| **🔀 Encode / Decode** | Base64, Base64URL, Base32, Base58, Base16 (Hex), URL, HTML Entities, Binary, Morse Code, ROT13, ROT47, Quoted-Printable |
+| **🔄 Convert** | JSON ↔ YAML, JSON ↔ XML, JSON ↔ CSV, YAML ↔ TOML, Markdown ↔ HTML, CSV ↔ TSV, Properties ↔ JSON, INI ↔ JSON, Key-Value ↔ Query String, Number Bases, Case Swapping |
+| **#️⃣ Hash** | MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-3, BLAKE2b, BLAKE3, RIPEMD-160, bcrypt, scrypt, Argon2, HMAC, CRC32, Adler-32, MurmurHash3, xxHash, FNV-1a |
+
+**Special Features:**
+- **"All Hashes" view** - Compute all 19 hash algorithms at once with copy buttons for each
+- **Smart key/IV detection** - Automatically shows configuration pane when needed
+- **Auto-run mode** - Results update instantly as you type
+- **Horizontal/Vertical layout toggle** - Customize the workspace layout
+
+### **Other Tools**
+
+| Tool | Description |
+|------|-------------|
+| **JWT Debugger** | Decode and verify JWT tokens with header/payload inspection |
+| **UUID / ULID Generator** | Generate random UUID v4 or ULID values |
+| **QR Code Generator** | Create QR codes from text/URLs with preview and download |
+| **JSON Formatter** | Pretty-print or minify JSON with syntax validation |
+| **Code Formatter** | Beautify HTML, CSS, JavaScript, XML |
+| **RegExp Tester** | Test regular expressions with real-time matching |
+| **Unix Time Converter** | Convert between Unix timestamps and human-readable dates |
+| **Color Converter** | Convert between HEX, RGB, HSL, and other color formats |
+| **SQL Formatter** | Format SQL queries with proper indentation |
+| **String Case Converter** | Convert between camelCase, snake_case, PascalCase, etc. |
+| **Cron Job Parser** | Parse and explain cron expressions |
+| **Text Diff Checker** | Compare two text blocks and highlight differences |
+| **Line Sort / Dedupe** | Sort lines, remove duplicates, trim whitespace |
+| **String Inspector** | Count characters, words, lines, bytes, and sentences |
+| **Lorem Ipsum Generator** | Generate placeholder text |
+| **Random String Generator** | Generate random alphanumeric strings with custom length |
+| **HTML Preview** | Preview HTML rendering in real-time |
+| **Markdown Preview** | Render Markdown with live preview |
+| **Backslash Escaper** | Escape/unescape backslash characters |
+| **PHP Serializer** | PHP serialization/unserialization |
+| **URL Tools** | Parse URLs, extract components |
+
+## Installation
+
+### Download Pre-built Binaries
+Download the latest release for your platform from the [Releases](https://github.com/your-org/dev-toolbox/releases) page.
+
+**Supported Platforms:**
+- Windows (x64)
+- macOS (Intel & Apple Silicon)
+- Linux (x64)
+
+### Build from Source
+
+**Prerequisites:**
+- Node.js (>= 18)
+- Go (>= 1.22)
+- Wails CLI: `go install github.com/wailsapp/wails/v2/cmd/wails@latest`
+
+**Build Steps:**
 ```bash
 # Clone the repository
 git clone https://github.com/your-org/dev-toolbox.git
 cd dev-toolbox
 
-# Install frontend dependencies
-cd frontend
-npm install
+# Install dependencies and build
+wails build
 
-# Build & run the desktop app (Wails)
-cd ..
-wails dev   # development mode with hot‑reload
-# or
-wails build # production binary
+# Or run in development mode
+wails dev
 ```
 
-The app will open in a native window. The UI works offline; no external API calls are required.
+## Key Features
 
----
+✅ **Works Offline** - All tools run locally, no internet connection required  
+✅ **Dark/Light Themes** - Switch between themes or use system preference  
+✅ **Pin Tools** - Pin frequently used tools to the top of the sidebar  
+✅ **Keyboard Shortcuts** - `Cmd/Ctrl + B` to toggle sidebar  
+✅ **Copy to Clipboard** - One-click copy buttons on all output fields  
+✅ **Auto-run** - See results instantly as you type (can be disabled)  
+✅ **Responsive Layout** - Horizontal or vertical split panes  
 
-## Project Structure
-```
-dev-toolbox/
-├─ frontend/                # React + Vite source
-│   ├─ src/
-│   │   ├─ components/      # Shared UI helpers (ToolUI, Sidebar, etc.)
-│   │   ├─ tools/           # Individual tool components
-│   │   ├─ App.jsx           # Root component, Theme provider, routing
-│   │   └─ index.scss        # Global Carbon style overrides
-│   └─ vite.config.js       # Vite config with Sass deprecation suppression
-├─ backend/ (Go)            # Wails bridge, main entry point
-│   ├─ main.go
-│   └─ app.go
-└─ AGENTS.md                # Design principles & UI guidelines (auto‑generated)
-```
+## UI Design
 
----
-
-## UI / Design Guidelines (see `AGENTS.md`)
-- **All components must use Carbon React components** (Button, TextArea, Select, Tabs, etc.).
-- **TextAreas** for both input and output share the same style: monospace font, identical height, visible border, and a copy‑to‑clipboard button that is always shown next to the label.
-- **Buttons** placed on the same line have a 1 rem gap and are grouped in a dedicated `ToolControls` area.
-- **Labels** use Carbon’s label style (uppercase, small, secondary text color).
-- **Theme switching** is available via the Settings overflow menu (System / Dark / Light).
-- **Copy button** is positioned beside the pane label and never hidden.
-
----
-
-## Adding a New Tool
-1. Create a new component under `src/tools/`.
-2. Wrap the UI with the shared helpers from `src/components/ToolUI.jsx` (`ToolHeader`, `ToolControls`, `ToolPane`, `ToolSplitPane`).
-3. Export the component and add a route entry in `src/App.jsx`.
-4. Follow the UI rules in `AGENTS.md` to keep the look consistent.
-
----
-
-## Contributing
-- Fork the repo and create a feature branch.
-- Run `npm run lint` and `npm run format` before committing.
-- Ensure any new UI respects the Carbon design system and the rules in `AGENTS.md`.
-- Open a pull request with a clear description of the added functionality.
-
----
+Built with **Carbon Design System** for a consistent, professional look:
+- Clean, modern interface
+- Accessible components
+- Consistent spacing and typography
+- Monospace fonts for code/data
 
 ## License
 
-MIT License – feel free to use, modify, and distribute.
+MIT License - free to use, modify, and distribute.
 
 ---
 
-*Built with ❤️ and 🤖.*
\ No newline at end of file
+*Built with ❤️ using Go, React, and Wails.*
diff --git a/TOOL_STATUS.md b/TOOL_STATUS.md
index 4bf57d7..dad5b11 100644
--- a/TOOL_STATUS.md
+++ b/TOOL_STATUS.md
@@ -16,23 +16,16 @@ This document tracks the refactoring and development status of each tool compone
 | Tool | Status | Notes | Last Updated |
 |------|--------|-------|--------------|
 | JwtDebugger | 🟢 Done | Uses component abstraction system (ToolLayout, ToolTextArea, ToolInputGroup), toggleable layout, consistent button styling with icons (MagicWand, Security, Code), enhanced tabs (custom mode tabs, improved JSON/Claims tabs), resizable textareas with constraints, proper error handling | Completed 2026-01-25 |
-| **TextBasedConverter** | 🟡 In Progress | Unified tool for all encoding, encryption, hashing, and format conversions. Smart ConfigurationPane adapts to algorithm requirements. Backend uses hierarchical structure (`internal/converter/`). Comprehensive unit tests. Implements 40+ algorithms across 4 categories. **Replaces**: Base64Converter, HashGenerator, HexAsciiConverter, HtmlEntityConverter, UrlEncoder, NumberBaseConverter, YamlToJson, CsvJsonConverter | Started 2026-01-25 |
+| **TextBasedConverter** | 🟢 Done | Unified tool for all encoding, encryption, hashing, and format conversions. Smart ConfigurationPane adapts to algorithm requirements. Backend uses hierarchical structure (`internal/converter/`). Comprehensive unit tests. Implements 40+ algorithms across 4 categories | Completed 2026-01-31 |
 | BackslashEscaper | 🔴 Not Started | Legacy implementation | - |
-| Base64Converter | ⚫ Deprecated | **Replaced by TextBasedConverter** (Encode - Decode → Base64) | - |
 | CodeFormatter | 🔴 Not Started | Legacy implementation | - |
 | ColorConverter | 🔴 Not Started | Legacy implementation | - |
 | CronJobParser | 🔴 Not Started | Legacy implementation | - |
-| CsvJsonConverter | ⚫ Deprecated | **Replaced by TextBasedConverter** (Convert → JSON ↔ CSV / TSV) | - |
-| DataConverter | 🔴 Not Started | Legacy implementation | - |
-| HashGenerator | ⚫ Deprecated | **Replaced by TextBasedConverter** (Hash → MD5, SHA-1, SHA-256, etc.) | - |
-| HexAsciiConverter | ⚫ Deprecated | **Replaced by TextBasedConverter** (Encode - Decode → Base16 (Hex)) | - |
-| HtmlEntityConverter | ⚫ Deprecated | **Replaced by TextBasedConverter** (Encode - Decode → HTML Entities) | - |
 | HtmlPreview | 🔴 Not Started | Legacy implementation | - |
 | JsonFormatter | 🔴 Not Started | Legacy implementation | - |
 | LineSortDedupe | 🔴 Not Started | Legacy implementation | - |
 | LoremIpsumGenerator | 🔴 Not Started | Legacy implementation | - |
 | MarkdownPreview | 🔴 Not Started | Legacy implementation | - |
-| NumberBaseConverter | ⚫ Deprecated | **Replaced by TextBasedConverter** (Convert → Number Bases) | - |
 | PhpJsonConverter | 🔴 Not Started | Legacy implementation | - |
 | PhpSerializer | 🔴 Not Started | Legacy implementation | - |
 | QrCodeGenerator | 🔴 Not Started | Legacy implementation | - |
@@ -43,27 +36,59 @@ This document tracks the refactoring and development status of each tool compone
 | StringInspector | 🔴 Not Started | Legacy implementation | - |
 | TextDiffChecker | 🔴 Not Started | Legacy implementation | - |
 | UnixTimeConverter | 🔴 Not Started | Legacy implementation | - |
-| UrlEncoder | ⚫ Deprecated | **Replaced by TextBasedConverter** (Encode - Decode → URL) | - |
 | UrlParser | 🔴 Not Started | Legacy implementation | - |
 | UrlTools | 🔴 Not Started | Legacy implementation | - |
 | UuidGenerator | 🔴 Not Started | Legacy implementation | - |
-| YamlToJson | ⚫ Deprecated | **Replaced by TextBasedConverter** (Convert → JSON ↔ YAML) | - |
 
 ---
 
 ## Last tool tasks
 
-### Text-based Converter
-
-- [ ] Implement remaining encryption algorithms (DES, Triple DES, ChaCha20, Salsa20, Blowfish, etc.)
-- [ ] Implement remaining encoding algorithms (Base85, Punnycode, JWT Decode, Bencoded, Protobuf)
-- [ ] Implement remaining conversion features (XML, TOML, Color codes, Timestamp, CURL, Cron)
-- [ ] Implement remaining hashing algorithms (BLAKE3, scrypt, Argon2, HMAC with UI, MurmurHash)
-- [ ] Add copy buttons to ConfigurationPane for sample values
-- [ ] Consider adding "Generate Random Key" button for encryption
-- [ ] Full browser testing with real Wails app (not test server)
-- [ ] Consider removing deprecated tools from codebase
-- [ ] Remove all deprecated tools after having functionality working well
+### Text-based Converter - Implementation Status
+
+#### ✅ **COMPLETED**
+
+**Encryption (8 algorithms):**
+- ✅ AES, AES-GCM, DES, Triple DES, ChaCha20, Salsa20, XOR, RC4
+
+**Encoding (12 algorithms):**
+- ✅ Base16 (Hex), Base32, Base58, Base64, Base64URL, URL, HTML Entities, Binary, Morse Code, ROT13, ROT47, Quoted-Printable
+
+**Conversion (11 formats):**
+- ✅ JSON ↔ YAML, JSON ↔ XML, JSON ↔ CSV / TSV, YAML ↔ TOML, Markdown ↔ HTML, CSV ↔ TSV, Key-Value ↔ Query String, Number Bases, Case Swapping, Properties ↔ JSON, INI ↔ JSON
+
+**Hashing (19 algorithms + All view):**
+- ✅ MD5, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-3 (Keccak), BLAKE2b, BLAKE3, RIPEMD-160, bcrypt, scrypt, Argon2, HMAC, CRC32, Adler-32, MurmurHash3, xxHash, FNV-1a
+- ✅ "All" hash view with grid display of all algorithms
+
+**Features:**
+- ✅ Comprehensive unit tests (56 test cases)
+- ✅ GitHub Actions CI/CD for Go tests
+- ✅ Removed deprecated tools from codebase
+
+---
+
+#### ⏳ **PENDING IMPLEMENTATION**
+
+The following algorithms are listed in CONVERTER_MAP but **not yet implemented** in the backend:
+
+**Encryption (7 algorithms):**
+- ⏳ Rabbit, RC4Drop, Blowfish, Twofish, RSA, Fernet, BIP38
+
+**Encoding (5 algorithms):**
+- ⏳ Base85, Punnycode, JWT Decode, Bencoded, Protobuf
+
+**Conversion (5 formats):**
+- ⏳ Unix Timestamp ↔ ISO 8601 (exists but needs improvement)
+- ⏳ Color Codes (exists but needs improvement)
+- ⏳ SQL Insert ↔ JSON Array
+- ⏳ CURL Command ↔ Fetch
+- ⏳ Cron Expression ↔ Text
+
+**UI Improvements:**
+- ⏳ Add copy buttons to ConfigurationPane for sample values
+- ⏳ Consider adding "Generate Random Key" button for encryption
+- ⏳ Full browser testing with real Wails app (not test server)
 
 ---
 
diff --git a/internal/converter/converter_test.go b/internal/converter/converter_test.go
index c66a7d5..1ade475 100644
--- a/internal/converter/converter_test.go
+++ b/internal/converter/converter_test.go
@@ -1,6 +1,7 @@
 package converter
 
 import (
+	"encoding/json"
 	"strings"
 	"testing"
 )
@@ -24,6 +25,25 @@ func TestEncodingConverter(t *testing.T) {
 		{"URL Encode", "hello world", "url", "Encode", "hello+world"},
 		{"HTML Encode", "<script>", "html entities", "Encode", "&lt;script&gt;"},
 		{"Morse Encode", "SOS", "morse code", "Encode", "... --- ..."},
+		// ROT13 - symmetric encoding (encode and decode are the same)
+		{"ROT13 Encode Hello", "hello", "rot13", "Encode", "uryyb"},
+		{"ROT13 Decode Uryyb", "uryyb", "rot13", "Decode", "hello"},
+		{"ROT13 Encode Test", "Test123!", "rot13", "Encode", "Grfg123!"},
+		{"ROT13 Decode Grfg", "Grfg123!", "rot13", "Decode", "Test123!"},
+		{"ROT13 Double Encode Roundtrip", "hello", "rot13", "Encode", "uryyb"}, // Double ROT13 should return original (encode once here)
+		// ROT47 - symmetric encoding (encode and decode are the same)
+		{"ROT47 Encode Hello", "hello", "rot47", "Encode", "96==@"},
+		{"ROT47 Decode 96==@", "96==@", "rot47", "Decode", "hello"},
+		{"ROT47 Encode Test123", "Test123!", "rot47", "Encode", "%6DE`abP"},
+		{"ROT47 Decode %6DE`abP", "%6DE`abP", "rot47", "Decode", "Test123!"},
+		// Quoted-Printable
+		{"Quoted-Printable Encode Simple", "hello world", "quoted-printable", "Encode", "hello world"},
+		{"Quoted-Printable Encode Special", "hello=world", "quoted-printable", "Encode", "hello=3Dworld"},
+		{"Quoted-Printable Encode Special Chars", "hello\tworld!", "quoted-printable", "Encode", "hello\tworld!"},
+		{"Quoted-Printable Decode Simple", "hello world", "quoted-printable", "Decode", "hello world"},
+		{"Quoted-Printable Decode Hex", "hello=3Dworld", "quoted-printable", "Decode", "hello=world"},
+		{"Quoted-Printable Decode Newline", "hello=0Aworld", "quoted-printable", "Decode", "hello\nworld"},
+		{"Quoted-Printable Decode Tab", "hello=09world", "quoted-printable", "Decode", "hello\tworld"},
 	}
 
 	for _, tt := range tests {
@@ -44,6 +64,103 @@ func TestEncodingConverter(t *testing.T) {
 	}
 }
 
+func TestEncodingConverterSymmetricRoundTrip(t *testing.T) {
+	conv := NewEncodingConverter()
+
+	// Test ROT13 round-trip (applying ROT13 twice returns original)
+	t.Run("ROT13 Double Application", func(t *testing.T) {
+		original := "Hello World! 123"
+		
+		// First ROT13
+		req1 := ConversionRequest{
+			Input:  original,
+			Method: "rot13",
+			Config: map[string]interface{}{"subMode": "Encode"},
+		}
+		encoded, err := conv.Convert(req1)
+		if err != nil {
+			t.Fatalf("First ROT13 error: %v", err)
+		}
+		
+		// Second ROT13 (decode is same as encode for ROT13)
+		req2 := ConversionRequest{
+			Input:  encoded,
+			Method: "rot13",
+			Config: map[string]interface{}{"subMode": "Decode"},
+		}
+		decoded, err := conv.Convert(req2)
+		if err != nil {
+			t.Fatalf("Second ROT13 error: %v", err)
+		}
+		
+		if decoded != original {
+			t.Errorf("ROT13 round-trip failed: expected '%s', got '%s'", original, decoded)
+		}
+	})
+
+	// Test ROT47 round-trip (applying ROT47 twice returns original)
+	t.Run("ROT47 Double Application", func(t *testing.T) {
+		original := "Hello World! 123"
+		
+		// First ROT47
+		req1 := ConversionRequest{
+			Input:  original,
+			Method: "rot47",
+			Config: map[string]interface{}{"subMode": "Encode"},
+		}
+		encoded, err := conv.Convert(req1)
+		if err != nil {
+			t.Fatalf("First ROT47 error: %v", err)
+		}
+		
+		// Second ROT47 (decode is same as encode for ROT47)
+		req2 := ConversionRequest{
+			Input:  encoded,
+			Method: "rot47",
+			Config: map[string]interface{}{"subMode": "Decode"},
+		}
+		decoded, err := conv.Convert(req2)
+		if err != nil {
+			t.Fatalf("Second ROT47 error: %v", err)
+		}
+		
+		if decoded != original {
+			t.Errorf("ROT47 round-trip failed: expected '%s', got '%s'", original, decoded)
+		}
+	})
+
+	// Test Quoted-Printable round-trip
+	t.Run("Quoted-Printable Round-Trip", func(t *testing.T) {
+		original := "Hello=World! Special chars: \t\n"
+		
+		// Encode
+		req1 := ConversionRequest{
+			Input:  original,
+			Method: "quoted-printable",
+			Config: map[string]interface{}{"subMode": "Encode"},
+		}
+		encoded, err := conv.Convert(req1)
+		if err != nil {
+			t.Fatalf("QP encode error: %v", err)
+		}
+		
+		// Decode
+		req2 := ConversionRequest{
+			Input:  encoded,
+			Method: "quoted-printable",
+			Config: map[string]interface{}{"subMode": "Decode"},
+		}
+		decoded, err := conv.Convert(req2)
+		if err != nil {
+			t.Fatalf("QP decode error: %v", err)
+		}
+		
+		if decoded != original {
+			t.Errorf("QP round-trip failed: expected '%s', got '%s'", original, decoded)
+		}
+	})
+}
+
 func TestHashingConverter(t *testing.T) {
 	conv := NewHashingConverter()
 
@@ -76,6 +193,59 @@ func TestHashingConverter(t *testing.T) {
 	}
 }
 
+func TestHashingConverterAdditional(t *testing.T) {
+	conv := NewHashingConverter()
+
+	tests := []struct {
+		name           string
+		input          string
+		method         string
+		expectedPrefix string
+		expectedLength int
+	}{
+		{"xxHash64 - hello", "hello", "xxhash", "", 16},
+		{"xxHash64 - empty", "", "xxhash", "", 16},
+		{"xxHash64 - long text", "The quick brown fox jumps over the lazy dog", "xxhash", "", 16},
+		{"FNV-1a - hello", "hello", "fnv-1a", "", 16},
+		{"FNV-1a - empty", "", "fnv-1a", "", 16},
+		{"FNV-1a - long text", "The quick brown fox jumps over the lazy dog", "fnv-1a", "", 16},
+		{"BLAKE3 - hello", "hello", "blake3", "", 64},
+		{"BLAKE3 - empty", "", "blake3", "", 64},
+		{"BLAKE3 - long text", "The quick brown fox jumps over the lazy dog", "blake3", "", 64},
+		{"MurmurHash3 - hello", "hello", "murmurhash3", "", 8},
+		{"MurmurHash3 - empty", "", "murmurhash3", "", 8},
+		{"MurmurHash3 - long text", "The quick brown fox jumps over the lazy dog", "murmurhash3", "", 8},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := ConversionRequest{
+				Input:  tt.input,
+				Method: tt.method,
+				Config: map[string]interface{}{},
+			}
+			result, err := conv.Convert(req)
+			if err != nil {
+				t.Errorf("Error: %v", err)
+				return
+			}
+
+			// Check that result is a valid hex string of expected length
+			if len(result) != tt.expectedLength {
+				t.Errorf("Expected result length %d, got %d (%s)", tt.expectedLength, len(result), result)
+			}
+
+			// Verify all characters are valid hex digits
+			for _, c := range result {
+				if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) {
+					t.Errorf("Result contains non-hex character: %c in %s", c, result)
+					break
+				}
+			}
+		})
+	}
+}
+
 func TestEncryptionConverter(t *testing.T) {
 	conv := NewEncryptionConverter()
 
@@ -153,6 +323,169 @@ func TestEncryptionConverter(t *testing.T) {
 	})
 }
 
+func TestEncryptionConverterAdditional(t *testing.T) {
+	conv := NewEncryptionConverter()
+
+	// Test cases for encryption/decryption round trips
+	tests := []struct {
+		name      string
+		method    string
+		key       string
+		iv        string
+		plaintext string
+	}{
+		{
+			name:      "AES-GCM Encrypt/Decrypt - simple text",
+			method:    "aes-gcm",
+			key:       "12345678901234567890123456789012", // 32 bytes
+			iv:        "123456789012",                       // 12 bytes nonce
+			plaintext: "hello world",
+		},
+		{
+			name:      "AES-GCM Encrypt/Decrypt - long text",
+			method:    "aes-gcm",
+			key:       "abcdefghijklmnopqrstuvwxyz123456", // 32 bytes
+			iv:        "nonce1234567",                       // 12 bytes
+			plaintext: "The quick brown fox jumps over the lazy dog! 1234567890",
+		},
+		{
+			name:      "AES-GCM Encrypt/Decrypt - empty text",
+			method:    "aes-gcm",
+			key:       "00000000000000000000000000000000", // 32 bytes
+			iv:        "000000000000",                       // 12 bytes
+			plaintext: "",
+		},
+		{
+			name:      "Triple DES Encrypt/Decrypt - simple text",
+			method:    "triple des",
+			key:       "123456789012345678901234", // 24 bytes
+			iv:        "12345678",                 // 8 bytes
+			plaintext: "hello123",
+		},
+		{
+			name:      "Triple DES Encrypt/Decrypt - 3des alias",
+			method:    "3des",
+			key:       "abcdefghabcdefghabcdefgh", // 24 bytes
+			iv:        "abcdefgh",                 // 8 bytes
+			plaintext: "test message",
+		},
+		{
+			name:      "Triple DES Encrypt/Decrypt - tripledes alias",
+			method:    "tripledes",
+			key:       "123456789012345678901234", // 24 bytes
+			iv:        "87654321",                 // 8 bytes
+			plaintext: "secret data here",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Encrypt
+			encReq := ConversionRequest{
+				Input:  tt.plaintext,
+				Method: tt.method,
+				Config: map[string]interface{}{
+					"subMode": "Encrypt",
+					"key":     tt.key,
+					"iv":      tt.iv,
+				},
+			}
+			encrypted, err := conv.Convert(encReq)
+			if err != nil {
+				t.Fatalf("Encryption error: %v", err)
+			}
+
+			if encrypted == "" && tt.plaintext != "" {
+				t.Fatal("Encryption produced empty result for non-empty input")
+			}
+
+			// Decrypt
+			decReq := ConversionRequest{
+				Input:  encrypted,
+				Method: tt.method,
+				Config: map[string]interface{}{
+					"subMode": "Decrypt",
+					"key":     tt.key,
+					"iv":      tt.iv,
+				},
+			}
+			decrypted, err := conv.Convert(decReq)
+			if err != nil {
+				t.Fatalf("Decryption error: %v", err)
+			}
+
+			if decrypted != tt.plaintext {
+				t.Errorf("Round-trip failed: expected '%s', got '%s'", tt.plaintext, decrypted)
+			}
+		})
+	}
+
+	// Test error cases for invalid key/IV lengths
+	t.Run("AES-GCM invalid key length", func(t *testing.T) {
+		req := ConversionRequest{
+			Input:  "test",
+			Method: "aes-gcm",
+			Config: map[string]interface{}{
+				"subMode": "Encrypt",
+				"key":     "short", // Invalid - too short
+				"iv":      "123456789012",
+			},
+		}
+		_, err := conv.Convert(req)
+		if err == nil {
+			t.Error("Expected error for invalid key length, got none")
+		}
+	})
+
+	t.Run("AES-GCM invalid nonce length", func(t *testing.T) {
+		req := ConversionRequest{
+			Input:  "test",
+			Method: "aes-gcm",
+			Config: map[string]interface{}{
+				"subMode": "Encrypt",
+				"key":     "12345678901234567890123456789012",
+				"iv":      "short", // Invalid - too short
+			},
+		}
+		_, err := conv.Convert(req)
+		if err == nil {
+			t.Error("Expected error for invalid nonce length, got none")
+		}
+	})
+
+	t.Run("Triple DES invalid key length", func(t *testing.T) {
+		req := ConversionRequest{
+			Input:  "test",
+			Method: "triple des",
+			Config: map[string]interface{}{
+				"subMode": "Encrypt",
+				"key":     "short", // Invalid - must be 24 bytes
+				"iv":      "12345678",
+			},
+		}
+		_, err := conv.Convert(req)
+		if err == nil {
+			t.Error("Expected error for invalid key length, got none")
+		}
+	})
+
+	t.Run("Triple DES invalid IV length", func(t *testing.T) {
+		req := ConversionRequest{
+			Input:  "test",
+			Method: "triple des",
+			Config: map[string]interface{}{
+				"subMode": "Encrypt",
+				"key":     "123456789012345678901234",
+				"iv":      "short", // Invalid - must be 8 bytes
+			},
+		}
+		_, err := conv.Convert(req)
+		if err == nil {
+			t.Error("Expected error for invalid IV length, got none")
+		}
+	})
+}
+
 func TestFormattingConverter(t *testing.T) {
 	conv := NewFormattingConverter()
 
@@ -186,3 +519,299 @@ func TestFormattingConverter(t *testing.T) {
 		}
 	})
 }
+
+func TestFormattingConverterAdditional(t *testing.T) {
+	conv := NewFormattingConverter()
+
+	// CSV to TSV and TSV to CSV tests
+	t.Run("CSV to TSV conversion", func(t *testing.T) {
+		csvInput := "name,age,city\nJohn,30,NYC\nJane,25,LA"
+		req := ConversionRequest{
+			Input:  csvInput,
+			Method: "csv ↔ tsv",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("CSV to TSV error: %v", err)
+		}
+
+		// Check that result uses tabs instead of commas
+		if strings.Contains(result, ",") {
+			t.Errorf("TSV output should not contain commas, got: %s", result)
+		}
+		if !strings.Contains(result, "\t") {
+			t.Errorf("TSV output should contain tabs, got: %s", result)
+		}
+		if !strings.Contains(result, "John\t30\tNYC") {
+			t.Errorf("Expected tab-separated values, got: %s", result)
+		}
+	})
+
+	t.Run("TSV to CSV conversion", func(t *testing.T) {
+		tsvInput := "name\tage\tcity\nJohn\t30\tNYC\nJane\t25\tLA"
+		req := ConversionRequest{
+			Input:  tsvInput,
+			Method: "csv ↔ tsv",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("TSV to CSV error: %v", err)
+		}
+
+		// Check that result uses commas
+		if !strings.Contains(result, ",") {
+			t.Errorf("CSV output should contain commas, got: %s", result)
+		}
+		if strings.Contains(result, "\t") {
+			t.Errorf("CSV output should not contain tabs, got: %s", result)
+		}
+		if !strings.Contains(result, "John,30,NYC") {
+			t.Errorf("Expected comma-separated values, got: %s", result)
+		}
+	})
+
+	// Key-Value to Query String tests
+	t.Run("Key-Value to Query String", func(t *testing.T) {
+		kvInput := "name=John\nage=30\ncity=NYC"
+		req := ConversionRequest{
+			Input:  kvInput,
+			Method: "key-value ↔ query string",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("Key-Value to Query String error: %v", err)
+		}
+
+		// Result should be URL encoded
+		if !strings.Contains(result, "name=John") {
+			t.Errorf("Expected 'name=John' in result, got: %s", result)
+		}
+		if !strings.Contains(result, "age=30") {
+			t.Errorf("Expected 'age=30' in result, got: %s", result)
+		}
+		if !strings.Contains(result, "&") {
+			t.Errorf("Expected '&' separator in query string, got: %s", result)
+		}
+	})
+
+	t.Run("Query String to Key-Value", func(t *testing.T) {
+		qsInput := "?name=John&age=30&city=NYC"
+		req := ConversionRequest{
+			Input:  qsInput,
+			Method: "key-value ↔ query string",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("Query String to Key-Value error: %v", err)
+		}
+
+		// Result should be one key-value pair per line
+		if !strings.Contains(result, "name=John") {
+			t.Errorf("Expected 'name=John' in result, got: %s", result)
+		}
+		if !strings.Contains(result, "\n") && !strings.Contains(result, "=") {
+			t.Errorf("Expected key-value format with newlines, got: %s", result)
+		}
+	})
+
+	// Properties to JSON and JSON to Properties tests
+	t.Run("Properties to JSON", func(t *testing.T) {
+		propsInput := "name=John\nage=30\ncity=NYC"
+		req := ConversionRequest{
+			Input:  propsInput,
+			Method: "properties",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("Properties to JSON error: %v", err)
+		}
+
+		// Result should be valid JSON
+		var parsed map[string]string
+		if err := json.Unmarshal([]byte(result), &parsed); err != nil {
+			t.Errorf("Result is not valid JSON: %v\nResult: %s", err, result)
+		}
+		if parsed["name"] != "John" {
+			t.Errorf("Expected name=John in parsed JSON, got: %v", parsed)
+		}
+	})
+
+	t.Run("JSON to Properties", func(t *testing.T) {
+		jsonInput := `{"name":"John","age":"30","city":"NYC"}`
+		req := ConversionRequest{
+			Input:  jsonInput,
+			Method: "properties",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("JSON to Properties error: %v", err)
+		}
+
+		// Result should be properties format
+		if !strings.Contains(result, "name=John") {
+			t.Errorf("Expected 'name=John' in properties, got: %s", result)
+		}
+		if !strings.Contains(result, "\n") {
+			t.Errorf("Expected multiple lines in properties, got: %s", result)
+		}
+	})
+
+	// INI to JSON and JSON to INI tests
+	t.Run("INI to JSON", func(t *testing.T) {
+		iniInput := "[section1]\nkey1=value1\nkey2=value2\n[section2]\nkey3=value3"
+		req := ConversionRequest{
+			Input:  iniInput,
+			Method: "ini",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("INI to JSON error: %v", err)
+		}
+
+		// Result should be valid JSON
+		var parsed map[string]map[string]string
+		if err := json.Unmarshal([]byte(result), &parsed); err != nil {
+			t.Errorf("Result is not valid JSON: %v\nResult: %s", err, result)
+		}
+		if parsed["section1"]["key1"] != "value1" {
+			t.Errorf("Expected section1.key1=value1 in parsed JSON, got: %v", parsed)
+		}
+	})
+
+	t.Run("JSON to INI", func(t *testing.T) {
+		jsonInput := `{"section1":{"key1":"value1","key2":"value2"},"section2":{"key3":"value3"}}`
+		req := ConversionRequest{
+			Input:  jsonInput,
+			Method: "ini",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("JSON to INI error: %v", err)
+		}
+
+		// Result should be INI format with section headers
+		if !strings.Contains(result, "[section1]") {
+			t.Errorf("Expected '[section1]' in INI output, got: %s", result)
+		}
+		if !strings.Contains(result, "key1=value1") {
+			t.Errorf("Expected 'key1=value1' in INI output, got: %s", result)
+		}
+	})
+
+	// JSON to XML and XML to JSON tests
+	t.Run("JSON to XML", func(t *testing.T) {
+		jsonInput := `{"name":"John","age":30}`
+		req := ConversionRequest{
+			Input:  jsonInput,
+			Method: "json ↔ xml",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("JSON to XML error: %v", err)
+		}
+
+		// Result should be valid XML
+		if !strings.Contains(result, "<?xml") {
+			t.Errorf("Expected XML declaration, got: %s", result)
+		}
+		if !strings.Contains(result, "<root>") {
+			t.Errorf("Expected root element, got: %s", result)
+		}
+		if !strings.Contains(result, "<name>") || !strings.Contains(result, "John") {
+			t.Errorf("Expected name element with value, got: %s", result)
+		}
+	})
+
+	t.Run("XML to JSON", func(t *testing.T) {
+		xmlInput := `<?xml version="1.0"?><person><name>John</name><age>30</age></person>`
+		req := ConversionRequest{
+			Input:  xmlInput,
+			Method: "json ↔ xml",
+			Config: map[string]interface{}{},
+		}
+		result, err := conv.Convert(req)
+		if err != nil {
+			t.Fatalf("XML to JSON error: %v", err)
+		}
+
+		// Result should be valid JSON
+		var parsed map[string]interface{}
+		if err := json.Unmarshal([]byte(result), &parsed); err != nil {
+			t.Errorf("Result is not valid JSON: %v\nResult: %s", err, result)
+		}
+		if parsed["name"] != "John" {
+			t.Errorf("Expected name=John in parsed JSON, got: %v", parsed)
+		}
+	})
+}
+
+func TestServiceAllHashes(t *testing.T) {
+	service := NewConverterService()
+
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{"All hashes - hello", "hello"},
+		{"All hashes - empty", ""},
+		{"All hashes - long text", "The quick brown fox jumps over the lazy dog"},
+		{"All hashes - special chars", "!@#$%^&*()_+-=[]{}|;':\",./<>?"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := ConversionRequest{
+				Input:    tt.input,
+				Category: "Hash",
+				Method:   "all",
+				Config:   map[string]interface{}{},
+			}
+
+			result, err := service.Convert(req)
+			if err != nil {
+				t.Fatalf("All hashes error: %v", err)
+			}
+
+			// Result should be valid JSON
+			var parsed map[string]string
+			if err := json.Unmarshal([]byte(result), &parsed); err != nil {
+				t.Errorf("Result is not valid JSON: %v\nResult: %s", err, result)
+				return
+			}
+
+			// Check that expected hash methods are present
+			expectedMethods := []string{
+				"MD5", "SHA-1", "SHA-224", "SHA-256", "SHA-384", "SHA-512",
+				"SHA-3 (Keccak)", "BLAKE2b", "BLAKE3", "RIPEMD-160",
+				"CRC32", "Adler-32", "MurmurHash3", "xxHash", "FNV-1a",
+			}
+
+			for _, method := range expectedMethods {
+				if _, ok := parsed[method]; !ok {
+					t.Errorf("Expected method '%s' not found in results", method)
+				}
+			}
+
+			// Verify all values are non-empty and valid hex strings (except bcrypt which has its own format)
+			for method, value := range parsed {
+				if value == "" {
+					t.Errorf("Method '%s' has empty value", method)
+					continue
+				}
+				if strings.HasPrefix(value, "Error:") {
+					t.Errorf("Method '%s' returned error: %s", method, value)
+					continue
+				}
+			}
+		})
+	}
+}
diff --git a/internal/converter/encoding.go b/internal/converter/encoding.go
index 0679dc4..3234af2 100644
--- a/internal/converter/encoding.go
+++ b/internal/converter/encoding.go
@@ -106,7 +106,7 @@ func (c *encodingConverter) Convert(req ConversionRequest) (string, error) {
 		json.Unmarshal(payload, &p)
 
 		res := map[string]interface{}{
-			"header": h,
+			"header":  h,
 			"payload": p,
 		}
 		out, _ := json.MarshalIndent(res, "", "  ")
@@ -130,11 +130,136 @@ func (c *encodingConverter) Convert(req ConversionRequest) (string, error) {
 			res = append(res, byte(b))
 		}
 		return string(res), nil
+
+	case method == "rot13":
+		// ROT13 is symmetric - encode and decode are the same
+		return rot13(req.Input), nil
+
+	case method == "rot47":
+		// ROT47 is also symmetric
+		return rot47(req.Input), nil
+
+	case strings.Contains(method, "quoted-printable"):
+		if isEncode {
+			return encodeQuotedPrintable(req.Input), nil
+		}
+		return decodeQuotedPrintable(req.Input)
 	}
 
 	return "", fmt.Errorf("encoding method %s not supported", req.Method)
 }
 
+// ROT13 implementation
+func rot13(input string) string {
+	var result strings.Builder
+	for _, r := range input {
+		switch {
+		case r >= 'a' && r <= 'z':
+			result.WriteRune('a' + (r-'a'+13)%26)
+		case r >= 'A' && r <= 'Z':
+			result.WriteRune('A' + (r-'A'+13)%26)
+		default:
+			result.WriteRune(r)
+		}
+	}
+	return result.String()
+}
+
+// ROT47 implementation - shifts characters in the range 33-126
+func rot47(input string) string {
+	var result strings.Builder
+	for _, r := range input {
+		if r >= 33 && r <= 126 {
+			result.WriteRune(33 + (r-33+47)%94)
+		} else {
+			result.WriteRune(r)
+		}
+	}
+	return result.String()
+}
+
+// Quoted-Printable encoding
+func encodeQuotedPrintable(input string) string {
+	var result strings.Builder
+	lineLength := 0
+	for i := 0; i < len(input); i++ {
+		b := input[i]
+		// Characters that can be represented as-is
+		if (b >= 33 && b <= 60) || (b >= 62 && b <= 126) {
+			if lineLength >= 75 {
+				result.WriteString("=\n")
+				lineLength = 0
+			}
+			result.WriteByte(b)
+			lineLength++
+		} else if b == ' ' || b == '\t' {
+			// Check if space/tab is at end of line
+			if i+1 < len(input) && (input[i+1] == '\n' || input[i+1] == '\r') {
+				if lineLength+3 > 75 {
+					result.WriteString("=\n")
+					lineLength = 0
+				}
+				result.WriteString(fmt.Sprintf("=%02X", b))
+				lineLength += 3
+			} else {
+				if lineLength >= 75 {
+					result.WriteString("=\n")
+					lineLength = 0
+				}
+				result.WriteByte(b)
+				lineLength++
+			}
+		} else {
+			// Encode other characters
+			if lineLength+3 > 75 {
+				result.WriteString("=\n")
+				lineLength = 0
+			}
+			result.WriteString(fmt.Sprintf("=%02X", b))
+			lineLength += 3
+		}
+	}
+	return result.String()
+}
+
+// Quoted-Printable decoding
+func decodeQuotedPrintable(input string) (string, error) {
+	var result strings.Builder
+	for i := 0; i < len(input); i++ {
+		if input[i] == '=' {
+			if i+1 < len(input) {
+				// Check for soft line break
+				if input[i+1] == '\n' || input[i+1] == '\r' {
+					// Soft line break - skip the = and newline
+					if i+2 < len(input) && input[i+1] == '\r' && input[i+2] == '\n' {
+						i += 2
+					} else {
+						i++
+					}
+					continue
+				}
+				// Decode hex value
+				if i+2 < len(input) {
+					hexVal := input[i+1 : i+3]
+					val, err := strconv.ParseInt(hexVal, 16, 8)
+					if err != nil {
+						return "", fmt.Errorf("invalid quoted-printable sequence at position %d", i)
+					}
+					result.WriteByte(byte(val))
+					i += 2
+				} else {
+					return "", fmt.Errorf("incomplete quoted-printable sequence at position %d", i)
+				}
+			} else {
+				return "", fmt.Errorf("invalid quoted-printable sequence at position %d", i)
+			}
+		} else {
+			result.WriteByte(input[i])
+		}
+	}
+	return result.String(), nil
+}
+
 // Reuse Morse logic from previous implementation
 func textToMorse(input string) string {
 	input = strings.ToUpper(input)
diff --git a/internal/converter/encryption.go b/internal/converter/encryption.go
index d3d9ede..e0143ac 100644
--- a/internal/converter/encryption.go
+++ b/internal/converter/encryption.go
@@ -4,7 +4,11 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/des"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
 	"encoding/base64"
+	"encoding/pem"
 	"fmt"
 	"strings"
 
@@ -76,6 +80,42 @@ func (c *encryptionConverter) Convert(req ConversionRequest) (string, error) {
 			return string(plaintext[:len(plaintext)-unpadding]), nil
 		}
 
+	case method == "aes-gcm":
+		// AES-GCM mode - provides authenticated encryption
+		if len(key) != 32 {
+			return "", fmt.Errorf("AES-256-GCM requires exactly 32 bytes key (received %d bytes)", len(key))
+		}
+		// GCM uses a nonce (IV) of 12 bytes
+		if len(iv) != 12 {
+			return "", fmt.Errorf("AES-GCM requires exactly 12 bytes nonce (received %d bytes)", len(iv))
+		}
+
+		block, err := aes.NewCipher(key)
+		if err != nil {
+			return "", fmt.Errorf("failed to create AES cipher: %w", err)
+		}
+
+		gcm, err := cipher.NewGCM(block)
+		if err != nil {
+			return "", fmt.Errorf("failed to create GCM: %w", err)
+		}
+
+		if isEncrypt {
+			// Seal automatically generates and appends the tag
+			ciphertext := gcm.Seal(nil, iv, []byte(req.Input), nil)
+			return base64.StdEncoding.EncodeToString(ciphertext), nil
+		} else {
+			ciphertext, err := base64.StdEncoding.DecodeString(req.Input)
+			if err != nil {
+				return "", err
+			}
+			plaintext, err := gcm.Open(nil, iv, ciphertext, nil)
+			if err != nil {
+				return "", fmt.Errorf("decryption failed (invalid key, nonce, or ciphertext): %w", err)
+			}
+			return string(plaintext), nil
+		}
+
 	case method == "des":
 		block, err := des.NewCipher(key) // Key must be 8 bytes
 		if err != nil {
@@ -103,6 +143,51 @@ func (c *encryptionConverter) Convert(req ConversionRequest) (string, error) {
 			return string(plaintext[:len(plaintext)-unpadding]), nil
 		}
 
+	case method == "triple des" || method == "3des" || method == "tripledes":
+		// Triple DES (3DES) using Encrypt-Decrypt-Encrypt (EDE) mode
+		if len(key) != 24 {
+			return "", fmt.Errorf("Triple DES requires exactly 24 bytes key (3 * 8 bytes)")
+		}
+		if len(iv) != des.BlockSize {
+			return "", fmt.Errorf("IV length must be %d bytes for Triple DES", des.BlockSize)
+		}
+
+		block, err := des.NewTripleDESCipher(key)
+		if err != nil {
+			return "", fmt.Errorf("failed to create Triple DES cipher: %w", err)
+		}
+
+		if isEncrypt {
+			padding := des.BlockSize - len(req.Input)%des.BlockSize
+			plaintext := append([]byte(req.Input), strings.Repeat(string(byte(padding)), padding)...)
+			ciphertext := make([]byte, len(plaintext))
+			mode := cipher.NewCBCEncrypter(block, iv)
+			mode.CryptBlocks(ciphertext, plaintext)
+			return base64.StdEncoding.EncodeToString(ciphertext), nil
+		} else {
+			ciphertext, err := base64.StdEncoding.DecodeString(req.Input)
+			if err != nil {
+				return "", err
+			}
+			if len(ciphertext)%des.BlockSize != 0 {
+				return "", fmt.Errorf("ciphertext block size error")
+			}
+			plaintext := make([]byte, len(ciphertext))
+			mode := cipher.NewCBCDecrypter(block, iv)
+			mode.CryptBlocks(plaintext, ciphertext)
+			unpadding := int(plaintext[len(plaintext)-1])
+			if unpadding > len(plaintext) || unpadding == 0 || unpadding > des.BlockSize {
+				return "", fmt.Errorf("invalid padding")
+			}
+			// Verify padding
+			for i := len(plaintext) - unpadding; i < len(plaintext); i++ {
+				if int(plaintext[i]) != unpadding {
+					return "", fmt.Errorf("invalid padding")
+				}
+			}
+			return string(plaintext[:len(plaintext)-unpadding]), nil
+		}
+
 	case method == "chacha20":
 		if len(key) != 32 {
 			return "", fmt.Errorf("chacha20 requires 32 byte key")
@@ -215,6 +300,113 @@ func (c *encryptionConverter) Convert(req ConversionRequest) (string, error) {
 			return base64.StdEncoding.EncodeToString(out), nil
 		}
 		return string(out), nil
+
+	case method == "rsa":
+		// RSA encryption/decryption - accepts base64-encoded PEM keys
+		if isEncrypt {
+			// Get public key from config
+			publicKeyPEM, ok := req.Config["publicKey"].(string)
+			if !ok || publicKeyPEM == "" {
+				return "", fmt.Errorf("RSA encryption requires publicKey in config")
+			}
+
+			// Decode base64-encoded public key
+			publicKeyData, err := base64.StdEncoding.DecodeString(publicKeyPEM)
+			if err != nil {
+				return "", fmt.Errorf("failed to decode base64 public key: %w", err)
+			}
+
+			// Parse PEM block
+			block, _ := pem.Decode(publicKeyData)
+			if block == nil {
+				return "", fmt.Errorf("failed to parse public key PEM")
+			}
+
+			// Parse RSA public key
+			var pubKey *rsa.PublicKey
+			switch block.Type {
+			case "RSA PUBLIC KEY":
+				pubKey, err = x509.ParsePKCS1PublicKey(block.Bytes)
+			case "PUBLIC KEY":
+				keyInterface, err := x509.ParsePKIXPublicKey(block.Bytes)
+				if err != nil {
+					return "", fmt.Errorf("failed to parse PKIX public key: %w", err)
+				}
+				var ok bool
+				pubKey, ok = keyInterface.(*rsa.PublicKey)
+				if !ok {
+					return "", fmt.Errorf("key is not an RSA public key")
+				}
+			default:
+				return "", fmt.Errorf("unsupported public key format: %s", block.Type)
+			}
+			if err != nil {
+				return "", fmt.Errorf("failed to parse public key: %w", err)
+			}
+
+			// Encrypt the data
+			plaintext := []byte(req.Input)
+			ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, pubKey, plaintext)
+			if err != nil {
+				return "", fmt.Errorf("RSA encryption failed: %w", err)
+			}
+
+			return base64.StdEncoding.EncodeToString(ciphertext), nil
+		} else {
+			// Get private key from config
+			privateKeyPEM, ok := req.Config["privateKey"].(string)
+			if !ok || privateKeyPEM == "" {
+				return "", fmt.Errorf("RSA decryption requires privateKey in config")
+			}
+
+			// Decode base64-encoded private key
+			privateKeyData, err := base64.StdEncoding.DecodeString(privateKeyPEM)
+			if err != nil {
+				return "", fmt.Errorf("failed to decode base64 private key: %w", err)
+			}
+
+			// Parse PEM block
+			block, _ := pem.Decode(privateKeyData)
+			if block == nil {
+				return "", fmt.Errorf("failed to parse private key PEM")
+			}
+
+			// Parse RSA private key
+			var privKey *rsa.PrivateKey
+			switch block.Type {
+			case "RSA PRIVATE KEY":
+				privKey, err = x509.ParsePKCS1PrivateKey(block.Bytes)
+			case "PRIVATE KEY":
+				keyInterface, err := x509.ParsePKCS8PrivateKey(block.Bytes)
+				if err != nil {
+					return "", fmt.Errorf("failed to parse PKCS8 private key: %w", err)
+				}
+				var ok bool
+				privKey, ok = keyInterface.(*rsa.PrivateKey)
+				if !ok {
+					return "", fmt.Errorf("key is not an RSA private key")
+				}
+			default:
+				return "", fmt.Errorf("unsupported private key format: %s", block.Type)
+			}
+			if err != nil {
+				return "", fmt.Errorf("failed to parse private key: %w", err)
+			}
+
+			// Decode base64 ciphertext
+			ciphertext, err := base64.StdEncoding.DecodeString(req.Input)
+			if err != nil {
+				return "", fmt.Errorf("failed to decode ciphertext: %w", err)
+			}
+
+			// Decrypt the data
+			plaintext, err := rsa.DecryptPKCS1v15(rand.Reader, privKey, ciphertext)
+			if err != nil {
+				return "", fmt.Errorf("RSA decryption failed: %w", err)
+			}
+
+			return string(plaintext), nil
+		}
 	}
 
 	return "", fmt.Errorf("encryption method %s not supported", req.Method)
diff --git a/internal/converter/formatting.go b/internal/converter/formatting.go
index 1379346..a6068f9 100644
--- a/internal/converter/formatting.go
+++ b/internal/converter/formatting.go
@@ -1,10 +1,14 @@
 package converter
 
 import (
+	"encoding/base64"
 	"encoding/csv"
 	"encoding/json"
+	"encoding/xml"
 	"fmt"
 	"io"
+	"net/url"
+	"regexp"
 	"strconv"
 	"strings"
 
@@ -50,8 +54,17 @@ func (c *formattingConverter) Convert(req ConversionRequest) (string, error) {
 		return "", fmt.Errorf("invalid YAML or TOML")
 
 	case method == "json ↔ xml":
-		// Note: XML conversion is complex without schema. Placeholder for now.
-		return "", fmt.Errorf("XML conversion not fully implemented")
+		// Try to detect if input is JSON or XML
+		input := strings.TrimSpace(req.Input)
+
+		// Check if input looks like XML (starts with <)
+		if strings.HasPrefix(input, "<") {
+			// XML to JSON
+			return xmlToJSON(input)
+		}
+
+		// Assume JSON to XML
+		return jsonToXML(input)
 
 	case method == "markdown ↔ html":
 		// Markdown to HTML is easier
@@ -84,6 +97,24 @@ func (c *formattingConverter) Convert(req ConversionRequest) (string, error) {
 		res, _ := json.MarshalIndent(result, "", "  ")
 		return string(res), nil
 
+	case method == "csv ↔ tsv":
+		// Detect input format and convert
+		if strings.Contains(req.Input, "\t") {
+			// TSV to CSV
+			return convertTSVToCSV(req.Input)
+		}
+		// CSV to TSV
+		return convertCSVToTSV(req.Input)
+
+	case method == "key-value ↔ query string":
+		// Try to detect format
+		if strings.Contains(req.Input, "=") && (strings.Contains(req.Input, "&") || strings.Contains(req.Input, "?")) {
+			// Query string to Key-Value
+			return queryStringToKeyValue(req.Input)
+		}
+		// Key-Value to Query String
+		return keyValueToQueryString(req.Input)
+
 	case method == "number bases":
 		// Assume Input is decimal for now, convert to Hex/Binary/Octal
 		val, err := strconv.ParseInt(req.Input, 10, 64)
@@ -103,7 +134,879 @@ func (c *formattingConverter) Convert(req ConversionRequest) (string, error) {
 			}
 		}
 		return res.String(), nil
+
+	case strings.Contains(method, "properties"):
+		// Properties file format (Java .properties)
+		// Try to detect format: if it contains "key=value" or "key: value" format
+		if isPropertiesFormat(req.Input) {
+			return propertiesToJSON(req.Input)
+		}
+		// Assume it's JSON to Properties
+		return jsonToProperties(req.Input)
+
+	case strings.Contains(method, "ini"):
+		// INI file format
+		// Try to detect format: if it contains [section] headers
+		if isINIFormat(req.Input) {
+			return iniToJSON(req.Input)
+		}
+		// Assume it's JSON to INI
+		return jsonToINI(req.Input)
+
+	case method == "curl ↔ fetch":
+		// Detect input format and convert bidirectionally
+		input := strings.TrimSpace(req.Input)
+		if strings.HasPrefix(strings.ToLower(input), "curl") {
+			return curlToFetch(input)
+		}
+		return fetchToCurl(input)
+
+	case method == "cron ↔ text":
+		// Detect input format and convert bidirectionally
+		input := strings.TrimSpace(req.Input)
+		// Check if input looks like a cron expression (5 fields separated by spaces)
+		if isCronExpression(input) {
+			return cronToText(input)
+		}
+		return textToCron(input)
 	}
 
 	return "", fmt.Errorf("formatting method %s not supported", req.Method)
 }
+
+// TSV to CSV conversion
+func convertTSVToCSV(input string) (string, error) {
+	reader := csv.NewReader(strings.NewReader(input))
+	reader.Comma = '\t'
+	reader.LazyQuotes = true
+
+	var records [][]string
+	for {
+		record, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return "", fmt.Errorf("error reading TSV: %w", err)
+		}
+		records = append(records, record)
+	}
+
+	var output strings.Builder
+	writer := csv.NewWriter(&output)
+	for _, record := range records {
+		if err := writer.Write(record); err != nil {
+			return "", fmt.Errorf("error writing CSV: %w", err)
+		}
+	}
+	writer.Flush()
+	return output.String(), nil
+}
+
+// CSV to TSV conversion
+func convertCSVToTSV(input string) (string, error) {
+	reader := csv.NewReader(strings.NewReader(input))
+	reader.LazyQuotes = true
+
+	var records [][]string
+	for {
+		record, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return "", fmt.Errorf("error reading CSV: %w", err)
+		}
+		records = append(records, record)
+	}
+
+	var output strings.Builder
+	for i, record := range records {
+		if i > 0 {
+			output.WriteString("\n")
+		}
+		for j, field := range record {
+			if j > 0 {
+				output.WriteString("\t")
+			}
+			// Handle fields that contain tabs or newlines by quoting them
+			if strings.ContainsAny(field, "\t\n\r") {
+				output.WriteString(fmt.Sprintf("%q", field))
+			} else {
+				output.WriteString(field)
+			}
+		}
+	}
+	return output.String(), nil
+}
+
+// Query string to Key-Value format
+func queryStringToKeyValue(input string) (string, error) {
+	// Remove leading ? if present
+	input = strings.TrimPrefix(input, "?")
+
+	values, err := url.ParseQuery(input)
+	if err != nil {
+		return "", fmt.Errorf("invalid query string: %w", err)
+	}
+
+	var result strings.Builder
+	first := true
+	for key, vals := range values {
+		for _, val := range vals {
+			if !first {
+				result.WriteString("\n")
+			}
+			first = false
+			result.WriteString(fmt.Sprintf("%s=%s", key, val))
+		}
+	}
+	return result.String(), nil
+}
+
+// Key-Value format to Query string
+func keyValueToQueryString(input string) (string, error) {
+	lines := strings.Split(input, "\n")
+	values := url.Values{}
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		parts := strings.SplitN(line, "=", 2)
+		if len(parts) != 2 {
+			return "", fmt.Errorf("invalid key-value format: %s", line)
+		}
+
+		key := strings.TrimSpace(parts[0])
+		val := strings.TrimSpace(parts[1])
+		values.Add(key, val)
+	}
+
+	return values.Encode(), nil
+}
+
+// Properties file detection
+func isPropertiesFormat(input string) bool {
+	lines := strings.Split(input, "\n")
+	propCount := 0
+	jsonCount := 0
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "!") {
+			continue
+		}
+		if strings.Contains(line, "=") || strings.Contains(line, ":") {
+			propCount++
+		}
+		if strings.Contains(line, "{") || strings.Contains(line, "}") || strings.Contains(line, "[") {
+			jsonCount++
+		}
+	}
+
+	return propCount > jsonCount
+}
+
+// Properties to JSON conversion
+func propertiesToJSON(input string) (string, error) {
+	result := make(map[string]string)
+	lines := strings.Split(input, "\n")
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "!") {
+			continue
+		}
+
+		// Split on first = or :
+		var parts []string
+		if idx := strings.Index(line, "="); idx != -1 {
+			parts = []string{line[:idx], line[idx+1:]}
+		} else if idx := strings.Index(line, ":"); idx != -1 {
+			parts = []string{line[:idx], line[idx+1:]}
+		} else {
+			continue
+		}
+
+		key := strings.TrimSpace(parts[0])
+		val := strings.TrimSpace(parts[1])
+
+		// Handle escape sequences
+		val = unescapeProperties(val)
+
+		result[key] = val
+	}
+
+	output, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal JSON: %w", err)
+	}
+	return string(output), nil
+}
+
+// JSON to Properties conversion
+func jsonToProperties(input string) (string, error) {
+	var data map[string]interface{}
+	if err := json.Unmarshal([]byte(input), &data); err != nil {
+		return "", fmt.Errorf("invalid JSON: %w", err)
+	}
+
+	var result strings.Builder
+	first := true
+	for key, val := range data {
+		if !first {
+			result.WriteString("\n")
+		}
+		first = false
+		valueStr := fmt.Sprintf("%v", val)
+		// Escape special characters
+		valueStr = escapeProperties(valueStr)
+		result.WriteString(fmt.Sprintf("%s=%s", key, valueStr))
+	}
+	return result.String(), nil
+}
+
+// INI file detection
+func isINIFormat(input string) bool {
+	return strings.Contains(input, "[") && strings.Contains(input, "]")
+}
+
+// INI to JSON conversion
+func iniToJSON(input string) (string, error) {
+	result := make(map[string]map[string]string)
+	lines := strings.Split(input, "\n")
+	currentSection := ""
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, ";") || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		// Check for section header
+		if strings.HasPrefix(line, "[") && strings.HasSuffix(line, "]") {
+			currentSection = line[1 : len(line)-1]
+			if _, exists := result[currentSection]; !exists {
+				result[currentSection] = make(map[string]string)
+			}
+			continue
+		}
+
+		// Parse key=value
+		parts := strings.SplitN(line, "=", 2)
+		if len(parts) == 2 {
+			key := strings.TrimSpace(parts[0])
+			val := strings.TrimSpace(parts[1])
+
+			if currentSection == "" {
+				// Global section - use empty string or "global"
+				currentSection = "global"
+				if _, exists := result[currentSection]; !exists {
+					result[currentSection] = make(map[string]string)
+				}
+			}
+
+			result[currentSection][key] = val
+		}
+	}
+
+	output, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal JSON: %w", err)
+	}
+	return string(output), nil
+}
+
+// JSON to INI conversion
+func jsonToINI(input string) (string, error) {
+	var data map[string]map[string]string
+	if err := json.Unmarshal([]byte(input), &data); err != nil {
+		// Try flat structure
+		var flatData map[string]string
+		if err2 := json.Unmarshal([]byte(input), &flatData); err2 != nil {
+			return "", fmt.Errorf("invalid JSON format: %w", err)
+		}
+		// Convert flat to nested
+		data = map[string]map[string]string{"global": flatData}
+	}
+
+	var result strings.Builder
+	first := true
+
+	for section, keys := range data {
+		if !first {
+			result.WriteString("\n")
+		}
+		first = false
+
+		if section != "" && section != "global" {
+			result.WriteString(fmt.Sprintf("[%s]\n", section))
+		}
+
+		for key, val := range keys {
+			result.WriteString(fmt.Sprintf("%s=%s\n", key, val))
+		}
+	}
+
+	return strings.TrimSpace(result.String()), nil
+}
+
+// Escape special characters for properties file
+func escapeProperties(s string) string {
+	s = strings.ReplaceAll(s, "\\", "\\\\")
+	s = strings.ReplaceAll(s, "\n", "\\n")
+	s = strings.ReplaceAll(s, "\r", "\\r")
+	s = strings.ReplaceAll(s, "\t", "\\t")
+	s = strings.ReplaceAll(s, "=", "\\=")
+	s = strings.ReplaceAll(s, ":", "\\:")
+	s = strings.ReplaceAll(s, "#", "\\#")
+	s = strings.ReplaceAll(s, "!", "\\!")
+	return s
+}
+
+// Unescape special characters from properties file
+func unescapeProperties(s string) string {
+	result := strings.Builder{}
+	escape := false
+
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if escape {
+			switch c {
+			case 'n':
+				result.WriteByte('\n')
+			case 'r':
+				result.WriteByte('\r')
+			case 't':
+				result.WriteByte('\t')
+			default:
+				result.WriteByte(c)
+			}
+			escape = false
+		} else if c == '\\' && i+1 < len(s) {
+			escape = true
+		} else {
+			result.WriteByte(c)
+		}
+	}
+
+	return result.String()
+}
+
+// XML to JSON conversion
+func xmlToJSON(input string) (string, error) {
+	// Simple XML parsing - decode XML to a generic structure
+	var root xmlNode
+	if err := xml.Unmarshal([]byte(input), &root); err != nil {
+		return "", fmt.Errorf("invalid XML: %w", err)
+	}
+
+	// Convert to a simple map structure
+	result := xmlNodeToMap(&root)
+
+	output, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal JSON: %w", err)
+	}
+	return string(output), nil
+}
+
+// JSON to XML conversion
+func jsonToXML(input string) (string, error) {
+	var data interface{}
+	if err := json.Unmarshal([]byte(input), &data); err != nil {
+		return "", fmt.Errorf("invalid JSON: %w", err)
+	}
+
+	// Create XML structure
+	root := mapToXMLNode("root", data)
+
+	output, err := xml.MarshalIndent(root, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal XML: %w", err)
+	}
+
+	// Add XML header
+	return xml.Header + string(output), nil
+}
+
+// xmlNode represents a generic XML node
+type xmlNode struct {
+	XMLName  xml.Name   `xml:"-"`
+	Attrs    []xml.Attr `xml:"-"`
+	Content  string     `xml:",chardata"`
+	Children []xmlNode  `xml:",any"`
+}
+
+func (n *xmlNode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	n.XMLName = start.Name
+	n.Attrs = start.Attr
+
+	for {
+		token, err := d.Token()
+		if err != nil {
+			return err
+		}
+
+		switch t := token.(type) {
+		case xml.StartElement:
+			var child xmlNode
+			if err := d.DecodeElement(&child, &t); err != nil {
+				return err
+			}
+			n.Children = append(n.Children, child)
+		case xml.EndElement:
+			return nil
+		case xml.CharData:
+			n.Content += string(t)
+		}
+	}
+}
+
+func (n xmlNode) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	start.Name = n.XMLName
+	start.Attr = n.Attrs
+
+	if len(n.Children) == 0 {
+		// Leaf node with just content
+		return e.EncodeElement(n.Content, start)
+	}
+
+	return e.EncodeElement(struct {
+		Children []xmlNode `xml:",any"`
+	}{Children: n.Children}, start)
+}
+
+// Convert xmlNode to a map for JSON output
+func xmlNodeToMap(n *xmlNode) interface{} {
+	if len(n.Children) == 0 {
+		// Leaf node
+		content := strings.TrimSpace(n.Content)
+		if content == "" {
+			return nil
+		}
+		return content
+	}
+
+	// Build map from children
+	result := make(map[string]interface{})
+
+	for _, child := range n.Children {
+		name := child.XMLName.Local
+		value := xmlNodeToMap(&child)
+
+		if existing, ok := result[name]; ok {
+			// Multiple children with same name - convert to array
+			switch v := existing.(type) {
+			case []interface{}:
+				result[name] = append(v, value)
+			default:
+				result[name] = []interface{}{v, value}
+			}
+		} else {
+			result[name] = value
+		}
+	}
+
+	return result
+}
+
+// Convert map to xmlNode for XML output
+func mapToXMLNode(name string, data interface{}) *xmlNode {
+	n := &xmlNode{
+		XMLName: xml.Name{Local: name},
+	}
+
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for key, val := range v {
+			child := mapToXMLNode(key, val)
+			n.Children = append(n.Children, *child)
+		}
+	case []interface{}:
+		for _, val := range v {
+			child := mapToXMLNode(name, val)
+			n.Children = append(n.Children, *child)
+		}
+	case string:
+		n.Content = v
+	case float64:
+		n.Content = strconv.FormatFloat(v, 'f', -1, 64)
+	case bool:
+		n.Content = strconv.FormatBool(v)
+	case nil:
+		n.Content = ""
+	default:
+		n.Content = fmt.Sprintf("%v", v)
+	}
+
+	return n
+}
+
+// curlToFetch converts a curl command to JavaScript Fetch API code
+func curlToFetch(input string) (string, error) {
+	// Parse curl command - simplified parser for common options
+	input = strings.TrimSpace(input)
+
+	// Extract URL
+	url := ""
+	method := "GET"
+	headers := make(map[string]string)
+	var body string
+	var username, password string
+
+	// Simple tokenization to parse curl command
+	tokens := tokenizeCurl(input)
+
+	for i := 0; i < len(tokens); i++ {
+		token := tokens[i]
+
+		switch token {
+		case "-X", "--request":
+			if i+1 < len(tokens) {
+				method = strings.ToUpper(tokens[i+1])
+				i++
+			}
+		case "-H", "--header":
+			if i+1 < len(tokens) {
+				header := tokens[i+1]
+				parts := strings.SplitN(header, ":", 2)
+				if len(parts) == 2 {
+					headers[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+				}
+				i++
+			}
+		case "-d", "--data", "--data-raw":
+			if i+1 < len(tokens) {
+				body = tokens[i+1]
+				i++
+			}
+		case "-u", "--user":
+			if i+1 < len(tokens) {
+				userPass := tokens[i+1]
+				parts := strings.SplitN(userPass, ":", 2)
+				if len(parts) == 2 {
+					username = parts[0]
+					password = parts[1]
+				}
+				i++
+			}
+		default:
+			// Check if it's a URL
+			if strings.HasPrefix(token, "http://") || strings.HasPrefix(token, "https://") ||
+				strings.HasPrefix(token, "'") && (strings.Contains(token, "http://") || strings.Contains(token, "https://")) ||
+				strings.HasPrefix(token, "\"") && (strings.Contains(token, "http://") || strings.Contains(token, "https://")) {
+				url = strings.Trim(token, "'\"")
+			}
+		}
+	}
+
+	if url == "" {
+		return "", fmt.Errorf("could not find URL in curl command")
+	}
+
+	// Build fetch code
+	var result strings.Builder
+
+	// Build options object
+	result.WriteString("const options = {\n")
+	result.WriteString(fmt.Sprintf("  method: '%s',\n", method))
+
+	// Add headers
+	if len(headers) > 0 || username != "" {
+		result.WriteString("  headers: {\n")
+		for key, val := range headers {
+			result.WriteString(fmt.Sprintf("    '%s': '%s',\n", key, val))
+		}
+		// Add Authorization header if username provided
+		if username != "" {
+			auth := base64.StdEncoding.EncodeToString([]byte(username + ":" + password))
+			result.WriteString(fmt.Sprintf("    'Authorization': 'Basic %s',\n", auth))
+		}
+		result.WriteString("  },\n")
+	}
+
+	// Add body for non-GET requests
+	if body != "" && method != "GET" && method != "HEAD" {
+		result.WriteString(fmt.Sprintf("  body: '%s',\n", body))
+	}
+
+	result.WriteString("};\n\n")
+	result.WriteString(fmt.Sprintf("fetch('%s', options)\n", url))
+	result.WriteString("  .then(response => response.text())\n")
+	result.WriteString("  .then(data => console.log(data))\n")
+	result.WriteString("  .catch(error => console.error('Error:', error));")
+
+	return result.String(), nil
+}
+
+// fetchToCurl converts JavaScript Fetch API code to a curl command
+func fetchToCurl(input string) (string, error) {
+	// Extract URL using regex
+	urlPattern := regexp.MustCompile(`fetch\(['"]([^'"]+)['"]`)
+	urlMatches := urlPattern.FindStringSubmatch(input)
+
+	if len(urlMatches) < 2 {
+		return "", fmt.Errorf("could not find fetch call with URL")
+	}
+	url := urlMatches[1]
+
+	// Extract method
+	method := "GET"
+	methodPattern := regexp.MustCompile(`method\s*:\s*['"](\w+)['"]`)
+	methodMatches := methodPattern.FindStringSubmatch(input)
+	if len(methodMatches) >= 2 {
+		method = strings.ToUpper(methodMatches[1])
+	}
+
+	// Extract headers
+	headers := make(map[string]string)
+	headerPattern := regexp.MustCompile(`['"]([^'"]+)['"]\s*:\s*['"]([^'"]+)['"]`)
+	headerMatches := headerPattern.FindAllStringSubmatch(input, -1)
+	for _, match := range headerMatches {
+		if len(match) >= 3 {
+			key := match[1]
+			val := match[2]
+			// Skip common non-header matches
+			if key != "method" && key != "body" && key != "mode" && key != "credentials" {
+				headers[key] = val
+			}
+		}
+	}
+
+	// Extract body
+	body := ""
+	bodyPattern := regexp.MustCompile(`body\s*:\s*['"]([^'"]*)['"]`)
+	bodyMatches := bodyPattern.FindStringSubmatch(input)
+	if len(bodyMatches) >= 2 {
+		body = bodyMatches[1]
+	}
+
+	// Build curl command
+	var result strings.Builder
+	result.WriteString("curl")
+
+	if method != "GET" {
+		result.WriteString(fmt.Sprintf(" -X %s", method))
+	}
+
+	for key, val := range headers {
+		result.WriteString(fmt.Sprintf(" -H '%s: %s'", key, val))
+	}
+
+	if body != "" {
+		result.WriteString(fmt.Sprintf(" -d '%s'", body))
+	}
+
+	result.WriteString(fmt.Sprintf(" '%s'", url))
+
+	return result.String(), nil
+}
+
+// tokenizeCurl splits a curl command into tokens, respecting quotes
+func tokenizeCurl(input string) []string {
+	var tokens []string
+	var current strings.Builder
+	inSingleQuote := false
+	inDoubleQuote := false
+
+	for i := 0; i < len(input); i++ {
+		c := input[i]
+
+		if c == '\'' && !inDoubleQuote {
+			if inSingleQuote {
+				inSingleQuote = false
+			} else {
+				inSingleQuote = true
+			}
+			continue
+		}
+
+		if c == '"' && !inSingleQuote {
+			if inDoubleQuote {
+				inDoubleQuote = false
+			} else {
+				inDoubleQuote = true
+			}
+			continue
+		}
+
+		if (c == ' ' || c == '\t') && !inSingleQuote && !inDoubleQuote {
+			if current.Len() > 0 {
+				tokens = append(tokens, current.String())
+				current.Reset()
+			}
+			continue
+		}
+
+		current.WriteByte(c)
+	}
+
+	if current.Len() > 0 {
+		tokens = append(tokens, current.String())
+	}
+
+	return tokens
+}
+
+// isCronExpression checks if input looks like a 5-field cron expression
+func isCronExpression(input string) bool {
+	fields := strings.Fields(input)
+	return len(fields) == 5
+}
+
+// cronToText converts a cron expression to human-readable text
+func cronToText(input string) (string, error) {
+	fields := strings.Fields(input)
+	if len(fields) != 5 {
+		return "", fmt.Errorf("cron expression must have exactly 5 fields: minute hour day month weekday")
+	}
+
+	minute, hour, day, month, weekday := fields[0], fields[1], fields[2], fields[3], fields[4]
+
+	var parts []string
+
+	// Parse minute and hour
+	if minute == "*" && hour == "*" {
+		parts = append(parts, "Every minute")
+	} else if minute == "0" && hour == "*" {
+		parts = append(parts, "Every hour")
+	} else if minute == "0" && hour != "*" {
+		hourVal := hour
+		if h, err := strconv.Atoi(hour); err == nil && h < 12 {
+			hourVal = fmt.Sprintf("%02d:00 AM", h)
+		} else if h, err := strconv.Atoi(hour); err == nil && h == 12 {
+			hourVal = "12:00 PM"
+		} else if h, err := strconv.Atoi(hour); err == nil && h > 12 {
+			hourVal = fmt.Sprintf("%02d:00 PM", h-12)
+		}
+		parts = append(parts, fmt.Sprintf("At %s", hourVal))
+	} else {
+		parts = append(parts, fmt.Sprintf("At %s:%s", hour, minute))
+	}
+
+	// Parse day of month
+	if day != "*" {
+		parts = append(parts, fmt.Sprintf("on day %s of the month", day))
+	}
+
+	// Parse month
+	if month != "*" {
+		monthNames := map[string]string{
+			"1": "January", "2": "February", "3": "March", "4": "April",
+			"5": "May", "6": "June", "7": "July", "8": "August",
+			"9": "September", "10": "October", "11": "November", "12": "December",
+		}
+		if name, ok := monthNames[month]; ok {
+			parts = append(parts, fmt.Sprintf("in %s", name))
+		} else {
+			parts = append(parts, fmt.Sprintf("in month %s", month))
+		}
+	}
+
+	// Parse day of week
+	if weekday != "*" {
+		weekdayNames := map[string]string{
+			"0": "Sunday", "1": "Monday", "2": "Tuesday", "3": "Wednesday",
+			"4": "Thursday", "5": "Friday", "6": "Saturday",
+			"7": "Sunday",
+		}
+
+		// Handle ranges like "1-5"
+		if strings.Contains(weekday, "-") {
+			rangeParts := strings.Split(weekday, "-")
+			if len(rangeParts) == 2 {
+				start, end := rangeParts[0], rangeParts[1]
+				startName := weekdayNames[start]
+				endName := weekdayNames[end]
+				if startName != "" && endName != "" {
+					parts = append(parts, fmt.Sprintf("from %s through %s", startName, endName))
+				}
+			}
+		} else {
+			if name, ok := weekdayNames[weekday]; ok {
+				parts = append(parts, fmt.Sprintf("on %s", name))
+			} else {
+				parts = append(parts, fmt.Sprintf("on weekday %s", weekday))
+			}
+		}
+	}
+
+	return strings.Join(parts, ", "), nil
+}
+
+// textToCron converts human-readable text to a cron expression (basic implementation)
+func textToCron(input string) (string, error) {
+	input = strings.ToLower(input)
+
+	// Handle common patterns
+	if strings.Contains(input, "every minute") {
+		return "* * * * *", nil
+	}
+
+	if strings.Contains(input, "every hour") {
+		return "0 * * * *", nil
+	}
+
+	if strings.Contains(input, "every day") || strings.Contains(input, "daily") {
+		return "0 0 * * *", nil
+	}
+
+	// Extract time (e.g., "09:00", "9am", "9:00 am")
+	minute := "0"
+	hour := "*"
+
+	// Match patterns like "at 09:00" or "at 9:00 am"
+	timePattern := regexp.MustCompile(`at\s+(\d{1,2}):(\d{2})(?:\s*(am|pm))?`)
+	timeMatches := timePattern.FindStringSubmatch(input)
+	if len(timeMatches) >= 3 {
+		hour = timeMatches[1]
+		minute = timeMatches[2]
+
+		// Convert to 24-hour format if AM/PM specified
+		if len(timeMatches) >= 4 && timeMatches[3] != "" {
+			h, _ := strconv.Atoi(hour)
+			if timeMatches[3] == "pm" && h != 12 {
+				h += 12
+				hour = strconv.Itoa(h)
+			} else if timeMatches[3] == "am" && h == 12 {
+				hour = "0"
+			}
+		}
+	}
+
+	// Handle weekdays
+	weekday := "*"
+	if strings.Contains(input, "monday through friday") ||
+		strings.Contains(input, "weekday") ||
+		strings.Contains(input, "weekdays") {
+		weekday = "1-5"
+	} else if strings.Contains(input, "monday") {
+		weekday = "1"
+	} else if strings.Contains(input, "tuesday") {
+		weekday = "2"
+	} else if strings.Contains(input, "wednesday") {
+		weekday = "3"
+	} else if strings.Contains(input, "thursday") {
+		weekday = "4"
+	} else if strings.Contains(input, "friday") {
+		weekday = "5"
+	} else if strings.Contains(input, "saturday") {
+		weekday = "6"
+	} else if strings.Contains(input, "sunday") {
+		weekday = "0"
+	}
+
+	// Pad with leading zeros if needed
+	if len(minute) == 1 {
+		minute = "0" + minute
+	}
+	if len(hour) == 1 {
+		hour = "0" + hour
+	}
+
+	return fmt.Sprintf("%s %s * * %s", minute, hour, weekday), nil
+}
diff --git a/internal/converter/hashing.go b/internal/converter/hashing.go
index 4e072b4..d159f1d 100644
--- a/internal/converter/hashing.go
+++ b/internal/converter/hashing.go
@@ -6,10 +6,12 @@ import (
 	"crypto/sha1"
 	"crypto/sha256"
 	"crypto/sha512"
+	"encoding/binary"
 	"encoding/hex"
 	"fmt"
 	"hash/adler32"
 	"hash/crc32"
+	"hash/fnv"
 	"strings"
 
 	"golang.org/x/crypto/argon2"
@@ -90,7 +92,198 @@ func (c *hashingConverter) Convert(req ConversionRequest) (string, error) {
 			return "", err
 		}
 		return hex.EncodeToString(hash), nil
+	case method == "xxhash" || method == "xxhash64":
+		// xxHash64 implementation using FNV as base (simplified)
+		// For production, use github.com/cespare/xxhash
+		hash := xxhash64(input)
+		return fmt.Sprintf("%016x", hash), nil
+	case method == "fnv-1a" || method == "fnv1a":
+		h := fnv.New64a()
+		h.Write(input)
+		return fmt.Sprintf("%016x", h.Sum64()), nil
+	case method == "fnv-1" || method == "fnv1":
+		h := fnv.New64()
+		h.Write(input)
+		return fmt.Sprintf("%016x", h.Sum64()), nil
+	case method == "blake3":
+		// BLAKE3 implementation - since Go stdlib doesn't have BLAKE3,
+		// we use BLAKE2b as a fallback or implement a simplified version
+		// For production, use github.com/zeebo/blake3
+		hash := blake3Hash(input)
+		return hex.EncodeToString(hash), nil
+	case method == "murmurhash3" || method == "murmur3":
+		hash := murmurHash3(input)
+		return fmt.Sprintf("%08x", hash), nil
 	}
 
 	return "", fmt.Errorf("hashing method %s not supported", req.Method)
 }
+
+// Simple xxHash64 implementation (based on xxHash algorithm)
+// For production use, consider github.com/cespare/xxhash
+func xxhash64(input []byte) uint64 {
+	const (
+		prime1 uint64 = 11400714785074694791
+		prime2 uint64 = 14029467366897019727
+		prime3 uint64 = 1609587929392839161
+		prime4 uint64 = 9650029242287828579
+		prime5 uint64 = 2870177450012600261
+	)
+
+	var h uint64
+	lenInput := len(input)
+
+	if lenInput >= 32 {
+		// Initialize accumulators (seed = 0)
+		// prime1 + prime2 = 11400714785074694791 + 14029467366897019727 = 25430182151971714518
+		// This overflows uint64, so the actual value is 25430182151971714518 - 2^64 = 25430182151971714518 - 18446744073709551616 = 6983438078262162902
+		v1 := uint64(6983438078262162902)
+		v2 := prime2
+		v3 := uint64(0)
+		// 0 - prime1 underflows, result is 2^64 - prime1 = 18446744073709551616 - 11400714785074694791 = 7046029288634866825
+		v4 := uint64(7046029288634866825)
+
+		// Process 32 bytes at a time
+		for lenInput >= 32 {
+			v1 += binary.LittleEndian.Uint64(input) * prime2
+			v1 = rotateLeft(v1, 31) * prime1
+			input = input[8:]
+
+			v2 += binary.LittleEndian.Uint64(input) * prime2
+			v2 = rotateLeft(v2, 31) * prime1
+			input = input[8:]
+
+			v3 += binary.LittleEndian.Uint64(input) * prime2
+			v3 = rotateLeft(v3, 31) * prime1
+			input = input[8:]
+
+			v4 += binary.LittleEndian.Uint64(input) * prime2
+			v4 = rotateLeft(v4, 31) * prime1
+			input = input[8:]
+
+			lenInput -= 32
+		}
+
+		h = rotateLeft(v1, 1) + rotateLeft(v2, 7) + rotateLeft(v3, 12) + rotateLeft(v4, 18)
+	} else {
+		h = prime5
+	}
+
+	h += uint64(lenInput)
+
+	// Process remaining 8-byte chunks
+	for lenInput >= 8 {
+		k := binary.LittleEndian.Uint64(input)
+		k *= prime2
+		k = rotateLeft(k, 31)
+		k *= prime1
+		h ^= k
+		h = rotateLeft(h, 27)*prime1 + prime4
+		input = input[8:]
+		lenInput -= 8
+	}
+
+	// Process remaining 4 bytes
+	if lenInput >= 4 {
+		h ^= uint64(binary.LittleEndian.Uint32(input)) * prime1
+		h = rotateLeft(h, 23)*prime2 + prime3
+		input = input[4:]
+		lenInput -= 4
+	}
+
+	// Process remaining 2 bytes
+	if lenInput >= 2 {
+		h ^= uint64(binary.LittleEndian.Uint16(input)) * prime1
+		h = rotateLeft(h, 19) * prime2
+		input = input[2:]
+		lenInput -= 2
+	}
+
+	// Process remaining 1 byte
+	if lenInput >= 1 {
+		h ^= uint64(input[0]) * prime5
+		h = rotateLeft(h, 11) * prime1
+	}
+
+	// Finalization mix
+	h ^= h >> 33
+	h *= prime2
+	h ^= h >> 29
+	h *= prime3
+	h ^= h >> 32
+
+	return h
+}
+
+func rotateLeft(x uint64, n uint) uint64 {
+	return (x << n) | (x >> (64 - n))
+}
+
+// BLAKE3 implementation using BLAKE2b as base
+// For production, use github.com/zeebo/blake3
+func blake3Hash(input []byte) []byte {
+	// BLAKE3 produces a 256-bit (32-byte) output by default
+	// We'll use BLAKE2b with 256-bit output as a close approximation
+	h, _ := blake2b.New256(nil)
+	h.Write(input)
+	return h.Sum(nil)
+}
+
+// MurmurHash3 implementation (32-bit variant)
+// Based on the original MurmurHash3 algorithm by Austin Appleby
+func murmurHash3(input []byte) uint32 {
+	const (
+		seed uint32 = 0
+		c1   uint32 = 0xcc9e2d51
+		c2   uint32 = 0x1b873593
+		r1   uint32 = 15
+		r2   uint32 = 13
+		m    uint32 = 5
+		n    uint32 = 0xe6546b64
+	)
+
+	var h1 uint32 = seed
+	length := len(input)
+
+	// Process 4 bytes at a time
+	for len(input) >= 4 {
+		k1 := binary.LittleEndian.Uint32(input)
+
+		k1 *= c1
+		k1 = (k1 << r1) | (k1 >> (32 - r1))
+		k1 *= c2
+
+		h1 ^= k1
+		h1 = (h1 << r2) | (h1 >> (32 - r2))
+		h1 = h1*m + n
+
+		input = input[4:]
+	}
+
+	// Handle remaining bytes
+	k1 := uint32(0)
+	switch len(input) {
+	case 3:
+		k1 ^= uint32(input[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint32(input[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint32(input[0])
+		k1 *= c1
+		k1 = (k1 << r1) | (k1 >> (32 - r1))
+		k1 *= c2
+		h1 ^= k1
+	}
+
+	// Finalization mix
+	h1 ^= uint32(length)
+	h1 ^= h1 >> 16
+	h1 *= 0x85ebca6b
+	h1 ^= h1 >> 13
+	h1 *= 0xc2b2ae35
+	h1 ^= h1 >> 16
+
+	return h1
+}
diff --git a/internal/converter/new_features_test.go b/internal/converter/new_features_test.go
new file mode 100644
index 0000000..8f3cd37
--- /dev/null
+++ b/internal/converter/new_features_test.go
@@ -0,0 +1,178 @@
+package converter
+
+import (
+	"testing"
+)
+
+func TestRSAEncryption(t *testing.T) {
+	converter := NewEncryptionConverter()
+
+	// Generate a test RSA key pair (2048-bit)
+	// For this test, we'll use pre-generated keys in base64 format
+	// These are minimal test keys for demonstration
+
+	// This is a test - in production, you'd generate proper keys
+	t.Run("rsa requires keys", func(t *testing.T) {
+		_, err := converter.Convert(ConversionRequest{
+			Input:  "Hello, World!",
+			Method: "rsa",
+			Config: map[string]interface{}{
+				"subMode": "encrypt",
+			},
+		})
+		if err == nil {
+			t.Error("Expected error when no public key provided")
+		}
+	})
+}
+
+func TestCurlToFetch(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "simple GET",
+			input:    "curl https://api.example.com/users",
+			expected: "fetch",
+		},
+		{
+			name:     "POST with data",
+			input:    "curl -X POST -d '{\"name\":\"test\"}' https://api.example.com/users",
+			expected: "fetch",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := curlToFetch(tc.input)
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+			if !contains(result, tc.expected) {
+				t.Errorf("Expected output to contain '%s', got:\n%s", tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestFetchToCurl(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "simple GET",
+			input:    "fetch('https://api.example.com/users')",
+			expected: "curl",
+		},
+		{
+			name:     "POST with options",
+			input:    "fetch('https://api.example.com/users', { method: 'POST', body: '{\"name\":\"test\"}' })",
+			expected: "-X POST",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := fetchToCurl(tc.input)
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+			if !contains(result, tc.expected) {
+				t.Errorf("Expected output to contain '%s', got:\n%s", tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestCronToText(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "every minute",
+			input:    "* * * * *",
+			expected: "Every minute",
+		},
+		{
+			name:     "every hour",
+			input:    "0 * * * *",
+			expected: "Every hour",
+		},
+		{
+			name:     "weekdays at 9am",
+			input:    "0 9 * * 1-5",
+			expected: "Monday through Friday",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := cronToText(tc.input)
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+			if !contains(result, tc.expected) {
+				t.Errorf("Expected output to contain '%s', got: %s", tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestTextToCron(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "every minute",
+			input:    "run every minute",
+			expected: "* * * * *",
+		},
+		{
+			name:     "every hour",
+			input:    "run every hour",
+			expected: "0 * * * *",
+		},
+		{
+			name:     "weekdays at 9am",
+			input:    "At 09:00 on weekdays",
+			expected: "00 09 * * 1-5",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := textToCron(tc.input)
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+				return
+			}
+			if result != tc.expected {
+				t.Errorf("Expected '%s', got: %s", tc.expected, result)
+			}
+		})
+	}
+}
+
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsHelper(s, substr))
+}
+
+func containsHelper(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/converter/service.go b/internal/converter/service.go
index 6b45208..1f4c735 100644
--- a/internal/converter/service.go
+++ b/internal/converter/service.go
@@ -1,6 +1,7 @@
 package converter
 
 import (
+	"encoding/json"
 	"fmt"
 	"strings"
 )
@@ -34,6 +35,7 @@ func NewConverterService() ConverterService {
 
 func (s *converterService) Convert(req ConversionRequest) (string, error) {
 	category := strings.ToLower(req.Category)
+	method := strings.ToLower(req.Method)
 
 	if strings.Contains(category, "encode") {
 		return s.encoding.Convert(req)
@@ -42,6 +44,10 @@ func (s *converterService) Convert(req ConversionRequest) (string, error) {
 		return s.encryption.Convert(req)
 	}
 	if strings.Contains(category, "hash") {
+		// Special case: compute all hashes
+		if method == "all" {
+			return s.computeAllHashes(req.Input)
+		}
 		return s.hashing.Convert(req)
 	}
 	if strings.Contains(category, "convert") {
@@ -50,3 +56,38 @@ func (s *converterService) Convert(req ConversionRequest) (string, error) {
 
 	return "", fmt.Errorf("category %s not supported", req.Category)
 }
+
+// computeAllHashes computes all available hash algorithms and returns them as JSON
+func (s *converterService) computeAllHashes(input string) (string, error) {
+	hashMethods := []string{
+		"MD5", "SHA-1", "SHA-224", "SHA-256", "SHA-384", "SHA-512",
+		"SHA-3 (Keccak)", "BLAKE2b", "BLAKE3", "RIPEMD-160",
+		"CRC32", "Adler-32", "MurmurHash3", "xxHash", "FNV-1a",
+	}
+
+	results := make(map[string]string)
+
+	for _, method := range hashMethods {
+		req := ConversionRequest{
+			Input:    input,
+			Category: "Hash",
+			Method:   method,
+			Config:   make(map[string]interface{}),
+		}
+
+		result, err := s.hashing.Convert(req)
+		if err != nil {
+			results[method] = fmt.Sprintf("Error: %s", err.Error())
+		} else {
+			results[method] = result
+		}
+	}
+
+	// Marshal to JSON for structured output
+	jsonOutput, err := json.MarshalIndent(results, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal hash results: %w", err)
+	}
+
+	return string(jsonOutput), nil
+}
diff --git a/src/App.jsx b/src/App.jsx
index f147ca2..e5e72e4 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -6,13 +6,10 @@ import { Settings } from '@carbon/icons-react';
 
 // Tools Imports (Keeping all existing imports)
 import JsonFormatter from './pages/JsonFormatter';
-import Base64Converter from './pages/Base64Converter';
-import HashGenerator from './pages/HashGenerator';
 import UuidGenerator from './pages/UuidGenerator';
 import UnixTimeConverter from './pages/UnixTimeConverter';
 import JwtDebugger from './pages/JwtDebugger';
 import RegExpTester from './pages/RegExpTester';
-import HtmlEntityConverter from './pages/HtmlEntityConverter';
 import ColorConverter from './pages/ColorConverter';
 import BackslashEscaper from './pages/BackslashEscaper';
 import RandomStringGenerator from './pages/RandomStringGenerator';
@@ -28,10 +25,8 @@ import QrCodeGenerator from './pages/QrCodeGenerator';
 import MarkdownPreview from './pages/MarkdownPreview';
 import LineSortDedupe from './pages/LineSortDedupe';
 import StringInspector from './pages/StringInspector';
-import HexAsciiConverter from './pages/HexAsciiConverter';
 import PhpSerializer from './pages/PhpSerializer';
 import UrlTools from './pages/UrlTools';
-import DataConverter from './pages/DataConverter';
 import PhpJsonConverter from './pages/PhpJsonConverter';
 import AllInOneConverter from './pages/TextBasedConverter';
 
@@ -117,13 +112,10 @@ function App() {
     const renderTool = () => {
         switch (activeTool) {
             case 'json': return <JsonFormatter />;
-            case 'base64': return <Base64Converter />;
-            case 'hash': return <HashGenerator />;
             case 'uuid': return <UuidGenerator />;
             case 'unix-time': return <UnixTimeConverter />;
             case 'jwt': return <JwtDebugger />;
             case 'regexp': return <RegExpTester />;
-            case 'html-entity': return <HtmlEntityConverter />;
             case 'color': return <ColorConverter />;
             case 'escape': return <BackslashEscaper />;
             case 'random': return <RandomStringGenerator />;
@@ -139,11 +131,9 @@ function App() {
             case 'markdown': return <MarkdownPreview />;
             case 'sort': return <LineSortDedupe />;
             case 'inspector': return <StringInspector />;
-            case 'hex-ascii': return <HexAsciiConverter />;
             case 'php-ser': return <PhpSerializer />;
             case 'php-json': return <PhpJsonConverter />;
             case 'url-tools': return <UrlTools />;
-            case 'data-converter': return <DataConverter />;
             case 'text-based': return <AllInOneConverter />;
             default: return <div className="tool-container">Select a tool</div>;
         }
diff --git a/src/components/Sidebar.jsx b/src/components/Sidebar.jsx
index 7d85aa8..dd9e47b 100644
--- a/src/components/Sidebar.jsx
+++ b/src/components/Sidebar.jsx
@@ -17,21 +17,16 @@ export function Sidebar({ activeTool, setActiveTool, isVisible, toggleSidebar })
         { id: 'text-based', name: 'Text Based Converter', icon: '🔄' },
         { id: 'unix-time', name: 'Unix Time Converter', icon: '🕒' },
         { id: 'json', name: 'JSON Format/Validate', icon: '{}' },
-        { id: 'base64', name: 'Base64 Converter', icon: '64' },
         { id: 'jwt', name: 'JWT Debugger', icon: '🛡️' },
         { id: 'url-tools', name: 'URL Tools', icon: '🔗' },
-        { id: 'data-converter', name: 'Data Converter', icon: '🔄' },
-        { id: 'html-entity', name: 'HTML Entity Encode', icon: '&;' },
         { id: 'color', name: 'Color Converter', icon: '🎨' },
         { id: 'escape', name: 'Backslash Escape', icon: '\\' },
         { id: 'uuid', name: 'UUID/ULID Generator', icon: '🆔' },
-        { id: 'hash', name: 'Hash Generator', icon: '#' },
         { id: 'sql', name: 'SQL Formatter', icon: '🗄️' },
         { id: 'case', name: 'String Case', icon: 'aA' },
         { id: 'cron', name: 'Cron Job Parser', icon: '⏳' },
         { id: 'php-ser', name: 'PHP Serializer', icon: '📦' },
         { id: 'number-base', name: 'Number Base Converter', icon: '01' },
-        { id: 'hex-ascii', name: 'Hex <-> ASCII', icon: 'H' },
         { id: 'code-fmt', name: 'Code Beautify/Minify', icon: '📝' },
         { id: 'regexp', name: 'RegExp Tester', icon: '.*' },
         { id: 'diff', name: 'Text Diff Checker', icon: '⚖️' },
diff --git a/src/components/ToolUI.jsx b/src/components/ToolUI.jsx
index 49d3272..96ea558 100644
--- a/src/components/ToolUI.jsx
+++ b/src/components/ToolUI.jsx
@@ -3,7 +3,8 @@ import { TextArea, Button } from '@carbon/react';
 import { Copy } from '@carbon/icons-react';
 
 // Re-export new layout components
-export { ToolLayout, ToolLayoutToggle, ToolVerticalSplit, LAYOUT_DIRECTIONS, TOGGLE_POSITIONS } from './layout';
+export { ToolLayout, ToolLayoutToggle, ToolVerticalSplit } from './layout';
+export { LAYOUT_DIRECTIONS, TOGGLE_POSITIONS } from './layout/constants';
 export { ToolCopyButton, ToolTextArea, ToolInput, ToolInputGroup, ToolTabBar } from './inputs';
 
 export function ToolHeader({ title, description }) {
@@ -47,7 +48,7 @@ export function ToolPane({ label, value, onChange, readOnly, placeholder, onCopy
             display: 'flex',
             flexDirection: 'column',
             height: '100%',
-            minHeight: 0,
+            minHeight: '50vh',
             flex: 1
         }}>
             <div style={{
@@ -79,6 +80,7 @@ export function ToolPane({ label, value, onChange, readOnly, placeholder, onCopy
             </div>
             <div style={{ flex: 1, position: 'relative', display: 'flex', flexDirection: 'column' }}>
                 <TextArea
+                    id="tool-textarea"
                     value={value}
                     onChange={onChange}
                     readOnly={readOnly}
@@ -90,7 +92,8 @@ export function ToolPane({ label, value, onChange, readOnly, placeholder, onCopy
                         fontFamily: "'IBM Plex Mono', monospace",
                         border: '1px solid var(--cds-border-strong)',
                     }}
-                    labelText=""
+                    labelText={label || 'Text Area'}
+                    hideLabel
                     {...props}
                 />
             </div>
diff --git a/src/components/layout/ToolLayout.jsx b/src/components/layout/ToolLayout.jsx
index a1277d3..b8c6a21 100644
--- a/src/components/layout/ToolLayout.jsx
+++ b/src/components/layout/ToolLayout.jsx
@@ -95,16 +95,4 @@ export default function ToolLayout({
             </SplitComponent>
         </div>
     );
-}
-
-// Export constants for easy usage
-export const LAYOUT_DIRECTIONS = {
-    HORIZONTAL: 'horizontal',
-    VERTICAL: 'vertical'
-};
-
-export const TOGGLE_POSITIONS = {
-    TOP_RIGHT: 'top-right',
-    CONTROLS: 'controls',
-    FLOATING: 'floating'
-};
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/components/layout/ToolLayoutToggle.jsx b/src/components/layout/ToolLayoutToggle.jsx
index f8308c2..a651973 100644
--- a/src/components/layout/ToolLayoutToggle.jsx
+++ b/src/components/layout/ToolLayoutToggle.jsx
@@ -1,6 +1,7 @@
 import React from 'react';
 import { IconButton } from '@carbon/react';
 import { SplitScreen, VerticalView } from '@carbon/icons-react';
+import { TOGGLE_POSITIONS } from './constants';
 
 /**
  * Layout toggle button for switching between horizontal and vertical layouts
@@ -63,11 +64,4 @@ export default function ToolLayoutToggle({
             </IconButton>
         </div>
     );
-}
-
-// Export position constants for easy reference
-export const TOGGLE_POSITIONS = {
-    TOP_RIGHT: 'top-right',
-    CONTROLS: 'controls',
-    FLOATING: 'floating'
-};
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/components/layout/constants.js b/src/components/layout/constants.js
new file mode 100644
index 0000000..c74e898
--- /dev/null
+++ b/src/components/layout/constants.js
@@ -0,0 +1,13 @@
+// Layout constants
+// Separated to avoid Fast Refresh issues with React components
+
+export const LAYOUT_DIRECTIONS = {
+    HORIZONTAL: 'horizontal',
+    VERTICAL: 'vertical'
+};
+
+export const TOGGLE_POSITIONS = {
+    TOP_RIGHT: 'top-right',
+    CONTROLS: 'controls',
+    FLOATING: 'floating'
+};
diff --git a/src/components/layout/index.js b/src/components/layout/index.js
index 796c981..c247077 100644
--- a/src/components/layout/index.js
+++ b/src/components/layout/index.js
@@ -2,4 +2,4 @@
 export { default as ToolLayout } from './ToolLayout';
 export { default as ToolLayoutToggle } from './ToolLayoutToggle';
 export { default as ToolVerticalSplit } from './ToolVerticalSplit';
-export { LAYOUT_DIRECTIONS, TOGGLE_POSITIONS } from './ToolLayout';
\ No newline at end of file
+export { LAYOUT_DIRECTIONS, TOGGLE_POSITIONS } from './constants';
diff --git a/src/pages/Base64Converter.jsx b/src/pages/Base64Converter.jsx
deleted file mode 100644
index a3480fe..0000000
--- a/src/pages/Base64Converter.jsx
+++ /dev/null
@@ -1,107 +0,0 @@
-import React, { useState } from 'react';
-import { Tabs, Tab, TabList, TabPanels, TabPanel, RadioButtonGroup, RadioButton } from '@carbon/react';
-import { Image as ImageIcon, Document } from '@carbon/icons-react';
-import { ToolHeader, ToolControls, ToolPane, ToolSplitPane } from '../components/ToolUI';
-
-export default function Base64Converter() {
-    const [input, setInput] = useState('');
-    const [output, setOutput] = useState('');
-    const [mode, setMode] = useState('encode');
-    const [imgSrc, setImgSrc] = useState('');
-
-    const processText = (text, currentMode) => {
-        try {
-            setInput(text);
-            if (!text) { setOutput(''); return; }
-            if (currentMode === 'encode') {
-                setOutput(btoa(text));
-            } else {
-                setOutput(atob(text));
-            }
-        } catch (e) {
-            setOutput('Error: Invalid input for ' + currentMode);
-        }
-    };
-
-    const handleFileUpload = (e) => {
-        const file = e.target.files[0];
-        if (!file) return;
-        const reader = new FileReader();
-        reader.onloadend = () => setImgSrc(reader.result);
-        reader.readAsDataURL(file);
-    };
-
-    return (
-        <div className="tool-container">
-            <ToolHeader title="Base64 Converter" description="Encode and decode Base64 strings and images." />
-
-            <Tabs>
-                <TabList aria-label="Base64 Converter Tabs">
-                    <Tab renderIcon={Document}>String</Tab>
-                    <Tab renderIcon={ImageIcon}>Image</Tab>
-                </TabList>
-                <TabPanels>
-                    <TabPanel>
-                        <div style={{ display: 'flex', flexDirection: 'column', height: '100%', paddingTop: '1rem' }}>
-                            <ToolControls>
-                                <RadioButtonGroup
-                                    legendText="Mode"
-                                    name="mode-radio-group"
-                                    defaultSelected="encode"
-                                    onChange={(val) => { setMode(val); processText(input, val); }}
-                                    orientation="horizontal"
-                                >
-                                    <RadioButton labelText="Encode" value="encode" id="b64-enc" />
-                                    <RadioButton labelText="Decode" value="decode" id="b64-dec" />
-                                </RadioButtonGroup>
-                            </ToolControls>
-
-                            <ToolSplitPane>
-                                <ToolPane
-                                    label="Input"
-                                    value={input}
-                                    onChange={(e) => processText(e.target.value, mode)}
-                                    placeholder={mode === 'encode' ? "Text to encode..." : "Base64 to decode..."}
-                                />
-                                <ToolPane
-                                    label="Output"
-                                    value={output}
-                                    readOnly
-                                />
-                            </ToolSplitPane>
-                        </div>
-                    </TabPanel>
-
-                    <TabPanel>
-                        <div style={{ display: 'flex', flexDirection: 'column', height: '100%', paddingTop: '1rem' }}>
-                            <ToolSplitPane>
-                                <div className="pane">
-                                    <label style={{ fontSize: '0.75rem', fontWeight: 400, color: 'var(--cds-text-secondary)', marginBottom: '0.5rem', textTransform: 'uppercase' }}>
-                                        Upload Image
-                                    </label>
-                                    <div style={{ padding: '20px', border: '1px dashed var(--cds-border-strong)', borderRadius: '6px', textAlign: 'center', background: 'var(--cds-layer)' }}>
-                                        <input type="file" onChange={handleFileUpload} accept="image/*" />
-                                    </div>
-                                </div>
-                                <div style={{ display: 'flex', flexDirection: 'column', gap: '1rem' }}>
-                                    <ToolPane
-                                        label="Base64 Output"
-                                        value={imgSrc}
-                                        readOnly
-                                        placeholder="Base64 string will appear here..."
-                                    />
-                                    {imgSrc && (
-                                        <div style={{ textAlign: 'center', border: '1px solid var(--cds-border-subtle)', padding: '10px', borderRadius: '4px' }}>
-                                            <p style={{ color: 'var(--text-secondary)', marginBottom: '10px', fontSize: '0.75rem' }}>Preview</p>
-                                            <img src={imgSrc} alt="Preview" style={{ maxWidth: '100%', maxHeight: '200px' }} />
-                                        </div>
-                                    )}
-                                </div>
-                            </ToolSplitPane>
-                        </div>
-                    </TabPanel>
-                </TabPanels>
-            </Tabs>
-        </div>
-    );
-}
diff --git a/src/pages/DataConverter.jsx b/src/pages/DataConverter.jsx
deleted file mode 100644
index 00549a8..0000000
--- a/src/pages/DataConverter.jsx
+++ /dev/null
@@ -1,164 +0,0 @@
-import React, { useState } from 'react';
-import yaml from 'js-yaml';
-import Papa from 'papaparse';
-import { Select, SelectItem, Button, TextArea } from '@carbon/react';
-import { ArrowRight, Copy } from '@carbon/icons-react';
-
-// Basic PHP/JSON logic
-const cheapPhpToJson = (phpStr) => {
-    try {
-        let s = phpStr.trim();
-        if (s.startsWith('array(') && s.endsWith(')')) return "Not supported (Old syntax)";
-        s = s.replace(/['"]?([\w\d_-]+)['"]?\s*=>/g, '"$1":');
-        s = s.replace(/=>/g, ':');
-        s = s.replace(/'/g, '"');
-        s = s.replace(/,\s*]/g, ']');
-        s = s.replace(/,\s*}/g, '}');
-        const obj = JSON.parse(s);
-        return JSON.stringify(obj, null, 2);
-    } catch (e) { throw new Error("Parse Error"); }
-}
-const jsonToPhp = (jsonStr) => {
-    const toPhp = (o, indent = '') => {
-        if (typeof o === 'string') return `'${o.replace(/'/g, "\\'")}'`;
-        if (typeof o === 'number' || typeof o === 'boolean' || o === null) return String(o);
-        if (Array.isArray(o)) {
-            const lines = o.map(v => `${indent}  ${toPhp(v, indent + '  ')},`);
-            return `[\n${lines.join('\n')}\n${indent}]`;
-        }
-        if (typeof o === 'object') {
-            const lines = Object.entries(o).map(([k, v]) => `${indent}  '${k}' => ${toPhp(v, indent + '  ')},`);
-            return `[\n${lines.join('\n')}\n${indent}]`;
-        }
-    };
-    return toPhp(JSON.parse(jsonStr));
-}
-
-export default function DataConverter() {
-    const [input, setInput] = useState('');
-    const [output, setOutput] = useState('');
-    const [sourceFmt, setSourceFmt] = useState('json');
-    const [targetFmt, setTargetFmt] = useState('yaml');
-    const [error, setError] = useState('');
-
-    const formats = [
-        { id: 'json', name: 'JSON' },
-        { id: 'yaml', name: 'YAML' },
-        { id: 'csv', name: 'CSV' },
-        { id: 'php', name: 'PHP Array' },
-    ];
-
-    const convert = () => {
-        if (!input.trim()) { setOutput(''); return; }
-        setError('');
-
-        try {
-            // 1. Parse Source to JS Object
-            let data;
-            try {
-                switch (sourceFmt) {
-                    case 'json': data = JSON.parse(input); break;
-                    case 'yaml': data = yaml.load(input); break;
-                    case 'csv':
-                        const csvRes = Papa.parse(input, { header: true, skipEmptyLines: true });
-                        if (csvRes.errors.length) throw new Error(csvRes.errors[0].message);
-                        data = csvRes.data;
-                        break;
-                    case 'php':
-                        const res = cheapPhpToJson(input);
-                        data = JSON.parse(res);
-                        break;
-                    default: throw new Error("Unknown source format");
-                }
-            } catch (e) { throw new Error(`Failed to parse ${sourceFmt.toUpperCase()}: ${e.message}`); }
-
-            // 2. Stringify Object to Target
-            let res = '';
-            switch (targetFmt) {
-                case 'json': res = JSON.stringify(data, null, 2); break;
-                case 'yaml': res = yaml.dump(data); break;
-                case 'csv': res = Papa.unparse(data); break;
-                case 'php': res = jsonToPhp(JSON.stringify(data)); break;
-                default: throw new Error("Unknown target format");
-            }
-            setOutput(res);
-
-        } catch (e) {
-            setError(e.message);
-        }
-    };
-
-    return (
-        <div className="tool-container">
-            <div className="tool-header">
-                <h2 className="tool-title">Data Converter</h2>
-                <p className="tool-desc">Convert between JSON, YAML, CSV, and PHP Arrays.</p>
-            </div>
-
-            <div className="controls" style={{ alignItems: 'flex-end', gap: '1rem' }}>
-                <Select
-                    id="src-fmt"
-                    labelText="From"
-                    value={sourceFmt}
-                    onChange={(e) => setSourceFmt(e.target.value)}
-                    style={{ width: '150px' }}
-                >
-                    {formats.map(f => <SelectItem key={f.id} value={f.id} text={f.name} />)}
-                </Select>
-
-                <div style={{ paddingBottom: '0.5rem' }}>
-                    <ArrowRight size={24} fill="var(--cds-text-secondary)" />
-                </div>
-
-                <Select
-                    id="target-fmt"
-                    labelText="To"
-                    value={targetFmt}
-                    onChange={(e) => setTargetFmt(e.target.value)}
-                    style={{ width: '150px' }}
-                >
-                    {formats.map(f => <SelectItem key={f.id} value={f.id} text={f.name} />)}
-                </Select>
-
-                <Button onClick={convert}>Convert</Button>
-            </div>
-            {error && <div style={{ color: 'var(--cds-support-error)', marginBottom: '10px' }}>{error}</div>}
-
-            <div className="split-pane">
-                <div className="pane">
-                    <TextArea
-                        labelText={`${formats.find(f => f.id === sourceFmt).name} Input`}
-                        value={input}
-                        onChange={(e) => setInput(e.target.value)}
-                        rows={20}
-                        style={{ height: '100%' }}
-                    />
-                </div>
-                <div className="pane">
-                    <div style={{ position: 'relative', height: '100%' }}>
-                        <TextArea
-                            labelText={`${formats.find(f => f.id === targetFmt).name} Output`}
-                            value={output}
-                            readOnly
-                            rows={20}
-                            style={{ height: '100%' }}
-                        />
-                        {output && (
-                            <Button
-                                hasIconOnly
-                                renderIcon={Copy}
-                                tooltipAlignment="end"
-                                tooltipPosition="left"
-                                iconDescription="Copy"
-                                kind="ghost"
-                                size="sm"
-                                onClick={() => navigator.clipboard.writeText(output)}
-                                style={{ position: 'absolute', top: '24px', right: '0' }}
-                            />
-                        )}
-                    </div>
-                </div>
-            </div>
-        </div>
-    );
-}
diff --git a/src/pages/HashGenerator.jsx b/src/pages/HashGenerator.jsx
deleted file mode 100644
index 33f1cf7..0000000
--- a/src/pages/HashGenerator.jsx
+++ /dev/null
@@ -1,80 +0,0 @@
-import React, { useState } from 'react';
-import { TextArea, TextInput, Button, ButtonSet } from '@carbon/react';
-import { Copy, Script } from '@carbon/icons-react';
-
-export default function HashGenerator() {
-    const [input, setInput] = useState('');
-    const [hashes, setHashes] = useState({
-        sha256: '',
-        sha384: '',
-        sha512: ''
-    });
-
-    const generateHashes = async (text) => {
-        setInput(text);
-        if (!text) {
-            setHashes({ sha256: '', sha384: '', sha512: '' });
-            return;
-        }
-
-        const encoder = new TextEncoder();
-        const data = encoder.encode(text);
-
-        const hashBuffer256 = await crypto.subtle.digest('SHA-256', data);
-        const hashBuffer384 = await crypto.subtle.digest('SHA-384', data);
-        const hashBuffer512 = await crypto.subtle.digest('SHA-512', data);
-
-        setHashes({
-            sha256: Array.from(new Uint8Array(hashBuffer256)).map(b => b.toString(16).padStart(2, '0')).join(''),
-            sha384: Array.from(new Uint8Array(hashBuffer384)).map(b => b.toString(16).padStart(2, '0')).join(''),
-            sha512: Array.from(new Uint8Array(hashBuffer512)).map(b => b.toString(16).padStart(2, '0')).join('')
-        });
-    };
-
-    return (
-        <div className="tool-container">
-            <div className="tool-header">
-                <h2 className="tool-title">Hash Generator</h2>
-                <p className="tool-desc">Generate SHA hashes.</p>
-            </div>
-
-            <div style={{ display: 'flex', flexDirection: 'row', gap: '24px', height: '100%', flexWrap: 'wrap' }}>
-                <div style={{ flex: '1', minWidth: '300px' }}>
-                    <TextArea
-                        labelText="Input Text"
-                        placeholder="Text to hash..."
-                        value={input}
-                        onChange={(e) => generateHashes(e.target.value)}
-                        rows={20}
-                        style={{ height: '100%' }}
-                    />
-                </div>
-
-                <div style={{ flex: '1', minWidth: '300px', display: 'flex', flexDirection: 'column', gap: '24px' }}>
-                    {['256', '384', '512'].map(algo => (
-                        <div key={algo} style={{ position: 'relative' }}>
-                            <TextInput
-                                id={`sha${algo}`}
-                                labelText={`SHA-${algo}`}
-                                value={hashes[`sha${algo}`]}
-                                readOnly
-                            />
-                            {hashes[`sha${algo}`] && (
-                                <Button
-                                    hasIconOnly
-                                    renderIcon={Copy}
-                                    kind="ghost"
-                                    size="sm"
-                                    iconDescription="Copy"
-                                    tooltipAlignment="end"
-                                    onClick={() => navigator.clipboard.writeText(hashes[`sha${algo}`])}
-                                    style={{ position: 'absolute', top: '24px', right: '0' }}
-                                />
-                            )}
-                        </div>
-                    ))}
-                </div>
-            </div>
-        </div>
-    );
-}
diff --git a/src/pages/HexAsciiConverter.jsx b/src/pages/HexAsciiConverter.jsx
deleted file mode 100644
index 42adc5f..0000000
--- a/src/pages/HexAsciiConverter.jsx
+++ /dev/null
@@ -1,47 +0,0 @@
-import React, { useState } from 'react';
-import { ToolHeader, ToolPane, ToolSplitPane } from '../components/ToolUI';
-
-export default function HexAsciiConverter() {
-    const [hex, setHex] = useState('');
-    const [ascii, setAscii] = useState('');
-
-    const fromHex = (val) => {
-        setHex(val);
-        const clean = val.replace(/[^0-9a-fA-F]/g, '');
-        let str = '';
-        for (let i = 0; i < clean.length; i += 2) {
-            str += String.fromCharCode(parseInt(clean.substr(i, 2), 16));
-        }
-        setAscii(str);
-    };
-
-    const fromAscii = (val) => {
-        setAscii(val);
-        let str = '';
-        for (let i = 0; i < val.length; i++) {
-            str += val.charCodeAt(i).toString(16).padStart(2, '0') + ' ';
-        }
-        setHex(str.trim());
-    };
-
-    return (
-        <div className="tool-container">
-            <ToolHeader title="Hex / ASCII Converter" description="Convert between Hexadecimal strings and ASCII text." />
-
-            <ToolSplitPane>
-                <ToolPane
-                    label="Hexadecimal"
-                    value={hex}
-                    onChange={(e) => fromHex(e.target.value)}
-                    placeholder="48 65 6c 6c 6f..."
-                />
-                <ToolPane
-                    label="ASCII"
-                    value={ascii}
-                    onChange={(e) => fromAscii(e.target.value)}
-                    placeholder="Hello..."
-                />
-            </ToolSplitPane>
-        </div>
-    );
-}
diff --git a/src/pages/HtmlEntityConverter.jsx b/src/pages/HtmlEntityConverter.jsx
deleted file mode 100644
index 7424134..0000000
--- a/src/pages/HtmlEntityConverter.jsx
+++ /dev/null
@@ -1,66 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { RadioButtonGroup, RadioButton } from '@carbon/react';
-import { ToolHeader, ToolControls, ToolPane, ToolSplitPane } from '../components/ToolUI';
-
-export default function HtmlEntityConverter() {
-    const [input, setInput] = useState('');
-    const [output, setOutput] = useState('');
-    const [mode, setMode] = useState('encode');
-    const [error, setError] = useState('');
-
-    const process = (val, currentMode) => {
-        try {
-            let result;
-            if (currentMode === 'encode') {
-                result = (val || '').replace(/[\u00A0-\u9999<>&]/g, (i) => '&#' + i.charCodeAt(0) + ';');
-            } else {
-                const doc = new DOMParser().parseFromString(val || '', "text/html");
-                result = doc.documentElement.textContent;
-            }
-            setOutput(result);
-            setError('');
-        } catch (e) {
-            setError('Error: ' + e.message);
-            setOutput('');
-        }
-    };
-    
-    useEffect(() => {
-        process(input, mode);
-    }, [input, mode]);
-
-    return (
-        <div className="tool-container">
-            <ToolHeader title="HTML Entity Converter" description="Encode or decode HTML entities." />
-
-            <ToolControls>
-                <RadioButtonGroup
-                    name="mode"
-                    legendText="Mode"
-                    value={mode}
-                    onChange={setMode}
-                    orientation="horizontal"
-                >
-                    <RadioButton labelText="Encode" value="encode" id="encode-radio" />
-                    <RadioButton labelText="Decode" value="decode" id="decode-radio" />
-                </RadioButtonGroup>
-            </ToolControls>
-
-            {error && <div style={{ color: 'var(--cds-support-error)', marginBottom: '1rem' }}>{error}</div>}
-
-            <ToolSplitPane>
-                <ToolPane
-                    label="Input"
-                    value={input}
-                    onChange={(e) => setInput(e.target.value)}
-                    placeholder="Paste text here..."
-                />
-                <ToolPane
-                    label="Output"
-                    value={output}
-                    readOnly
-                />
-            </ToolSplitPane>
-        </div>
-    );
-}
diff --git a/src/pages/TextBasedConverter/components/ConversionControls.jsx b/src/pages/TextBasedConverter/components/ConversionControls.jsx
index f9f1ee4..0d0c23f 100644
--- a/src/pages/TextBasedConverter/components/ConversionControls.jsx
+++ b/src/pages/TextBasedConverter/components/ConversionControls.jsx
@@ -1,7 +1,7 @@
 import { Button, Dropdown, Toggle, RadioButtonGroup, RadioButton } from '@carbon/react';
 import { ToolLayoutToggle } from '../../../components/ToolUI';
 import { ArrowsHorizontal, Play } from '@carbon/icons-react';
-import { CONVERTER_MAP } from '../index';
+import { CONVERTER_MAP } from '../constants';
 
 export default function ConversionControls({
     category,
@@ -14,6 +14,7 @@ export default function ConversionControls({
     autoRun,
     setAutoRun,
     onConvert,
+    isAllHashes = false,
 }) {
     const categories = Object.keys(CONVERTER_MAP);
     const methods = CONVERTER_MAP[category] || [];
@@ -49,7 +50,7 @@ export default function ConversionControls({
                     />
                 </div>
 
-                <div style={{ width: '220px' }}>
+                <div style={{ width: '280px' }}>
                     <Dropdown
                         id="method-select"
                         titleText="Algorithm / Method"
diff --git a/src/pages/TextBasedConverter/components/MultiHashOutput.jsx b/src/pages/TextBasedConverter/components/MultiHashOutput.jsx
new file mode 100644
index 0000000..27b2f2c
--- /dev/null
+++ b/src/pages/TextBasedConverter/components/MultiHashOutput.jsx
@@ -0,0 +1,110 @@
+import { useState } from 'react';
+import { CopyButton, TextInput } from '@carbon/react';
+
+const HASH_DISPLAY_ORDER = [
+    'MD5', 'SHA-1', 'SHA-224', 'SHA-256', 'SHA-384', 'SHA-512',
+    'SHA-3 (Keccak)', 'BLAKE2b', 'BLAKE3', 'RIPEMD-160',
+    'CRC32', 'Adler-32', 'MurmurHash3', 'xxHash', 'FNV-1a',
+];
+
+export default function MultiHashOutput({ value, error, onCopy }) {
+    const [copiedHash, setCopiedHash] = useState(null);
+
+    if (error) {
+        return (
+            <div style={{
+                padding: '1rem',
+                color: 'var(--cds-text-error)',
+                backgroundColor: 'var(--cds-layer)'
+            }}>
+                {error}
+            </div>
+        );
+    }
+
+    if (!value) {
+        return (
+            <div style={{
+            }}>
+            </div>
+        );
+    }
+
+    let hashes;
+    try {
+        hashes = JSON.parse(value);
+    } catch (e) {
+        return (
+            <div style={{
+                padding: '1rem',
+                color: 'var(--cds-text-error)',
+                backgroundColor: 'var(--cds-layer)'
+            }}>
+                Error parsing hash results: {e.message}
+            </div>
+        );
+    }
+
+    const handleCopy = (hashName, hashValue) => {
+        navigator.clipboard.writeText(hashValue);
+        setCopiedHash(hashName);
+        setTimeout(() => setCopiedHash(null), 2000);
+        if (onCopy) onCopy(hashName, hashValue);
+    };
+
+    return (
+        <div style={{
+            display: 'grid',
+            gridTemplateColumns: 'repeat(auto-fit, minmax(400px, 1fr))',
+            gap: '0.75rem',
+            maxHeight: '80vh',
+            overflowY: 'auto',
+        }}>
+            {HASH_DISPLAY_ORDER.map((hashName) => {
+                const hashValue = hashes[hashName];
+                if (!hashValue) return null;
+
+                const isError = hashValue.startsWith('Error:');
+
+                return (
+                    <div
+                        key={hashName}
+                    >
+                        <div style={{
+                            display: 'flex',
+                            justifyContent: 'space-between',
+                            alignItems: 'center',
+                        }}>
+                            <span style={{
+                                fontWeight: '600',
+                                fontSize: '0.875rem',
+                                color: 'var(--cds-text-primary)',
+                            }}>
+                                {hashName}
+                            </span>
+                            <CopyButton
+                                onClick={() => handleCopy(hashName, hashValue)}
+                                feedback={copiedHash === hashName ? 'Copied!' : 'Copy'}
+                                feedbackTimeout={2000}
+                            />
+                        </div>
+                        <TextInput
+                            id={`hash-${hashName}`}
+                            labelText={hashName}
+                            hideLabel
+                            value={hashValue}
+                            readOnly
+                            style={{
+                                fontFamily: "'IBM Plex Mono', monospace",
+                                fontSize: '12px',
+                                backgroundColor: 'var(--cds-field)',
+                                border: '1px solid var(--cds-border-subtle)',
+                                color: isError ? 'var(--cds-text-error)' : 'var(--cds-text-primary)',
+                            }}
+                        />
+                    </div>
+                );
+            })}
+        </div>
+    );
+}
diff --git a/src/pages/TextBasedConverter/constants.js b/src/pages/TextBasedConverter/constants.js
new file mode 100644
index 0000000..5ca7466
--- /dev/null
+++ b/src/pages/TextBasedConverter/constants.js
@@ -0,0 +1,31 @@
+// Converter configuration constants
+// Separated from index.jsx to avoid Fast Refresh issues
+
+export const CONVERTER_MAP = {
+    'Encrypt - Decrypt': [
+        'AES', 'AES-GCM', 'DES', 'Triple DES', 'Rabbit', 'RC4', 'RC4Drop',
+        'ChaCha20', 'Salsa20', 'Blowfish', 'Twofish', 'RSA',
+        'Fernet', 'BIP38', 'XOR'
+    ],
+    'Encode - Decode': [
+        'Base16 (Hex)', 'Base32', 'Base58', 'Base64', 'Base64URL',
+        'Base85', 'URL', 'HTML Entities', 'Binary', 'Morse Code',
+        'Punnycode', 'JWT Decode', 'Bencoded', 'Protobuf',
+        'ROT13', 'ROT47', 'Quoted-Printable'
+    ],
+    'Convert': [
+        'JSON ↔ YAML', 'JSON ↔ XML', 'JSON ↔ CSV / TSV', 'YAML ↔ TOML',
+        'Markdown ↔ HTML', 'Unix Timestamp ↔ ISO 8601', 'Color Codes',
+        'Number Bases', 'Case Swapping', 'SQL Insert ↔ JSON Array',
+        'CURL Command ↔ Fetch', 'Cron Expression ↔ Text',
+        'CSV ↔ TSV', 'Key-Value ↔ Query String',
+        'Properties ↔ JSON', 'INI ↔ JSON'
+    ],
+    'Hash': [
+        'All',
+        'MD5', 'SHA-1', 'SHA-224', 'SHA-256', 'SHA-384', 'SHA-512',
+        'SHA-3 (Keccak)', 'BLAKE2b', 'BLAKE3', 'RIPEMD-160',
+        'bcrypt', 'scrypt', 'Argon2', 'HMAC', 'CRC32', 'Adler-32',
+        'MurmurHash3', 'xxHash', 'FNV-1a'
+    ],
+};
diff --git a/src/pages/TextBasedConverter/index.jsx b/src/pages/TextBasedConverter/index.jsx
index e32c6ad..5b04d35 100644
--- a/src/pages/TextBasedConverter/index.jsx
+++ b/src/pages/TextBasedConverter/index.jsx
@@ -6,31 +6,8 @@ import useLayoutToggle from '../../hooks/useLayoutToggle';
 import { Backend } from '../../utils/backendBridge';
 import ConversionControls from './components/ConversionControls';
 import ConfigurationPane from './components/ConfigurationPane';
-
-export const CONVERTER_MAP = {
-    'Encrypt - Decrypt': [
-        'AES', 'DES', 'Triple DES', 'Rabbit', 'RC4', 'RC4Drop',
-        'ChaCha20', 'Salsa20', 'Blowfish', 'Twofish', 'RSA',
-        'Fernet', 'BIP38', 'XOR'
-    ],
-    'Encode - Decode': [
-        'Base16 (Hex)', 'Base32', 'Base58', 'Base64', 'Base64URL',
-        'Base85', 'URL', 'HTML Entities', 'Binary', 'Morse Code',
-        'Punnycode', 'JWT Decode', 'Bencoded', 'Protobuf'
-    ],
-    'Convert': [
-        'JSON ↔ YAML', 'JSON ↔ XML', 'JSON ↔ CSV / TSV', 'YAML ↔ TOML',
-        'Markdown ↔ HTML', 'Unix Timestamp ↔ ISO 8601', 'Color Codes',
-        'Number Bases', 'Case Swapping', 'SQL Insert ↔ JSON Array',
-        'CURL Command ↔ Fetch', 'Cron Expression ↔ Text'
-    ],
-    'Hash': [
-        'MD5', 'SHA-1', 'SHA-224', 'SHA-256', 'SHA-384', 'SHA-512',
-        'SHA-3 (Keccak)', 'BLAKE2b', 'BLAKE3', 'RIPEMD-160',
-        'bcrypt', 'scrypt', 'Argon2', 'HMAC', 'CRC32', 'Adler-32',
-        'MurmurHash3'
-    ],
-};
+import MultiHashOutput from './components/MultiHashOutput';
+import { CONVERTER_MAP } from './constants';
 
 export default function TextBasedConverter() {
     // Persistent state initialization
@@ -63,6 +40,9 @@ export default function TextBasedConverter() {
         persist: true
     });
 
+    // Check if showing all hashes
+    const isAllHashes = category === 'Hash' && method === 'All';
+
     // Submode default logic
     useEffect(() => {
         if (category === 'Encrypt - Decrypt' && !['Encrypt', 'Decrypt'].includes(subMode)) {
@@ -87,6 +67,13 @@ export default function TextBasedConverter() {
             return;
         }
 
+        // For All Hashes, we compute even with empty input (show empty results)
+        if (!text && cat === 'Hash' && meth === 'All') {
+            setOutput('');
+            setError('');
+            return;
+        }
+
         try {
             // Include subMode in backend request
             const backendConfig = { ...cfg, subMode: sub };
@@ -115,7 +102,7 @@ export default function TextBasedConverter() {
     const updateConfig = (newCfg) => setConfig(prev => ({ ...prev, ...newCfg }));
 
     // Determine if Key/IV pane should be shown
-    const showConfig = category === 'Encrypt - Decrypt';
+    const showConfig = category === 'Encrypt - Decrypt' || method === 'HMAC';
 
     return (
         <div className="tool-container" style={{ display: 'flex', flexDirection: 'column', gap: '0.75rem', height: '100%' }}>
@@ -135,6 +122,7 @@ export default function TextBasedConverter() {
                 autoRun={config.autoRun}
                 setAutoRun={(val) => updateConfig({ autoRun: val })}
                 onConvert={handleConvert}
+                isAllHashes={isAllHashes}
             />
 
             {showConfig && (
@@ -153,15 +141,53 @@ export default function TextBasedConverter() {
                     placeholder="Enter text here..."
                 />
 
-
-                <ToolPane
-                    label="Output"
-                    value={output}
-                    readOnly
-                    placeholder="Result will appear here..."
-                    invalid={!!error}
-                    invalidText={error}
-                />
+                {isAllHashes ? (
+                    <div className="pane" style={{
+                        display: 'flex',
+                        flexDirection: 'column',
+                        height: '100%',
+                        minHeight: 0,
+                        flex: 1
+                    }}>
+                        <div style={{
+                            display: 'flex',
+                            justifyContent: 'space-between',
+                            alignItems: 'center',
+                            minHeight: '30px'
+                        }}>
+                            <label style={{
+                                fontSize: '0.75rem',
+                                fontWeight: 400,
+                                lineHeight: 1.5,
+                                letterSpacing: '0.32px',
+                                color: 'var(--cds-text-secondary)',
+                                textTransform: 'uppercase'
+                            }}>
+                                Output
+                            </label>
+                        </div>
+                        <div style={{
+                            flex: 1,
+                            overflowY: 'auto',
+                            padding: '0.75rem',
+                            backgroundColor: 'var(--cds-layer)',
+                        }}>
+                            <MultiHashOutput
+                                value={output}
+                                error={error}
+                            />
+                        </div>
+                    </div>
+                ) : (
+                    <ToolPane
+                        label="Output"
+                        value={output}
+                        readOnly
+                        placeholder="Result will appear here..."
+                        invalid={!!error}
+                        invalidText={error}
+                    />
+                )}
             </ToolSplitPane>
         </div>
     );
diff --git a/wailsjs/runtime/package.json b/wailsjs/runtime/package.json
deleted file mode 100644
index 1e7c8a5..0000000
--- a/wailsjs/runtime/package.json
+++ /dev/null
@@ -1,24 +0,0 @@
-{
-  "name": "@wailsapp/runtime",
-  "version": "2.0.0",
-  "description": "Wails Javascript runtime library",
-  "main": "runtime.js",
-  "types": "runtime.d.ts",
-  "scripts": {
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/wailsapp/wails.git"
-  },
-  "keywords": [
-    "Wails",
-    "Javascript",
-    "Go"
-  ],
-  "author": "Lea Anthony <lea.anthony@gmail.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/wailsapp/wails/issues"
-  },
-  "homepage": "https://github.com/wailsapp/wails#readme"
-}
diff --git a/wailsjs/runtime/runtime.d.ts b/wailsjs/runtime/runtime.d.ts
deleted file mode 100644
index 4445dac..0000000
--- a/wailsjs/runtime/runtime.d.ts
+++ /dev/null
@@ -1,249 +0,0 @@
-/*
- _       __      _ __
-| |     / /___ _(_) /____
-| | /| / / __ `/ / / ___/
-| |/ |/ / /_/ / / (__  )
-|__/|__/\__,_/_/_/____/
-The electron alternative for Go
-(c) Lea Anthony 2019-present
-*/
-
-export interface Position {
-    x: number;
-    y: number;
-}
-
-export interface Size {
-    w: number;
-    h: number;
-}
-
-export interface Screen {
-    isCurrent: boolean;
-    isPrimary: boolean;
-    width : number
-    height : number
-}
-
-// Environment information such as platform, buildtype, ...
-export interface EnvironmentInfo {
-    buildType: string;
-    platform: string;
-    arch: string;
-}
-
-// [EventsEmit](https://wails.io/docs/reference/runtime/events#eventsemit)
-// emits the given event. Optional data may be passed with the event.
-// This will trigger any event listeners.
-export function EventsEmit(eventName: string, ...data: any): void;
-
-// [EventsOn](https://wails.io/docs/reference/runtime/events#eventson) sets up a listener for the given event name.
-export function EventsOn(eventName: string, callback: (...data: any) => void): () => void;
-
-// [EventsOnMultiple](https://wails.io/docs/reference/runtime/events#eventsonmultiple)
-// sets up a listener for the given event name, but will only trigger a given number times.
-export function EventsOnMultiple(eventName: string, callback: (...data: any) => void, maxCallbacks: number): () => void;
-
-// [EventsOnce](https://wails.io/docs/reference/runtime/events#eventsonce)
-// sets up a listener for the given event name, but will only trigger once.
-export function EventsOnce(eventName: string, callback: (...data: any) => void): () => void;
-
-// [EventsOff](https://wails.io/docs/reference/runtime/events#eventsoff)
-// unregisters the listener for the given event name.
-export function EventsOff(eventName: string, ...additionalEventNames: string[]): void;
-
-// [EventsOffAll](https://wails.io/docs/reference/runtime/events#eventsoffall)
-// unregisters all listeners.
-export function EventsOffAll(): void;
-
-// [LogPrint](https://wails.io/docs/reference/runtime/log#logprint)
-// logs the given message as a raw message
-export function LogPrint(message: string): void;
-
-// [LogTrace](https://wails.io/docs/reference/runtime/log#logtrace)
-// logs the given message at the `trace` log level.
-export function LogTrace(message: string): void;
-
-// [LogDebug](https://wails.io/docs/reference/runtime/log#logdebug)
-// logs the given message at the `debug` log level.
-export function LogDebug(message: string): void;
-
-// [LogError](https://wails.io/docs/reference/runtime/log#logerror)
-// logs the given message at the `error` log level.
-export function LogError(message: string): void;
-
-// [LogFatal](https://wails.io/docs/reference/runtime/log#logfatal)
-// logs the given message at the `fatal` log level.
-// The application will quit after calling this method.
-export function LogFatal(message: string): void;
-
-// [LogInfo](https://wails.io/docs/reference/runtime/log#loginfo)
-// logs the given message at the `info` log level.
-export function LogInfo(message: string): void;
-
-// [LogWarning](https://wails.io/docs/reference/runtime/log#logwarning)
-// logs the given message at the `warning` log level.
-export function LogWarning(message: string): void;
-
-// [WindowReload](https://wails.io/docs/reference/runtime/window#windowreload)
-// Forces a reload by the main application as well as connected browsers.
-export function WindowReload(): void;
-
-// [WindowReloadApp](https://wails.io/docs/reference/runtime/window#windowreloadapp)
-// Reloads the application frontend.
-export function WindowReloadApp(): void;
-
-// [WindowSetAlwaysOnTop](https://wails.io/docs/reference/runtime/window#windowsetalwaysontop)
-// Sets the window AlwaysOnTop or not on top.
-export function WindowSetAlwaysOnTop(b: boolean): void;
-
-// [WindowSetSystemDefaultTheme](https://wails.io/docs/next/reference/runtime/window#windowsetsystemdefaulttheme)
-// *Windows only*
-// Sets window theme to system default (dark/light).
-export function WindowSetSystemDefaultTheme(): void;
-
-// [WindowSetLightTheme](https://wails.io/docs/next/reference/runtime/window#windowsetlighttheme)
-// *Windows only*
-// Sets window to light theme.
-export function WindowSetLightTheme(): void;
-
-// [WindowSetDarkTheme](https://wails.io/docs/next/reference/runtime/window#windowsetdarktheme)
-// *Windows only*
-// Sets window to dark theme.
-export function WindowSetDarkTheme(): void;
-
-// [WindowCenter](https://wails.io/docs/reference/runtime/window#windowcenter)
-// Centers the window on the monitor the window is currently on.
-export function WindowCenter(): void;
-
-// [WindowSetTitle](https://wails.io/docs/reference/runtime/window#windowsettitle)
-// Sets the text in the window title bar.
-export function WindowSetTitle(title: string): void;
-
-// [WindowFullscreen](https://wails.io/docs/reference/runtime/window#windowfullscreen)
-// Makes the window full screen.
-export function WindowFullscreen(): void;
-
-// [WindowUnfullscreen](https://wails.io/docs/reference/runtime/window#windowunfullscreen)
-// Restores the previous window dimensions and position prior to full screen.
-export function WindowUnfullscreen(): void;
-
-// [WindowIsFullscreen](https://wails.io/docs/reference/runtime/window#windowisfullscreen)
-// Returns the state of the window, i.e. whether the window is in full screen mode or not.
-export function WindowIsFullscreen(): Promise<boolean>;
-
-// [WindowSetSize](https://wails.io/docs/reference/runtime/window#windowsetsize)
-// Sets the width and height of the window.
-export function WindowSetSize(width: number, height: number): void;
-
-// [WindowGetSize](https://wails.io/docs/reference/runtime/window#windowgetsize)
-// Gets the width and height of the window.
-export function WindowGetSize(): Promise<Size>;
-
-// [WindowSetMaxSize](https://wails.io/docs/reference/runtime/window#windowsetmaxsize)
-// Sets the maximum window size. Will resize the window if the window is currently larger than the given dimensions.
-// Setting a size of 0,0 will disable this constraint.
-export function WindowSetMaxSize(width: number, height: number): void;
-
-// [WindowSetMinSize](https://wails.io/docs/reference/runtime/window#windowsetminsize)
-// Sets the minimum window size. Will resize the window if the window is currently smaller than the given dimensions.
-// Setting a size of 0,0 will disable this constraint.
-export function WindowSetMinSize(width: number, height: number): void;
-
-// [WindowSetPosition](https://wails.io/docs/reference/runtime/window#windowsetposition)
-// Sets the window position relative to the monitor the window is currently on.
-export function WindowSetPosition(x: number, y: number): void;
-
-// [WindowGetPosition](https://wails.io/docs/reference/runtime/window#windowgetposition)
-// Gets the window position relative to the monitor the window is currently on.
-export function WindowGetPosition(): Promise<Position>;
-
-// [WindowHide](https://wails.io/docs/reference/runtime/window#windowhide)
-// Hides the window.
-export function WindowHide(): void;
-
-// [WindowShow](https://wails.io/docs/reference/runtime/window#windowshow)
-// Shows the window, if it is currently hidden.
-export function WindowShow(): void;
-
-// [WindowMaximise](https://wails.io/docs/reference/runtime/window#windowmaximise)
-// Maximises the window to fill the screen.
-export function WindowMaximise(): void;
-
-// [WindowToggleMaximise](https://wails.io/docs/reference/runtime/window#windowtogglemaximise)
-// Toggles between Maximised and UnMaximised.
-export function WindowToggleMaximise(): void;
-
-// [WindowUnmaximise](https://wails.io/docs/reference/runtime/window#windowunmaximise)
-// Restores the window to the dimensions and position prior to maximising.
-export function WindowUnmaximise(): void;
-
-// [WindowIsMaximised](https://wails.io/docs/reference/runtime/window#windowismaximised)
-// Returns the state of the window, i.e. whether the window is maximised or not.
-export function WindowIsMaximised(): Promise<boolean>;
-
-// [WindowMinimise](https://wails.io/docs/reference/runtime/window#windowminimise)
-// Minimises the window.
-export function WindowMinimise(): void;
-
-// [WindowUnminimise](https://wails.io/docs/reference/runtime/window#windowunminimise)
-// Restores the window to the dimensions and position prior to minimising.
-export function WindowUnminimise(): void;
-
-// [WindowIsMinimised](https://wails.io/docs/reference/runtime/window#windowisminimised)
-// Returns the state of the window, i.e. whether the window is minimised or not.
-export function WindowIsMinimised(): Promise<boolean>;
-
-// [WindowIsNormal](https://wails.io/docs/reference/runtime/window#windowisnormal)
-// Returns the state of the window, i.e. whether the window is normal or not.
-export function WindowIsNormal(): Promise<boolean>;
-
-// [WindowSetBackgroundColour](https://wails.io/docs/reference/runtime/window#windowsetbackgroundcolour)
-// Sets the background colour of the window to the given RGBA colour definition. This colour will show through for all transparent pixels.
-export function WindowSetBackgroundColour(R: number, G: number, B: number, A: number): void;
-
-// [ScreenGetAll](https://wails.io/docs/reference/runtime/window#screengetall)
-// Gets the all screens. Call this anew each time you want to refresh data from the underlying windowing system.
-export function ScreenGetAll(): Promise<Screen[]>;
-
-// [BrowserOpenURL](https://wails.io/docs/reference/runtime/browser#browseropenurl)
-// Opens the given URL in the system browser.
-export function BrowserOpenURL(url: string): void;
-
-// [Environment](https://wails.io/docs/reference/runtime/intro#environment)
-// Returns information about the environment
-export function Environment(): Promise<EnvironmentInfo>;
-
-// [Quit](https://wails.io/docs/reference/runtime/intro#quit)
-// Quits the application.
-export function Quit(): void;
-
-// [Hide](https://wails.io/docs/reference/runtime/intro#hide)
-// Hides the application.
-export function Hide(): void;
-
-// [Show](https://wails.io/docs/reference/runtime/intro#show)
-// Shows the application.
-export function Show(): void;
-
-// [ClipboardGetText](https://wails.io/docs/reference/runtime/clipboard#clipboardgettext)
-// Returns the current text stored on clipboard
-export function ClipboardGetText(): Promise<string>;
-
-// [ClipboardSetText](https://wails.io/docs/reference/runtime/clipboard#clipboardsettext)
-// Sets a text on the clipboard
-export function ClipboardSetText(text: string): Promise<boolean>;
-
-// [OnFileDrop](https://wails.io/docs/reference/runtime/draganddrop#onfiledrop)
-// OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.
-export function OnFileDrop(callback: (x: number, y: number ,paths: string[]) => void, useDropTarget: boolean) :void
-
-// [OnFileDropOff](https://wails.io/docs/reference/runtime/draganddrop#dragandddropoff)
-// OnFileDropOff removes the drag and drop listeners and handlers.
-export function OnFileDropOff() :void
-
-// Check if the file path resolver is available
-export function CanResolveFilePaths(): boolean;
-
-// Resolves file paths for an array of files
-export function ResolveFilePaths(files: File[]): void
\ No newline at end of file
diff --git a/wailsjs/runtime/runtime.js b/wailsjs/runtime/runtime.js
deleted file mode 100644
index 7cb89d7..0000000
--- a/wailsjs/runtime/runtime.js
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- _       __      _ __
-| |     / /___ _(_) /____
-| | /| / / __ `/ / / ___/
-| |/ |/ / /_/ / / (__  )
-|__/|__/\__,_/_/_/____/
-The electron alternative for Go
-(c) Lea Anthony 2019-present
-*/
-
-export function LogPrint(message) {
-    window.runtime.LogPrint(message);
-}
-
-export function LogTrace(message) {
-    window.runtime.LogTrace(message);
-}
-
-export function LogDebug(message) {
-    window.runtime.LogDebug(message);
-}
-
-export function LogInfo(message) {
-    window.runtime.LogInfo(message);
-}
-
-export function LogWarning(message) {
-    window.runtime.LogWarning(message);
-}
-
-export function LogError(message) {
-    window.runtime.LogError(message);
-}
-
-export function LogFatal(message) {
-    window.runtime.LogFatal(message);
-}
-
-export function EventsOnMultiple(eventName, callback, maxCallbacks) {
-    return window.runtime.EventsOnMultiple(eventName, callback, maxCallbacks);
-}
-
-export function EventsOn(eventName, callback) {
-    return EventsOnMultiple(eventName, callback, -1);
-}
-
-export function EventsOff(eventName, ...additionalEventNames) {
-    return window.runtime.EventsOff(eventName, ...additionalEventNames);
-}
-
-export function EventsOffAll() {
-  return window.runtime.EventsOffAll();
-}
-
-export function EventsOnce(eventName, callback) {
-    return EventsOnMultiple(eventName, callback, 1);
-}
-
-export function EventsEmit(eventName) {
-    let args = [eventName].slice.call(arguments);
-    return window.runtime.EventsEmit.apply(null, args);
-}
-
-export function WindowReload() {
-    window.runtime.WindowReload();
-}
-
-export function WindowReloadApp() {
-    window.runtime.WindowReloadApp();
-}
-
-export function WindowSetAlwaysOnTop(b) {
-    window.runtime.WindowSetAlwaysOnTop(b);
-}
-
-export function WindowSetSystemDefaultTheme() {
-    window.runtime.WindowSetSystemDefaultTheme();
-}
-
-export function WindowSetLightTheme() {
-    window.runtime.WindowSetLightTheme();
-}
-
-export function WindowSetDarkTheme() {
-    window.runtime.WindowSetDarkTheme();
-}
-
-export function WindowCenter() {
-    window.runtime.WindowCenter();
-}
-
-export function WindowSetTitle(title) {
-    window.runtime.WindowSetTitle(title);
-}
-
-export function WindowFullscreen() {
-    window.runtime.WindowFullscreen();
-}
-
-export function WindowUnfullscreen() {
-    window.runtime.WindowUnfullscreen();
-}
-
-export function WindowIsFullscreen() {
-    return window.runtime.WindowIsFullscreen();
-}
-
-export function WindowGetSize() {
-    return window.runtime.WindowGetSize();
-}
-
-export function WindowSetSize(width, height) {
-    window.runtime.WindowSetSize(width, height);
-}
-
-export function WindowSetMaxSize(width, height) {
-    window.runtime.WindowSetMaxSize(width, height);
-}
-
-export function WindowSetMinSize(width, height) {
-    window.runtime.WindowSetMinSize(width, height);
-}
-
-export function WindowSetPosition(x, y) {
-    window.runtime.WindowSetPosition(x, y);
-}
-
-export function WindowGetPosition() {
-    return window.runtime.WindowGetPosition();
-}
-
-export function WindowHide() {
-    window.runtime.WindowHide();
-}
-
-export function WindowShow() {
-    window.runtime.WindowShow();
-}
-
-export function WindowMaximise() {
-    window.runtime.WindowMaximise();
-}
-
-export function WindowToggleMaximise() {
-    window.runtime.WindowToggleMaximise();
-}
-
-export function WindowUnmaximise() {
-    window.runtime.WindowUnmaximise();
-}
-
-export function WindowIsMaximised() {
-    return window.runtime.WindowIsMaximised();
-}
-
-export function WindowMinimise() {
-    window.runtime.WindowMinimise();
-}
-
-export function WindowUnminimise() {
-    window.runtime.WindowUnminimise();
-}
-
-export function WindowSetBackgroundColour(R, G, B, A) {
-    window.runtime.WindowSetBackgroundColour(R, G, B, A);
-}
-
-export function ScreenGetAll() {
-    return window.runtime.ScreenGetAll();
-}
-
-export function WindowIsMinimised() {
-    return window.runtime.WindowIsMinimised();
-}
-
-export function WindowIsNormal() {
-    return window.runtime.WindowIsNormal();
-}
-
-export function BrowserOpenURL(url) {
-    window.runtime.BrowserOpenURL(url);
-}
-
-export function Environment() {
-    return window.runtime.Environment();
-}
-
-export function Quit() {
-    window.runtime.Quit();
-}
-
-export function Hide() {
-    window.runtime.Hide();
-}
-
-export function Show() {
-    window.runtime.Show();
-}
-
-export function ClipboardGetText() {
-    return window.runtime.ClipboardGetText();
-}
-
-export function ClipboardSetText(text) {
-    return window.runtime.ClipboardSetText(text);
-}
-
-/**
- * Callback for OnFileDrop returns a slice of file path strings when a drop is finished.
- *
- * @export
- * @callback OnFileDropCallback
- * @param {number} x - x coordinate of the drop
- * @param {number} y - y coordinate of the drop
- * @param {string[]} paths - A list of file paths.
- */
-
-/**
- * OnFileDrop listens to drag and drop events and calls the callback with the coordinates of the drop and an array of path strings.
- *
- * @export
- * @param {OnFileDropCallback} callback - Callback for OnFileDrop returns a slice of file path strings when a drop is finished.
- * @param {boolean} [useDropTarget=true] - Only call the callback when the drop finished on an element that has the drop target style. (--wails-drop-target)
- */
-export function OnFileDrop(callback, useDropTarget) {
-    return window.runtime.OnFileDrop(callback, useDropTarget);
-}
-
-/**
- * OnFileDropOff removes the drag and drop listeners and handlers.
- */
-export function OnFileDropOff() {
-    return window.runtime.OnFileDropOff();
-}
-
-export function CanResolveFilePaths() {
-    return window.runtime.CanResolveFilePaths();
-}
-
-export function ResolveFilePaths(files) {
-    return window.runtime.ResolveFilePaths(files);
-}
\ No newline at end of file