diff --git a/package-lock.json b/package-lock.json
index a9a8dc556..62e57cc9d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -11,6 +11,14 @@
       "dependencies": {
         "@deadlyjack/ajax": "^1.2.6",
         "@ungap/custom-elements": "^1.3.0",
+        "@xterm/addon-attach": "^0.11.0",
+        "@xterm/addon-fit": "^0.10.0",
+        "@xterm/addon-image": "^0.8.0",
+        "@xterm/addon-search": "^0.15.0",
+        "@xterm/addon-unicode11": "^0.8.0",
+        "@xterm/addon-web-links": "^0.11.0",
+        "@xterm/addon-webgl": "^0.18.0",
+        "@xterm/xterm": "^5.5.0",
         "autosize": "^6.0.1",
         "cordova": "12.0.0",
         "core-js": "^3.37.1",
@@ -46,8 +54,9 @@
         "@types/url-parse": "^1.4.11",
         "autoprefixer": "^10.4.19",
         "babel-loader": "^9.1.3",
+        "com.foxdebug.acode.rk.exec.proot": "file:src/plugins/proot",
         "com.foxdebug.acode.rk.exec.terminal": "file:src/plugins/terminal",
-        "cordova-android": "13.0.0",
+        "cordova-android": "^13.0.0",
         "cordova-clipboard": "^1.3.0",
         "cordova-plugin-advanced-http": "^3.3.1",
         "cordova-plugin-browser": "file:src/plugins/browser",
@@ -3061,6 +3070,75 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@xterm/addon-attach": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-attach/-/addon-attach-0.11.0.tgz",
+      "integrity": "sha512-JboCN0QAY6ZLY/SSB/Zl2cQ5zW1Eh4X3fH7BnuR1NB7xGRhzbqU2Npmpiw/3zFlxDaU88vtKzok44JKi2L2V2Q==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-fit": {
+      "version": "0.10.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-fit/-/addon-fit-0.10.0.tgz",
+      "integrity": "sha512-UFYkDm4HUahf2lnEyHvio51TNGiLK66mqP2JoATy7hRZeXaGMRDr00JiSF7m63vR5WKATF605yEggJKsw0JpMQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-image": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-image/-/addon-image-0.8.0.tgz",
+      "integrity": "sha512-b/dqpFn3jUad2pUP5UpF4scPIh0WdxRQL/1qyiahGfUI85XZTCXo0py9G6AcOR2QYUw8eJ8EowGspT7BQcgw6A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.2.0"
+      }
+    },
+    "node_modules/@xterm/addon-search": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-search/-/addon-search-0.15.0.tgz",
+      "integrity": "sha512-ZBZKLQ+EuKE83CqCmSSz5y1tx+aNOCUaA7dm6emgOX+8J9H1FWXZyrKfzjwzV+V14TV3xToz1goIeRhXBS5qjg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-unicode11": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-unicode11/-/addon-unicode11-0.8.0.tgz",
+      "integrity": "sha512-LxinXu8SC4OmVa6FhgwsVCBZbr8WoSGzBl2+vqe8WcQ6hb1r6Gj9P99qTNdPiFPh4Ceiu2pC8xukZ6+2nnh49Q==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-web-links": {
+      "version": "0.11.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-web-links/-/addon-web-links-0.11.0.tgz",
+      "integrity": "sha512-nIHQ38pQI+a5kXnRaTgwqSHnX7KE6+4SVoceompgHL26unAxdfP6IPqUTSYPQgSwM56hsElfoNrrW5V7BUED/Q==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/addon-webgl": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.18.0.tgz",
+      "integrity": "sha512-xCnfMBTI+/HKPdRnSOHaJDRqEpq2Ugy8LEj9GiY4J3zJObo3joylIFaMvzBwbYRg8zLtkO0KQaStCeSfoaI2/w==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@xterm/xterm": "^5.0.0"
+      }
+    },
+    "node_modules/@xterm/xterm": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.5.0.tgz",
+      "integrity": "sha512-hqJHYaQb5OptNunnyAnkHyM8aCjZ1MEIDTQu1iIbbTD/xops91NB5yq1ZK/dC2JDbVWtF23zUtl9JE2NqwT87A==",
+      "license": "MIT"
+    },
     "node_modules/@xtuc/ieee754": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
@@ -4002,6 +4080,10 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/com.foxdebug.acode.rk.exec.proot": {
+      "resolved": "src/plugins/proot",
+      "link": true
+    },
     "node_modules/com.foxdebug.acode.rk.exec.terminal": {
       "resolved": "src/plugins/terminal",
       "link": true
@@ -10799,7 +10881,7 @@
     "src/plugins/proot": {
       "name": "com.foxdebug.acode.rk.exec.proot",
       "version": "1.0.0",
-      "extraneous": true,
+      "dev": true,
       "license": "MIT"
     },
     "src/plugins/sdcard": {
diff --git a/package.json b/package.json
index 01b0c9261..88206ac5d 100644
--- a/package.json
+++ b/package.json
@@ -36,6 +36,7 @@
       },
       "cordova-plugin-websocket": {},
       "cordova-plugin-buildinfo": {},
+      "com.foxdebug.acode.rk.exec.proot": {},
       "cordova-plugin-system": {},
       "com.foxdebug.acode.rk.exec.terminal": {}
     },
@@ -63,8 +64,9 @@
     "@types/url-parse": "^1.4.11",
     "autoprefixer": "^10.4.19",
     "babel-loader": "^9.1.3",
+    "com.foxdebug.acode.rk.exec.proot": "file:src/plugins/proot",
     "com.foxdebug.acode.rk.exec.terminal": "file:src/plugins/terminal",
-    "cordova-android": "13.0.0",
+    "cordova-android": "^13.0.0",
     "cordova-clipboard": "^1.3.0",
     "cordova-plugin-advanced-http": "^3.3.1",
     "cordova-plugin-browser": "file:src/plugins/browser",
@@ -95,6 +97,14 @@
   "dependencies": {
     "@deadlyjack/ajax": "^1.2.6",
     "@ungap/custom-elements": "^1.3.0",
+    "@xterm/addon-attach": "^0.11.0",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-image": "^0.8.0",
+    "@xterm/addon-search": "^0.15.0",
+    "@xterm/addon-unicode11": "^0.8.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/addon-webgl": "^0.18.0",
+    "@xterm/xterm": "^5.5.0",
     "autosize": "^6.0.1",
     "cordova": "12.0.0",
     "core-js": "^3.37.1",
diff --git a/src/ace/commands.js b/src/ace/commands.js
index 516253d19..233a23c0b 100644
--- a/src/ace/commands.js
+++ b/src/ace/commands.js
@@ -341,6 +341,14 @@ const commands = [
 		},
 		readOnly: true,
 	},
+	{
+		name: "openTerminal",
+		description: "Open Terminal",
+		exec() {
+			acode.exec("new-terminal");
+		},
+		readOnly: true,
+	},
 ];
 
 export function setCommands(editor) {
diff --git a/src/components/terminal/index.js b/src/components/terminal/index.js
new file mode 100644
index 000000000..ef2372fa1
--- /dev/null
+++ b/src/components/terminal/index.js
@@ -0,0 +1,22 @@
+/**
+ * Terminal Components Export
+ */
+
+import TerminalComponent from "./terminal";
+import { DEFAULT_TERMINAL_SETTINGS } from "./terminalDefaults";
+import TerminalManager from "./terminalManager";
+import TerminalThemeManager from "./terminalThemeManager";
+
+export {
+	TerminalComponent,
+	TerminalManager,
+	TerminalThemeManager,
+	DEFAULT_TERMINAL_SETTINGS,
+};
+
+export default {
+	TerminalComponent,
+	TerminalManager,
+	TerminalThemeManager,
+	DEFAULT_TERMINAL_SETTINGS,
+};
diff --git a/src/components/terminal/ligatures.js b/src/components/terminal/ligatures.js
new file mode 100644
index 000000000..d7042dd51
--- /dev/null
+++ b/src/components/terminal/ligatures.js
@@ -0,0 +1,102 @@
+// pretty basic ligature implementation for webview
+export default class LigaturesAddon {
+	constructor(options = {}) {
+		// fallback ligatures if a font does not support ligatures natively
+		this._fallbackLigatures =
+			options.fallbackLigatures ||
+			[
+				"<--",
+				"<---",
+				"<<-",
+				"<-",
+				"->",
+				"->>",
+				"-->",
+				"--->",
+				"<==",
+				"<===",
+				"<<=",
+				"<=",
+				"=>",
+				"=>>",
+				"==>",
+				"===>",
+				">=",
+				">>=",
+				"<->",
+				"<-->",
+				"<--->",
+				"<---->",
+				"<=>",
+				"<==>",
+				"<===>",
+				"<====>",
+				"<~~",
+				"<~",
+				"~>",
+				"~~>",
+				"::",
+				":::",
+				"==",
+				"!=",
+				"===",
+				"!==",
+				":=",
+				":-",
+				":+",
+				"<*",
+				"<*>",
+				"*>",
+				"<|",
+				"<|>",
+				"|>",
+				"+:",
+				"-:",
+				"=:",
+				":>",
+				"++",
+				"+++",
+				"<!--",
+				"<!---",
+				"<***>",
+			].sort((a, b) => b.length - a.length);
+		this._characterJoinerId = undefined;
+		this._terminal = undefined;
+	}
+
+	activate(terminal) {
+		this._terminal = terminal;
+		this._characterJoinerId = terminal.registerCharacterJoiner(
+			this._joinCharacters.bind(this),
+		);
+		terminal.element.style.fontFeatureSettings = `"liga" on, "calt" on`;
+	}
+
+	dispose() {
+		if (this._characterJoinerId !== undefined) {
+			this._terminal?.deregisterCharacterJoiner(this._characterJoinerId);
+			this._characterJoinerId = undefined;
+		}
+		if (this._terminal?.element) {
+			this._terminal.element.style.fontFeatureSettings = "";
+		}
+	}
+
+	_joinCharacters(text) {
+		return this._findLigatureRanges(text, this._fallbackLigatures);
+	}
+
+	_findLigatureRanges(text, ligatures) {
+		const ranges = [];
+		for (let i = 0; i < text.length; i++) {
+			for (const ligature of ligatures) {
+				if (text.startsWith(ligature, i)) {
+					ranges.push([i, i + ligature.length]);
+					i += ligature.length - 1;
+					break;
+				}
+			}
+		}
+		return ranges;
+	}
+}
diff --git a/src/components/terminal/terminal.js b/src/components/terminal/terminal.js
new file mode 100644
index 000000000..914b6bf49
--- /dev/null
+++ b/src/components/terminal/terminal.js
@@ -0,0 +1,940 @@
+/**
+ * Terminal Component using xtermjs
+ * Provides a pluggable and customizable terminal interface
+ */
+
+import { AttachAddon } from "@xterm/addon-attach";
+import { FitAddon } from "@xterm/addon-fit";
+import { ImageAddon } from "@xterm/addon-image";
+import { SearchAddon } from "@xterm/addon-search";
+import { Unicode11Addon } from "@xterm/addon-unicode11";
+import { WebLinksAddon } from "@xterm/addon-web-links";
+import { WebglAddon } from "@xterm/addon-webgl";
+import { Terminal as Xterm } from "@xterm/xterm";
+import toast from "components/toast";
+import confirm from "dialogs/confirm";
+import fonts from "lib/fonts";
+import keyBindings from "lib/keyBindings";
+import appSettings from "lib/settings";
+import LigaturesAddon from "./ligatures";
+import { getTerminalSettings } from "./terminalDefaults";
+import TerminalThemeManager from "./terminalThemeManager";
+import TerminalTouchSelection from "./terminalTouchSelection";
+
+export default class TerminalComponent {
+	constructor(options = {}) {
+		// Get terminal settings from shared defaults
+		const terminalSettings = getTerminalSettings();
+
+		this.options = {
+			allowProposedApi: true,
+			scrollOnUserInput: true,
+			rows: options.rows || 24,
+			cols: options.cols || 80,
+			fontSize: terminalSettings.fontSize,
+			fontFamily: terminalSettings.fontFamily,
+			fontWeight: terminalSettings.fontWeight,
+			theme: TerminalThemeManager.getTheme(terminalSettings.theme),
+			cursorBlink: terminalSettings.cursorBlink,
+			cursorStyle: terminalSettings.cursorStyle,
+			cursorInactiveStyle: terminalSettings.cursorInactiveStyle,
+			scrollback: terminalSettings.scrollback,
+			tabStopWidth: terminalSettings.tabStopWidth,
+			convertEol: terminalSettings.convertEol,
+			letterSpacing: terminalSettings.letterSpacing,
+			...options,
+		};
+
+		this.terminal = null;
+		this.fitAddon = null;
+		this.attachAddon = null;
+		this.unicode11Addon = null;
+		this.searchAddon = null;
+		this.webLinksAddon = null;
+		this.imageAddon = null;
+		this.ligaturesAddon = null;
+		this.container = null;
+		this.websocket = null;
+		this.pid = null;
+		this.isConnected = false;
+		this.serverMode = options.serverMode !== false; // Default true
+		this.touchSelection = null;
+
+		this.init();
+	}
+
+	init() {
+		this.terminal = new Xterm(this.options);
+
+		// Initialize addons
+		this.fitAddon = new FitAddon();
+		this.unicode11Addon = new Unicode11Addon();
+		this.searchAddon = new SearchAddon();
+		this.webLinksAddon = new WebLinksAddon(async (event, uri) => {
+			const linkOpenConfirm = await confirm(
+				"Terminal",
+				`Do you want to open ${uri} in browser?`,
+			);
+			if (linkOpenConfirm) {
+				system.openInBrowser(uri);
+			}
+		});
+		this.webglAddon = new WebglAddon();
+
+		// Load addons
+		this.terminal.loadAddon(this.fitAddon);
+		this.terminal.loadAddon(this.unicode11Addon);
+		this.terminal.loadAddon(this.searchAddon);
+		this.terminal.loadAddon(this.webLinksAddon);
+
+		// Load conditional addons based on settings
+		const terminalSettings = getTerminalSettings();
+
+		// Load image addon if enabled
+		if (terminalSettings.imageSupport) {
+			this.loadImageAddon();
+		}
+
+		// Load font if specified
+		this.loadTerminalFont();
+
+		// Set up terminal event handlers
+		this.setupEventHandlers();
+	}
+
+	setupEventHandlers() {
+		// terminal resize handling
+		this.setupResizeHandling();
+
+		// Handle terminal title changes
+		this.terminal.onTitleChange((title) => {
+			this.onTitleChange?.(title);
+		});
+
+		// Handle bell
+		this.terminal.onBell(() => {
+			this.onBell?.();
+		});
+
+		// Handle copy/paste keybindings
+		this.setupCopyPasteHandlers();
+	}
+
+	/**
+	 * Setup resize handling for keyboard events and content preservation
+	 */
+	setupResizeHandling() {
+		let resizeTimeout = null;
+		let lastKnownScrollPosition = 0;
+		let isResizing = false;
+		let resizeCount = 0;
+		const RESIZE_DEBOUNCE = 150;
+		const MAX_RAPID_RESIZES = 3;
+
+		// Store original dimensions for comparison
+		let originalRows = this.terminal.rows;
+		let originalCols = this.terminal.cols;
+
+		this.terminal.onResize((size) => {
+			// Track resize events
+			resizeCount++;
+			isResizing = true;
+
+			// Store current scroll position before resize
+			if (this.terminal.buffer && this.terminal.buffer.active) {
+				lastKnownScrollPosition = this.terminal.buffer.active.viewportY;
+			}
+
+			// Clear any existing timeout
+			if (resizeTimeout) {
+				clearTimeout(resizeTimeout);
+			}
+
+			// Debounced resize handling
+			resizeTimeout = setTimeout(async () => {
+				try {
+					// Only proceed with server resize if dimensions actually changed significantly
+					const rowDiff = Math.abs(size.rows - originalRows);
+					const colDiff = Math.abs(size.cols - originalCols);
+
+					// If this is a minor resize (likely intermediate state), skip server update
+					if (rowDiff < 2 && colDiff < 2 && resizeCount > 1) {
+						console.log("Skipping minor resize to prevent instability");
+						isResizing = false;
+						resizeCount = 0;
+						return;
+					}
+
+					// Handle server resize
+					if (this.serverMode) {
+						await this.resizeTerminal(size.cols, size.rows);
+					}
+
+					// Preserve scroll position for content-heavy terminals
+					this.preserveViewportPosition(lastKnownScrollPosition);
+
+					// Update stored dimensions
+					originalRows = size.rows;
+					originalCols = size.cols;
+
+					// Mark resize as complete
+					isResizing = false;
+					resizeCount = 0;
+
+					// Notify touch selection if it exists
+					if (this.touchSelection) {
+						this.touchSelection.onTerminalResize(size);
+					}
+				} catch (error) {
+					console.error("Resize handling failed:", error);
+					isResizing = false;
+					resizeCount = 0;
+				}
+			}, RESIZE_DEBOUNCE);
+		});
+
+		// Also handle viewport changes for scroll position preservation
+		this.terminal.onData(() => {
+			// If we're not resizing and user types, everything is stable
+			if (!isResizing && this.terminal.buffer && this.terminal.buffer.active) {
+				lastKnownScrollPosition = this.terminal.buffer.active.viewportY;
+			}
+		});
+	}
+
+	/**
+	 * Preserve viewport position during resize to prevent jumping
+	 */
+	preserveViewportPosition(targetScrollPosition) {
+		if (!this.terminal.buffer || !this.terminal.buffer.active) return;
+
+		const buffer = this.terminal.buffer.active;
+		const maxScroll = Math.max(0, buffer.length - this.terminal.rows);
+
+		// Ensure scroll position is within valid bounds
+		const safeScrollPosition = Math.min(targetScrollPosition, maxScroll);
+
+		// Only adjust if we have significant content and the position is different
+		if (
+			buffer.length > this.terminal.rows &&
+			Math.abs(buffer.viewportY - safeScrollPosition) > 2
+		) {
+			// Gradually adjust to prevent jarring movements
+			const steps = 3;
+			const diff = safeScrollPosition - buffer.viewportY;
+			const stepSize = Math.ceil(Math.abs(diff) / steps);
+
+			let currentStep = 0;
+			const adjustStep = () => {
+				if (currentStep >= steps) return;
+
+				const currentPos = buffer.viewportY;
+				const remaining = safeScrollPosition - currentPos;
+				const adjustment =
+					Math.sign(remaining) * Math.min(stepSize, Math.abs(remaining));
+
+				if (Math.abs(adjustment) >= 1) {
+					this.terminal.scrollLines(adjustment);
+				}
+
+				currentStep++;
+				if (currentStep < steps && Math.abs(remaining) > 1) {
+					setTimeout(adjustStep, 50);
+				}
+			};
+
+			setTimeout(adjustStep, 100);
+		}
+	}
+
+	/**
+	 * Setup touch selection for mobile devices
+	 */
+	setupTouchSelection() {
+		// Only initialize touch selection on mobile devices
+		if (window.cordova && this.container) {
+			const terminalSettings = getTerminalSettings();
+			this.touchSelection = new TerminalTouchSelection(
+				this.terminal,
+				this.container,
+				{
+					tapHoldDuration:
+						terminalSettings.touchSelectionTapHoldDuration || 600,
+					moveThreshold: terminalSettings.touchSelectionMoveThreshold || 8,
+					handleSize: terminalSettings.touchSelectionHandleSize || 24,
+					hapticFeedback:
+						terminalSettings.touchSelectionHapticFeedback !== false,
+					showContextMenu:
+						terminalSettings.touchSelectionShowContextMenu !== false,
+					onFontSizeChange: (fontSize) => this.updateFontSize(fontSize),
+				},
+			);
+		}
+	}
+
+	/**
+	 * Parse app keybindings into a format usable by the keyboard handler
+	 */
+	parseAppKeybindings() {
+		const parsedBindings = [];
+
+		Object.values(keyBindings).forEach((binding) => {
+			if (!binding.key) return;
+
+			// Skip editor-only keybindings in terminal
+			if (binding.editorOnly) return;
+
+			// Handle multiple key combinations separated by |
+			const keys = binding.key.split("|");
+
+			keys.forEach((keyCombo) => {
+				const parts = keyCombo.split("-");
+				const parsed = {
+					ctrl: false,
+					shift: false,
+					alt: false,
+					meta: false,
+					key: "",
+				};
+
+				parts.forEach((part) => {
+					const lowerPart = part.toLowerCase();
+					if (lowerPart === "ctrl") {
+						parsed.ctrl = true;
+					} else if (lowerPart === "shift") {
+						parsed.shift = true;
+					} else if (lowerPart === "alt") {
+						parsed.alt = true;
+					} else if (lowerPart === "meta" || lowerPart === "cmd") {
+						parsed.meta = true;
+					} else {
+						// This is the actual key
+						parsed.key = part;
+					}
+				});
+
+				if (parsed.key) {
+					parsedBindings.push(parsed);
+				}
+			});
+		});
+
+		return parsedBindings;
+	}
+
+	/**
+	 * Setup copy/paste keyboard handlers
+	 */
+	setupCopyPasteHandlers() {
+		// Add keyboard event listener to terminal element
+		this.terminal.attachCustomKeyEventHandler((event) => {
+			// Check for Ctrl+Shift+C (copy)
+			if (event.ctrlKey && event.shiftKey && event.key === "C") {
+				event.preventDefault();
+				this.copySelection();
+				return false;
+			}
+
+			// Check for Ctrl+Shift+V (paste)
+			if (event.ctrlKey && event.shiftKey && event.key === "V") {
+				event.preventDefault();
+				this.pasteFromClipboard();
+				return false;
+			}
+
+			// Check for Ctrl+= or Ctrl++ (increase font size)
+			if (event.ctrlKey && (event.key === "+" || event.key === "=")) {
+				event.preventDefault();
+				this.increaseFontSize();
+				return false;
+			}
+
+			// Check for Ctrl+- (decrease font size)
+			if (event.ctrlKey && event.key === "-") {
+				event.preventDefault();
+				this.decreaseFontSize();
+				return false;
+			}
+
+			// Only intercept specific app-wide keybindings, let terminal handle the rest
+			if (event.ctrlKey || event.altKey || event.metaKey) {
+				// Skip modifier-only keys
+				if (["Control", "Alt", "Meta", "Shift"].includes(event.key)) {
+					return true;
+				}
+
+				// Get parsed app keybindings
+				const appKeybindings = this.parseAppKeybindings();
+
+				// Check if this is an app-specific keybinding
+				const isAppKeybinding = appKeybindings.some(
+					(binding) =>
+						binding.ctrl === event.ctrlKey &&
+						binding.shift === event.shiftKey &&
+						binding.alt === event.altKey &&
+						binding.meta === event.metaKey &&
+						binding.key === event.key,
+				);
+
+				if (isAppKeybinding) {
+					const appEvent = new KeyboardEvent("keydown", {
+						key: event.key,
+						ctrlKey: event.ctrlKey,
+						shiftKey: event.shiftKey,
+						altKey: event.altKey,
+						metaKey: event.metaKey,
+						bubbles: true,
+						cancelable: true,
+					});
+
+					// Dispatch to document so it gets picked up by the app's keyboard handler
+					document.dispatchEvent(appEvent);
+
+					// Return false to prevent terminal from processing this key
+					return false;
+				}
+
+				// For all other modifier combinations, let the terminal handle them
+				return true;
+			}
+
+			// Return true to allow normal processing for other keys
+			return true;
+		});
+	}
+
+	/**
+	 * Copy selected text to clipboard
+	 */
+	copySelection() {
+		if (!this.terminal?.hasSelection()) return;
+		const selectedStr = this.terminal?.getSelection();
+		if (selectedStr && cordova?.plugins?.clipboard) {
+			cordova.plugins.clipboard.copy(selectedStr);
+		}
+	}
+
+	/**
+	 * Paste text from clipboard
+	 */
+	pasteFromClipboard() {
+		if (cordova?.plugins?.clipboard) {
+			cordova.plugins.clipboard.paste((text) => {
+				this.terminal?.paste(text);
+			});
+		}
+	}
+
+	/**
+	 * Create terminal container element
+	 * @returns {HTMLElement} Container element
+	 */
+	createContainer() {
+		this.container = document.createElement("div");
+		this.container.className = "terminal-container";
+		this.container.style.cssText = `
+      width: 100%;
+      height: 100%;
+      position: relative;
+      background: ${this.options.theme.background};
+      border-radius: 4px;
+      overflow: hidden;
+    `;
+
+		return this.container;
+	}
+
+	/**
+	 * Mount terminal to container
+	 * @param {HTMLElement} container - Container element
+	 */
+	mount(container) {
+		if (!container) {
+			container = this.createContainer();
+		}
+
+		this.container = container;
+
+		try {
+			try {
+				this.terminal.loadAddon(this.webglAddon);
+				this.terminal.open(container);
+			} catch (error) {
+				console.error("Failed to load WebglAddon:", error);
+				this.webglAddon.dispose();
+			}
+
+			if (!this.terminal.element) {
+				// webgl loading failed for some reason, attach with DOM renderer
+				this.terminal.open(container);
+			}
+			const terminalSettings = getTerminalSettings();
+			// Load ligatures addon if enabled
+			if (terminalSettings.fontLigatures) {
+				this.loadLigaturesAddon();
+			}
+
+			// Wait for terminal to render then fit
+			setTimeout(() => {
+				this.fitAddon.fit();
+				this.terminal.focus();
+
+				// Initialize touch selection after terminal is mounted
+				this.setupTouchSelection();
+			}, 10);
+		} catch (error) {
+			console.error("Failed to mount terminal:", error);
+		}
+
+		return container;
+	}
+
+	/**
+	 * Create new terminal session using global Terminal API
+	 * @returns {Promise<string>} Terminal PID
+	 */
+	async createSession() {
+		if (!this.serverMode) {
+			throw new Error(
+				"Terminal is in local mode, cannot create server session",
+			);
+		}
+
+		try {
+			// Check if terminal is installed before starting AXS
+			if (!(await Terminal.isInstalled())) {
+				throw new Error(
+					"Terminal not installed. Please install terminal first.",
+				);
+			}
+
+			// Start AXS if not running
+			if (!(await Terminal.isAxsRunning())) {
+				await Terminal.startAxs(false, () => {}, console.error);
+
+				// Check if AXS started with interval polling
+				const maxRetries = 10;
+				let retries = 0;
+				while (retries < maxRetries) {
+					await new Promise((resolve) => setTimeout(resolve, 1000));
+					if (await Terminal.isAxsRunning()) {
+						break;
+					}
+					retries++;
+				}
+
+				// If AXS still not running after retries, throw error
+				if (!(await Terminal.isAxsRunning())) {
+					toast("Failed to start AXS server after multiple attempts");
+					//throw new Error("Failed to start AXS server after multiple attempts");
+				}
+			}
+
+			const requestBody = {
+				cols: this.terminal.cols,
+				rows: this.terminal.rows,
+			};
+
+			const response = await fetch("http://localhost:8767/terminals", {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(requestBody),
+			});
+
+			if (!response.ok) {
+				throw new Error(`HTTP error! status: ${response.status}`);
+			}
+
+			const data = await response.text();
+			this.pid = data.trim();
+			return this.pid;
+		} catch (error) {
+			console.error("Failed to create terminal session:", error);
+			throw error;
+		}
+	}
+
+	/**
+	 * Connect to terminal session via WebSocket
+	 * @param {string} pid - Terminal PID
+	 */
+	async connectToSession(pid) {
+		if (!this.serverMode) {
+			throw new Error(
+				"Terminal is in local mode, cannot connect to server session",
+			);
+		}
+
+		if (!pid) {
+			pid = await this.createSession();
+		}
+
+		this.pid = pid;
+
+		const wsUrl = `ws://localhost:8767/terminals/${pid}`;
+
+		this.websocket = new WebSocket(wsUrl);
+
+		this.websocket.onopen = () => {
+			this.isConnected = true;
+			this.onConnect?.();
+
+			// Load attach addon after connection
+			this.attachAddon = new AttachAddon(this.websocket);
+			this.terminal.loadAddon(this.attachAddon);
+			this.terminal.unicode.activeVersion = "11";
+
+			// Focus terminal and ensure it's ready
+			this.terminal.focus();
+			this.fit();
+		};
+
+		this.websocket.onmessage = (event) => {
+			// Handle text messages (exit events)
+			if (typeof event.data === "string") {
+				try {
+					const message = JSON.parse(event.data);
+					if (message.type === "exit") {
+						this.onProcessExit?.(message.data);
+						return;
+					}
+				} catch (error) {
+					// Not a JSON message, let attachAddon handle it
+				}
+			}
+			// For binary data or non-exit text messages, let attachAddon handle them
+		};
+
+		this.websocket.onclose = (event) => {
+			this.isConnected = false;
+			this.onDisconnect?.();
+		};
+
+		this.websocket.onerror = (error) => {
+			console.error("WebSocket error:", error);
+			this.onError?.(error);
+		};
+	}
+
+	/**
+	 * Resize terminal
+	 * @param {number} cols - Number of columns
+	 * @param {number} rows - Number of rows
+	 */
+	async resizeTerminal(cols, rows) {
+		if (!this.pid || !this.serverMode) return;
+
+		try {
+			await fetch(`http://localhost:8767/terminals/${this.pid}/resize`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify({ cols, rows }),
+			});
+		} catch (error) {
+			console.error("Failed to resize terminal:", error);
+		}
+	}
+
+	/**
+	 * Fit terminal to container
+	 */
+	fit() {
+		if (this.fitAddon) {
+			this.fitAddon.fit();
+		}
+	}
+
+	/**
+	 * Write data to terminal
+	 * @param {string} data - Data to write
+	 */
+	write(data) {
+		this.terminal.write(data);
+	}
+
+	/**
+	 * Write line to terminal
+	 * @param {string} data - Data to write
+	 */
+	writeln(data) {
+		this.terminal.writeln(data);
+	}
+
+	/**
+	 * Clear terminal
+	 */
+	clear() {
+		this.terminal.clear();
+	}
+
+	/**
+	 * Focus terminal
+	 */
+	focus() {
+		this.terminal.focus();
+	}
+
+	/**
+	 * Blur terminal
+	 */
+	blur() {
+		this.terminal.blur();
+	}
+
+	/**
+	 * Search in terminal
+	 * @param {string} term - Search term
+	 * @param {number} skip Number of search results to skip
+	 * @param {boolean} backward Whether to search backward
+	 */
+	search(term, skip, backward) {
+		if (this.searchAddon) {
+			const searchOptions = {
+				regex: appSettings.value.search.regExp || false,
+				wholeWord: appSettings.value.search.wholeWord || false,
+				caseSensitive: appSettings.value.search.caseSensitive || false,
+				decorations: {
+					matchBorder: "#FFA500",
+					activeMatchBorder: "#FFFF00",
+				},
+			};
+			if (!term) {
+				return false;
+			}
+
+			if (backward) {
+				return this.searchAddon.findPrevious(term, searchOptions);
+			} else {
+				return this.searchAddon.findNext(term, searchOptions);
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Update terminal theme
+	 * @param {object|string} theme - Theme object or theme name
+	 */
+	updateTheme(theme) {
+		if (typeof theme === "string") {
+			theme = TerminalThemeManager.getTheme(theme);
+		}
+		this.options.theme = { ...this.options.theme, ...theme };
+		this.terminal.options.theme = this.options.theme;
+	}
+
+	/**
+	 * Update terminal options
+	 * @param {object} options - Options to update
+	 */
+	updateOptions(options) {
+		Object.keys(options).forEach((key) => {
+			if (key === "theme") {
+				this.updateTheme(options.theme);
+			} else {
+				this.terminal.options[key] = options[key];
+				this.options[key] = options[key];
+			}
+		});
+	}
+
+	/**
+	 * Load image addon
+	 */
+	loadImageAddon() {
+		if (!this.imageAddon) {
+			try {
+				this.imageAddon = new ImageAddon();
+				this.terminal.loadAddon(this.imageAddon);
+			} catch (error) {
+				console.error("Failed to load ImageAddon:", error);
+			}
+		}
+	}
+
+	/**
+	 * Dispose image addon
+	 */
+	disposeImageAddon() {
+		if (this.imageAddon) {
+			try {
+				this.imageAddon.dispose();
+				this.imageAddon = null;
+			} catch (error) {
+				console.error("Failed to dispose ImageAddon:", error);
+			}
+		}
+	}
+
+	/**
+	 * Update image support setting
+	 * @param {boolean} enabled - Whether to enable image support
+	 */
+	updateImageSupport(enabled) {
+		if (enabled) {
+			this.loadImageAddon();
+		} else {
+			this.disposeImageAddon();
+		}
+	}
+
+	/**
+	 * Load ligatures addon
+	 */
+	loadLigaturesAddon() {
+		if (!this.ligaturesAddon) {
+			try {
+				this.ligaturesAddon = new LigaturesAddon();
+				this.terminal.loadAddon(this.ligaturesAddon);
+			} catch (error) {
+				console.error("Failed to load LigaturesAddon:", error);
+			}
+		}
+	}
+
+	/**
+	 * Dispose ligatures addon
+	 */
+	disposeLigaturesAddon() {
+		if (this.ligaturesAddon) {
+			try {
+				this.ligaturesAddon.dispose();
+				this.ligaturesAddon = null;
+			} catch (error) {
+				console.error("Failed to dispose LigaturesAddon:", error);
+			}
+		}
+	}
+
+	/**
+	 * Update font ligatures setting
+	 * @param {boolean} enabled - Whether to enable font ligatures
+	 */
+	updateFontLigatures(enabled) {
+		if (enabled) {
+			this.loadLigaturesAddon();
+		} else {
+			this.disposeLigaturesAddon();
+		}
+	}
+
+	/**
+	 * Load terminal font if it's not already loaded
+	 */
+	async loadTerminalFont() {
+		const fontFamily = this.options.fontFamily;
+		if (fontFamily && fonts.get(fontFamily)) {
+			try {
+				await fonts.loadFont(fontFamily);
+			} catch (error) {
+				console.warn(`Failed to load terminal font ${fontFamily}:`, error);
+			}
+		}
+	}
+
+	/**
+	 * Increase terminal font size
+	 */
+	increaseFontSize() {
+		const currentSize = this.terminal.options.fontSize;
+		const newSize = Math.min(currentSize + 1, 24); // Max font size 24
+		this.updateFontSize(newSize);
+	}
+
+	/**
+	 * Decrease terminal font size
+	 */
+	decreaseFontSize() {
+		const currentSize = this.terminal.options.fontSize;
+		const newSize = Math.max(currentSize - 1, 8); // Min font size 8
+		this.updateFontSize(newSize);
+	}
+
+	/**
+	 * Update terminal font size and refresh display
+	 */
+	updateFontSize(fontSize) {
+		if (fontSize === this.terminal.options.fontSize) return;
+
+		this.terminal.options.fontSize = fontSize;
+		this.options.fontSize = fontSize;
+
+		// Update terminal settings properly
+		const currentSettings = appSettings.value.terminalSettings || {};
+		const updatedSettings = { ...currentSettings, fontSize };
+		appSettings.update({ terminalSettings: updatedSettings }, false);
+
+		// Refresh terminal display
+		this.terminal.refresh(0, this.terminal.rows - 1);
+
+		// Fit terminal to container after font size change to prevent empty space
+		setTimeout(() => {
+			if (this.fitAddon) {
+				this.fitAddon.fit();
+			}
+		}, 50);
+
+		// Update touch selection cell dimensions if it exists
+		if (this.touchSelection) {
+			setTimeout(() => {
+				this.touchSelection.updateCellDimensions();
+			}, 100);
+		}
+	}
+
+	/**
+	 * Terminate terminal session
+	 */
+	async terminate() {
+		if (this.websocket) {
+			this.websocket.close();
+		}
+
+		if (this.pid && this.serverMode) {
+			try {
+				await fetch(`http://localhost:8767/terminals/${this.pid}/terminate`, {
+					method: "POST",
+				});
+			} catch (error) {
+				console.error("Failed to terminate terminal:", error);
+			}
+		}
+	}
+
+	/**
+	 * Dispose terminal
+	 */
+	dispose() {
+		this.terminate();
+
+		// Dispose touch selection
+		if (this.touchSelection) {
+			this.touchSelection.destroy();
+			this.touchSelection = null;
+		}
+
+		// Dispose addons
+		this.disposeImageAddon();
+		this.disposeLigaturesAddon();
+
+		if (this.terminal) {
+			this.terminal.dispose();
+		}
+
+		if (this.container) {
+			this.container.remove();
+		}
+	}
+
+	// Event handlers (can be overridden)
+	onConnect() {}
+	onDisconnect() {}
+	onError(error) {}
+	onTitleChange(title) {}
+	onBell() {}
+	onProcessExit(exitData) {}
+}
diff --git a/src/components/terminal/terminalDefaults.js b/src/components/terminal/terminalDefaults.js
new file mode 100644
index 000000000..656d3f1ac
--- /dev/null
+++ b/src/components/terminal/terminalDefaults.js
@@ -0,0 +1,31 @@
+import appSettings from "lib/settings";
+
+export const DEFAULT_TERMINAL_SETTINGS = {
+	fontSize: 14,
+	fontFamily: "MesloLGS NF Regular",
+	fontWeight: "normal",
+	cursorBlink: true,
+	cursorStyle: "block",
+	cursorInactiveStyle: "underline",
+	scrollback: 1000,
+	theme: "dark",
+	tabStopWidth: 4,
+	convertEol: true,
+	letterSpacing: 0,
+	imageSupport: false,
+	fontLigatures: false,
+	// Touch selection settings
+	touchSelectionTapHoldDuration: 600,
+	touchSelectionMoveThreshold: 8,
+	touchSelectionHandleSize: 24,
+	touchSelectionHapticFeedback: true,
+	touchSelectionShowContextMenu: true,
+};
+
+export function getTerminalSettings() {
+	const settings = appSettings.value.terminalSettings || {};
+	return {
+		...DEFAULT_TERMINAL_SETTINGS,
+		...settings,
+	};
+}
diff --git a/src/components/terminal/terminalManager.js b/src/components/terminal/terminalManager.js
new file mode 100644
index 000000000..f723837e4
--- /dev/null
+++ b/src/components/terminal/terminalManager.js
@@ -0,0 +1,554 @@
+/**
+ * Terminal Manager
+ * Handles terminal session creation and management
+ */
+
+import EditorFile from "lib/editorFile";
+import TerminalComponent from "./terminal";
+import "@xterm/xterm/css/xterm.css";
+import toast from "components/toast";
+
+class TerminalManager {
+	constructor() {
+		this.terminals = new Map();
+		this.terminalCounter = 0;
+	}
+
+	/**
+	 * Create a new terminal session
+	 * @param {object} options - Terminal options
+	 * @returns {Promise<object>} Terminal instance info
+	 */
+	async createTerminal(options = {}) {
+		try {
+			const terminalId = `terminal_${++this.terminalCounter}`;
+			const terminalName = options.name || `Terminal ${this.terminalCounter}`;
+
+			// Check if terminal is installed before proceeding
+			if (options.serverMode !== false) {
+				const installationResult = await this.checkAndInstallTerminal();
+				if (!installationResult.success) {
+					throw new Error(installationResult.error);
+				}
+			}
+
+			// Create terminal component
+			const terminalComponent = new TerminalComponent({
+				serverMode: options.serverMode !== false,
+				...options,
+			});
+
+			// Create container
+			const terminalContainer = tag("div", {
+				className: "terminal-content",
+				id: `terminal-${terminalId}`,
+			});
+
+			// Terminal styles
+			const terminalStyles = this.getTerminalStyles();
+			const terminalStyle = tag("style", {
+				textContent: terminalStyles,
+			});
+			document.body.appendChild(terminalStyle);
+
+			// Create EditorFile for terminal
+			const terminalFile = new EditorFile(terminalName, {
+				type: "terminal",
+				content: terminalContainer,
+				tabIcon: "licons terminal",
+				render: true,
+			});
+
+			// Wait for tab creation and setup
+			const terminalInstance = await new Promise((resolve, reject) => {
+				setTimeout(async () => {
+					try {
+						// Mount terminal component
+						terminalComponent.mount(terminalContainer);
+
+						// Connect to session if in server mode
+						if (terminalComponent.serverMode) {
+							await terminalComponent.connectToSession();
+						} else {
+							// For local mode, just write a welcome message
+							terminalComponent.write(
+								"Local terminal mode - ready for output\r\n",
+							);
+						}
+
+						// Use PID as unique ID if available, otherwise fall back to terminalId
+						const uniqueId = terminalComponent.pid || terminalId;
+
+						// Setup event handlers
+						this.setupTerminalHandlers(
+							terminalFile,
+							terminalComponent,
+							uniqueId,
+						);
+
+						const instance = {
+							id: uniqueId,
+							name: terminalName,
+							component: terminalComponent,
+							file: terminalFile,
+							container: terminalContainer,
+						};
+
+						this.terminals.set(uniqueId, instance);
+						resolve(instance);
+					} catch (error) {
+						console.error("Failed to initialize terminal:", error);
+						reject(error);
+					}
+				}, 100);
+			});
+
+			return terminalInstance;
+		} catch (error) {
+			console.error("Failed to create terminal:", error);
+			throw error;
+		}
+	}
+
+	/**
+	 * Check if terminal is installed and install if needed
+	 * @returns {Promise<{success: boolean, error?: string}>}
+	 */
+	async checkAndInstallTerminal() {
+		try {
+			// Check if terminal is already installed
+			const isInstalled = await Terminal.isInstalled();
+			if (isInstalled) {
+				return { success: true };
+			}
+
+			// Check if terminal is supported on this device
+			const isSupported = await Terminal.isSupported();
+			if (!isSupported) {
+				return {
+					success: false,
+					error: "Terminal is not supported on this device architecture",
+				};
+			}
+
+			// Create installation progress terminal
+			const installTerminal = await this.createInstallationTerminal();
+
+			// Install terminal with progress logging
+			const installResult = await Terminal.install(
+				(message) => {
+					// Remove stdout/stderr prefix for
+					const cleanMessage = message.replace(/^(stdout|stderr)\s+/, "");
+					installTerminal.component.write(`${cleanMessage}\r\n`);
+				},
+				(error) => {
+					// Remove stdout/stderr prefix
+					const cleanError = error.replace(/^(stdout|stderr)\s+/, "");
+					installTerminal.component.write(
+						`\x1b[31mError: ${cleanError}\x1b[0m\r\n`,
+					);
+				},
+			);
+
+			// Only return success if Terminal.install() indicates success (exit code 0)
+			if (installResult === true) {
+				return { success: true };
+			} else {
+				return {
+					success: false,
+					error:
+						"Terminal installation failed - process did not exit with code 0",
+				};
+			}
+		} catch (error) {
+			console.error("Terminal installation failed:", error);
+			return {
+				success: false,
+				error: `Terminal installation failed: ${error.message}`,
+			};
+		}
+	}
+
+	/**
+	 * Create a terminal for showing installation progress
+	 * @returns {Promise<object>} Installation terminal instance
+	 */
+	async createInstallationTerminal() {
+		const terminalId = `install_terminal_${++this.terminalCounter}`;
+		const terminalName = "Terminal Installation";
+
+		// Create terminal component in local mode (no server needed)
+		const terminalComponent = new TerminalComponent({
+			serverMode: false,
+		});
+
+		// Create container
+		const terminalContainer = tag("div", {
+			className: "terminal-content",
+			id: `terminal-${terminalId}`,
+		});
+
+		// Terminal styles
+		const terminalStyles = this.getTerminalStyles();
+		const terminalStyle = tag("style", {
+			textContent: terminalStyles,
+		});
+		document.body.appendChild(terminalStyle);
+
+		// Create EditorFile for terminal
+		const terminalFile = new EditorFile(terminalName, {
+			type: "terminal",
+			content: terminalContainer,
+			tabIcon: "icon save_alt",
+			render: true,
+		});
+
+		// Wait for tab creation and setup
+		const terminalInstance = await new Promise((resolve, reject) => {
+			setTimeout(async () => {
+				try {
+					// Mount terminal component
+					terminalComponent.mount(terminalContainer);
+
+					// Write initial message
+					terminalComponent.write("🚀 Installing Terminal Environment...\r\n");
+					terminalComponent.write(
+						"This may take a few minutes depending on your connection.\r\n\r\n",
+					);
+
+					// Setup event handlers
+					this.setupTerminalHandlers(
+						terminalFile,
+						terminalComponent,
+						terminalId,
+					);
+
+					const instance = {
+						id: terminalId,
+						name: terminalName,
+						component: terminalComponent,
+						file: terminalFile,
+						container: terminalContainer,
+					};
+
+					this.terminals.set(terminalId, instance);
+					resolve(instance);
+				} catch (error) {
+					console.error("Failed to create installation terminal:", error);
+					reject(error);
+				}
+			}, 100);
+		});
+
+		return terminalInstance;
+	}
+
+	/**
+	 * Setup terminal event handlers
+	 * @param {EditorFile} terminalFile - Terminal file instance
+	 * @param {TerminalComponent} terminalComponent - Terminal component
+	 * @param {string} terminalId - Terminal ID
+	 */
+	setupTerminalHandlers(terminalFile, terminalComponent, terminalId) {
+		// Handle tab focus/blur
+		terminalFile.onfocus = () => {
+			setTimeout(() => {
+				terminalComponent.focus();
+				terminalComponent.fit();
+			}, 10);
+		};
+
+		// Handle tab close
+		terminalFile.onclose = () => {
+			this.closeTerminal(terminalId);
+		};
+
+		// Enhanced resize handling with debouncing
+		let resizeTimeout = null;
+		const RESIZE_DEBOUNCE = 200;
+		let lastResizeTime = 0;
+
+		const resizeObserver = new ResizeObserver((entries) => {
+			const now = Date.now();
+
+			// Clear any pending resize
+			if (resizeTimeout) {
+				clearTimeout(resizeTimeout);
+			}
+
+			// Debounce rapid resize events (common during keyboard open/close)
+			resizeTimeout = setTimeout(() => {
+				try {
+					// Check if terminal is still available and mounted
+					if (!terminalComponent.terminal || !terminalComponent.container) {
+						return;
+					}
+
+					// Get current terminal state
+					const currentRows = terminalComponent.terminal.rows;
+					const currentCols = terminalComponent.terminal.cols;
+
+					// Fit the terminal to new container size
+					terminalComponent.fit();
+
+					// Check if dimensions actually changed after fit
+					const newRows = terminalComponent.terminal.rows;
+					const newCols = terminalComponent.terminal.cols;
+
+					if (
+						Math.abs(newRows - currentRows) > 1 ||
+						Math.abs(newCols - currentCols) > 1
+					) {
+						// console.log(
+						// 	`Terminal ${terminalId} resized: ${currentRows}x${currentCols} -> ${newRows}x${newCols}`,
+						// );
+					}
+
+					// Update last resize time
+					lastResizeTime = now;
+				} catch (error) {
+					console.error(`Resize error for terminal ${terminalId}:`, error);
+				}
+			}, RESIZE_DEBOUNCE);
+		});
+
+		// Wait for the terminal container to be available, then observe it
+		setTimeout(() => {
+			const containerElement = terminalFile.content;
+			if (containerElement && containerElement instanceof Element) {
+				resizeObserver.observe(containerElement);
+			} else {
+				console.warn("Terminal container not available for ResizeObserver");
+			}
+		}, 200);
+
+		// Terminal event handlers
+		terminalComponent.onConnect = () => {
+			console.log(`Terminal ${terminalId} connected`);
+		};
+
+		terminalComponent.onDisconnect = () => {
+			console.log(`Terminal ${terminalId} disconnected`);
+		};
+
+		terminalComponent.onError = (error) => {
+			console.error(`Terminal ${terminalId} error:`, error);
+			window.toast?.("Terminal connection error");
+			// Close the terminal tab on error
+			this.closeTerminal(terminalId);
+		};
+
+		terminalComponent.onTitleChange = (title) => {
+			if (title) {
+				// Format terminal title as "Terminal ! - title"
+				const formattedTitle = `Terminal ${this.terminalCounter} - ${title}`;
+				terminalFile.filename = formattedTitle;
+			}
+		};
+
+		terminalComponent.onProcessExit = (exitData) => {
+			// Format exit message based on exit code and signal
+			let message;
+			if (exitData.signal) {
+				message = `Process terminated by signal ${exitData.signal}`;
+			} else if (exitData.exit_code === 0) {
+				message = `Process exited successfully (code ${exitData.exit_code})`;
+			} else {
+				message = `Process exited with code ${exitData.exit_code}`;
+			}
+
+			this.closeTerminal(terminalId);
+			terminalFile.remove(true);
+			toast(message);
+		};
+
+		// Store references for cleanup
+		terminalFile._terminalId = terminalId;
+		terminalFile.terminalComponent = terminalComponent;
+		terminalFile._resizeObserver = resizeObserver;
+	}
+
+	/**
+	 * Close a terminal session
+	 * @param {string} terminalId - Terminal ID
+	 */
+	closeTerminal(terminalId) {
+		const terminal = this.terminals.get(terminalId);
+		if (!terminal) return;
+
+		try {
+			// Cleanup resize observer
+			if (terminal.file._resizeObserver) {
+				terminal.file._resizeObserver.disconnect();
+			}
+
+			// Dispose terminal component
+			terminal.component.dispose();
+
+			// Remove from map
+			this.terminals.delete(terminalId);
+
+			console.log(`Terminal ${terminalId} closed`);
+		} catch (error) {
+			console.error(`Error closing terminal ${terminalId}:`, error);
+		}
+	}
+
+	/**
+	 * Get terminal by ID
+	 * @param {string} terminalId - Terminal ID
+	 * @returns {object|null} Terminal instance
+	 */
+	getTerminal(terminalId) {
+		return this.terminals.get(terminalId) || null;
+	}
+
+	/**
+	 * Get all active terminals
+	 * @returns {Map} All terminals
+	 */
+	getAllTerminals() {
+		return this.terminals;
+	}
+
+	/**
+	 * Write to a specific terminal
+	 * @param {string} terminalId - Terminal ID
+	 * @param {string} data - Data to write
+	 */
+	writeToTerminal(terminalId, data) {
+		const terminal = this.getTerminal(terminalId);
+		if (terminal) {
+			terminal.component.write(data);
+		}
+	}
+
+	/**
+	 * Clear a specific terminal
+	 * @param {string} terminalId - Terminal ID
+	 */
+	clearTerminal(terminalId) {
+		const terminal = this.getTerminal(terminalId);
+		if (terminal) {
+			terminal.component.clear();
+		}
+	}
+
+	/**
+	 * Get terminal styles for shadow DOM
+	 * @returns {string} CSS styles
+	 */
+	getTerminalStyles() {
+		return `
+			.terminal-content {
+				width: 100%;
+				height: 100%;
+				box-sizing: border-box;
+				background: #1e1e1e;
+				overflow: hidden;
+				position: relative;
+			}
+		`;
+	}
+
+	/**
+	 * Create a local terminal (no server connection)
+	 * @param {object} options - Terminal options
+	 * @returns {Promise<object>} Terminal instance
+	 */
+	async createLocalTerminal(options = {}) {
+		return this.createTerminal({
+			...options,
+			serverMode: false,
+		});
+	}
+
+	/**
+	 * Create a server terminal (with backend connection)
+	 * @param {object} options - Terminal options
+	 * @returns {Promise<object>} Terminal instance
+	 */
+	async createServerTerminal(options = {}) {
+		return this.createTerminal({
+			...options,
+			serverMode: true,
+		});
+	}
+
+	/**
+	 * Handle keyboard resize events for all terminals
+	 * This is called when the virtual keyboard opens/closes on mobile
+	 */
+	handleKeyboardResize() {
+		// Add a small delay to let the UI settle
+		setTimeout(() => {
+			this.terminals.forEach((terminal) => {
+				try {
+					if (terminal.component && terminal.component.terminal) {
+						// Force a re-fit for all terminals
+						terminal.component.fit();
+
+						// If terminal has lots of content, try to preserve scroll position
+						const buffer = terminal.component.terminal.buffer?.active;
+						if (
+							buffer &&
+							buffer.length > terminal.component.terminal.rows * 2
+						) {
+							// For content-heavy terminals, ensure we stay near the bottom if we were there
+							const wasNearBottom =
+								buffer.viewportY >=
+								buffer.length - terminal.component.terminal.rows - 5;
+							if (wasNearBottom) {
+								// Scroll to bottom after resize
+								setTimeout(() => {
+									terminal.component.terminal.scrollToBottom();
+								}, 100);
+							}
+						}
+					}
+				} catch (error) {
+					console.error(
+						`Error handling keyboard resize for terminal ${terminal.id}:`,
+						error,
+					);
+				}
+			});
+		}, 150);
+	}
+
+	/**
+	 * Stabilize terminal viewport after resize operations
+	 */
+	stabilizeTerminals() {
+		this.terminals.forEach((terminal) => {
+			try {
+				if (terminal.component && terminal.component.terminal) {
+					// Clear any touch selections during stabilization
+					if (
+						terminal.component.touchSelection &&
+						terminal.component.touchSelection.isSelecting
+					) {
+						terminal.component.touchSelection.clearSelection();
+					}
+
+					// Re-fit and refresh
+					terminal.component.fit();
+
+					// Focus the active terminal to ensure proper state
+					if (terminal.file && terminal.file.isOpen) {
+						setTimeout(() => {
+							terminal.component.focus();
+						}, 50);
+					}
+				}
+			} catch (error) {
+				console.error(`Error stabilizing terminal ${terminal.id}:`, error);
+			}
+		});
+	}
+}
+
+// Create singleton instance
+const terminalManager = new TerminalManager();
+
+export default terminalManager;
diff --git a/src/components/terminal/terminalThemeManager.js b/src/components/terminal/terminalThemeManager.js
new file mode 100644
index 000000000..d24074b3e
--- /dev/null
+++ b/src/components/terminal/terminalThemeManager.js
@@ -0,0 +1,581 @@
+/**
+ * Terminal Theme Manager
+ * Manages terminal themes and provides plugin API for custom themes
+ */
+
+class TerminalThemeManager {
+	constructor() {
+		this.themes = {
+			dark: {
+				background: "#1e1e1e",
+				foreground: "#ffffff",
+				cursor: "#ffffff",
+				cursorAccent: "#1e1e1e",
+				selection: "#ffffff40",
+				black: "#000000",
+				red: "#cd3131",
+				green: "#0dbc79",
+				yellow: "#e5e510",
+				blue: "#2472c8",
+				magenta: "#bc3fbc",
+				cyan: "#11a8cd",
+				white: "#e5e5e5",
+				brightBlack: "#666666",
+				brightRed: "#f14c4c",
+				brightGreen: "#23d18b",
+				brightYellow: "#f5f543",
+				brightBlue: "#3b8eea",
+				brightMagenta: "#d670d6",
+				brightCyan: "#29b8db",
+				brightWhite: "#ffffff",
+			},
+			light: {
+				background: "#ffffff",
+				foreground: "#000000",
+				cursor: "#000000",
+				cursorAccent: "#ffffff",
+				selection: "#00000040",
+				black: "#000000",
+				red: "#cd3131",
+				green: "#008000",
+				yellow: "#808000",
+				blue: "#0000ff",
+				magenta: "#800080",
+				cyan: "#008080",
+				white: "#c0c0c0",
+				brightBlack: "#808080",
+				brightRed: "#ff0000",
+				brightGreen: "#00ff00",
+				brightYellow: "#ffff00",
+				brightBlue: "#0000ff",
+				brightMagenta: "#ff00ff",
+				brightCyan: "#00ffff",
+				brightWhite: "#ffffff",
+			},
+			solarizedDark: {
+				background: "#002b36",
+				foreground: "#839496",
+				cursor: "#839496",
+				cursorAccent: "#002b36",
+				selection: "#073642",
+				black: "#073642",
+				red: "#dc322f",
+				green: "#859900",
+				yellow: "#b58900",
+				blue: "#268bd2",
+				magenta: "#d33682",
+				cyan: "#2aa198",
+				white: "#eee8d5",
+				brightBlack: "#002b36",
+				brightRed: "#cb4b16",
+				brightGreen: "#586e75",
+				brightYellow: "#657b83",
+				brightBlue: "#839496",
+				brightMagenta: "#6c71c4",
+				brightCyan: "#93a1a1",
+				brightWhite: "#fdf6e3",
+			},
+			solarizedLight: {
+				background: "#fdf6e3",
+				foreground: "#657b83",
+				cursor: "#657b83",
+				cursorAccent: "#fdf6e3",
+				selection: "#eee8d5",
+				black: "#073642",
+				red: "#dc322f",
+				green: "#859900",
+				yellow: "#b58900",
+				blue: "#268bd2",
+				magenta: "#d33682",
+				cyan: "#2aa198",
+				white: "#eee8d5",
+				brightBlack: "#002b36",
+				brightRed: "#cb4b16",
+				brightGreen: "#586e75",
+				brightYellow: "#657b83",
+				brightBlue: "#839496",
+				brightMagenta: "#6c71c4",
+				brightCyan: "#93a1a1",
+				brightWhite: "#fdf6e3",
+			},
+			monokai: {
+				background: "#272822",
+				foreground: "#f8f8f2",
+				cursor: "#f8f8f0",
+				cursorAccent: "#272822",
+				selection: "#49483e",
+				black: "#272822",
+				red: "#f92672",
+				green: "#a6e22e",
+				yellow: "#e6db74",
+				blue: "#66d9ef",
+				magenta: "#ae81ff",
+				cyan: "#a1efe4",
+				white: "#f8f8f2",
+				brightBlack: "#75715e",
+				brightRed: "#ff6188",
+				brightGreen: "#a6e22e",
+				brightYellow: "#ffd866",
+				brightBlue: "#78dce8",
+				brightMagenta: "#ab9df2",
+				brightCyan: "#a1efe4",
+				brightWhite: "#f9f8f5",
+			},
+			dracula: {
+				background: "#282a36",
+				foreground: "#f8f8f2",
+				cursor: "#f8f8f0",
+				cursorAccent: "#282a36",
+				selection: "#44475a",
+				black: "#000000",
+				red: "#ff5555",
+				green: "#50fa7b",
+				yellow: "#f1fa8c",
+				blue: "#bd93f9",
+				magenta: "#ff79c6",
+				cyan: "#8be9fd",
+				white: "#bfbfbf",
+				brightBlack: "#4d4d4d",
+				brightRed: "#ff6e67",
+				brightGreen: "#5af78e",
+				brightYellow: "#f4f99d",
+				brightBlue: "#caa9fa",
+				brightMagenta: "#ff92d0",
+				brightCyan: "#9aedfe",
+				brightWhite: "#e6e6e6",
+			},
+			nord: {
+				background: "#2e3440",
+				foreground: "#d8dee9",
+				cursor: "#d8dee9",
+				cursorAccent: "#2e3440",
+				selection: "#434c5e",
+				black: "#3b4252",
+				red: "#bf616a",
+				green: "#a3be8c",
+				yellow: "#ebcb8b",
+				blue: "#81a1c1",
+				magenta: "#b48ead",
+				cyan: "#88c0d0",
+				white: "#e5e9f0",
+				brightBlack: "#4c566a",
+				brightRed: "#d08770",
+				brightGreen: "#a3be8c",
+				brightYellow: "#ebcb8b",
+				brightBlue: "#5e81ac",
+				brightMagenta: "#b48ead",
+				brightCyan: "#8fbcbb",
+				brightWhite: "#eceff4",
+			},
+			gruvbox: {
+				background: "#282828",
+				foreground: "#ebdbb2",
+				cursor: "#ebdbb2",
+				cursorAccent: "#282828",
+				selection: "#665c54",
+				black: "#282828",
+				red: "#cc241d",
+				green: "#98971a",
+				yellow: "#d79921",
+				blue: "#458588",
+				magenta: "#b16286",
+				cyan: "#689d6a",
+				white: "#a89984",
+				brightBlack: "#928374",
+				brightRed: "#fb4934",
+				brightGreen: "#b8bb26",
+				brightYellow: "#fabd2f",
+				brightBlue: "#83a598",
+				brightMagenta: "#d3869b",
+				brightCyan: "#8ec07c",
+				brightWhite: "#ebdbb2",
+			},
+			oneDark: {
+				background: "#21252b",
+				foreground: "#abb2bf",
+				cursor: "#528bff",
+				cursorAccent: "#21252b",
+				selection: "#3e4451",
+				black: "#21252b",
+				red: "#e86671",
+				green: "#98c379",
+				yellow: "#e5c07b",
+				blue: "#61afef",
+				magenta: "#c678dd",
+				cyan: "#56b6c2",
+				white: "#abb2bf",
+				brightBlack: "#5c6370",
+				brightRed: "#f07178",
+				brightGreen: "#a6e22e",
+				brightYellow: "#f9e79f",
+				brightBlue: "#73d0ff",
+				brightMagenta: "#d19a66",
+				brightCyan: "#7fdbca",
+				brightWhite: "#ffffff",
+			},
+			material: {
+				background: "#263238",
+				foreground: "#eeffff",
+				cursor: "#ffcc00",
+				cursorAccent: "#263238",
+				selection: "#37474f",
+				black: "#263238",
+				red: "#f07178",
+				green: "#c3e88d",
+				yellow: "#ffcb6b",
+				blue: "#82aaff",
+				magenta: "#c792ea",
+				cyan: "#89ddff",
+				white: "#eeffff",
+				brightBlack: "#546e7a",
+				brightRed: "#f07178",
+				brightGreen: "#c3e88d",
+				brightYellow: "#ffcb6b",
+				brightBlue: "#82aaff",
+				brightMagenta: "#c792ea",
+				brightCyan: "#89ddff",
+				brightWhite: "#ffffff",
+			},
+			tokyoNight: {
+				background: "#1a1b26",
+				foreground: "#c0caf5",
+				cursor: "#c0caf5",
+				cursorAccent: "#1a1b26",
+				selection: "#33467c",
+				black: "#15161e",
+				red: "#f7768e",
+				green: "#9ece6a",
+				yellow: "#e0af68",
+				blue: "#7aa2f7",
+				magenta: "#bb9af7",
+				cyan: "#7dcfff",
+				white: "#a9b1d6",
+				brightBlack: "#414868",
+				brightRed: "#f7768e",
+				brightGreen: "#9ece6a",
+				brightYellow: "#e0af68",
+				brightBlue: "#7aa2f7",
+				brightMagenta: "#bb9af7",
+				brightCyan: "#7dcfff",
+				brightWhite: "#c0caf5",
+			},
+			catppuccin: {
+				background: "#1e1e2e",
+				foreground: "#cdd6f4",
+				cursor: "#f5e0dc",
+				cursorAccent: "#1e1e2e",
+				selection: "#585b70",
+				black: "#45475a",
+				red: "#f38ba8",
+				green: "#a6e3a1",
+				yellow: "#f9e2af",
+				blue: "#89b4fa",
+				magenta: "#f5c2e7",
+				cyan: "#94e2d5",
+				white: "#bac2de",
+				brightBlack: "#585b70",
+				brightRed: "#f38ba8",
+				brightGreen: "#a6e3a1",
+				brightYellow: "#f9e2af",
+				brightBlue: "#89b4fa",
+				brightMagenta: "#f5c2e7",
+				brightCyan: "#94e2d5",
+				brightWhite: "#a6adc8",
+			},
+			synthwave: {
+				background: "#241b2f",
+				foreground: "#f92aad",
+				cursor: "#f4f99d",
+				cursorAccent: "#241b2f",
+				selection: "#495495",
+				black: "#241b2f",
+				red: "#ff8b94",
+				green: "#a8e6cf",
+				yellow: "#f4f99d",
+				blue: "#88d8c0",
+				magenta: "#ff8b94",
+				cyan: "#88d8c0",
+				white: "#f92aad",
+				brightBlack: "#495495",
+				brightRed: "#ff8b94",
+				brightGreen: "#a8e6cf",
+				brightYellow: "#f4f99d",
+				brightBlue: "#88d8c0",
+				brightMagenta: "#ff8b94",
+				brightCyan: "#88d8c0",
+				brightWhite: "#f92aad",
+			},
+			cyberpunk: {
+				background: "#000b1e",
+				foreground: "#0abdc6",
+				cursor: "#ea00d9",
+				cursorAccent: "#000b1e",
+				selection: "#711c91",
+				black: "#000b1e",
+				red: "#ff0040",
+				green: "#00ff41",
+				yellow: "#ffff00",
+				blue: "#0080ff",
+				magenta: "#ea00d9",
+				cyan: "#0abdc6",
+				white: "#ffffff",
+				brightBlack: "#133e7c",
+				brightRed: "#ff0040",
+				brightGreen: "#00ff41",
+				brightYellow: "#ffff00",
+				brightBlue: "#0080ff",
+				brightMagenta: "#ea00d9",
+				brightCyan: "#0abdc6",
+				brightWhite: "#ffffff",
+			},
+			forest: {
+				background: "#1b2b1b",
+				foreground: "#d4ddd4",
+				cursor: "#87ceeb",
+				cursorAccent: "#1b2b1b",
+				selection: "#3a4f3a",
+				black: "#1b2b1b",
+				red: "#d75f5f",
+				green: "#87af87",
+				yellow: "#d7af5f",
+				blue: "#87ceeb",
+				magenta: "#af87af",
+				cyan: "#5fafaf",
+				white: "#d4ddd4",
+				brightBlack: "#5f6f5f",
+				brightRed: "#d75f5f",
+				brightGreen: "#87af87",
+				brightYellow: "#d7af5f",
+				brightBlue: "#87ceeb",
+				brightMagenta: "#af87af",
+				brightCyan: "#5fafaf",
+				brightWhite: "#ffffff",
+			},
+			sunset: {
+				background: "#3c1f1f",
+				foreground: "#ffd5a5",
+				cursor: "#ff8c42",
+				cursorAccent: "#3c1f1f",
+				selection: "#8b4513",
+				black: "#3c1f1f",
+				red: "#ff6b6b",
+				green: "#ffa500",
+				yellow: "#ffd700",
+				blue: "#ff8c42",
+				magenta: "#ff69b4",
+				cyan: "#ffa500",
+				white: "#ffd5a5",
+				brightBlack: "#8b4513",
+				brightRed: "#ff6b6b",
+				brightGreen: "#ffa500",
+				brightYellow: "#ffd700",
+				brightBlue: "#ff8c42",
+				brightMagenta: "#ff69b4",
+				brightCyan: "#ffa500",
+				brightWhite: "#fff8dc",
+			},
+			ocean: {
+				background: "#0f1419",
+				foreground: "#e6e1cf",
+				cursor: "#f29718",
+				cursorAccent: "#0f1419",
+				selection: "#253340",
+				black: "#0f1419",
+				red: "#ff3333",
+				green: "#b8cc52",
+				yellow: "#e7c547",
+				blue: "#36a3d9",
+				magenta: "#f07178",
+				cyan: "#95e6cb",
+				white: "#ffffff",
+				brightBlack: "#4d5566",
+				brightRed: "#ff3333",
+				brightGreen: "#b8cc52",
+				brightYellow: "#e7c547",
+				brightBlue: "#36a3d9",
+				brightMagenta: "#f07178",
+				brightCyan: "#95e6cb",
+				brightWhite: "#ffffff",
+			},
+		};
+
+		this.pluginThemes = new Map();
+	}
+
+	/**
+	 * Get a theme by name
+	 * @param {string} themeName - Theme name
+	 * @returns {object} Theme object
+	 */
+	getTheme(themeName) {
+		// Check plugin themes first
+		if (this.pluginThemes.has(themeName)) {
+			return this.pluginThemes.get(themeName);
+		}
+
+		// Check built-in themes
+		return this.themes[themeName] || this.themes.dark;
+	}
+
+	/**
+	 * Get all available themes
+	 * @returns {object} All themes
+	 */
+	getAllThemes() {
+		const allThemes = { ...this.themes };
+
+		// Add plugin themes
+		for (const [name, theme] of this.pluginThemes) {
+			allThemes[name] = theme;
+		}
+
+		return allThemes;
+	}
+
+	/**
+	 * Get all theme names
+	 * @returns {string[]} Array of theme names
+	 */
+	getThemeNames() {
+		return Object.keys(this.getAllThemes());
+	}
+
+	/**
+	 * Register a plugin theme
+	 * @param {string} name - Theme name
+	 * @param {object} theme - Theme object
+	 * @param {string} pluginId - Plugin ID for cleanup
+	 */
+	registerTheme(name, theme, pluginId) {
+		if (this.themes[name]) {
+			console.warn(
+				`Terminal theme '${name}' conflicts with built-in theme. Use a different name.`,
+			);
+			return false;
+		}
+
+		// Validate theme structure
+		if (!this.validateTheme(theme)) {
+			console.error(`Invalid terminal theme '${name}':`, theme);
+			return false;
+		}
+
+		// Store theme with plugin metadata
+		this.pluginThemes.set(name, {
+			...theme,
+			_pluginId: pluginId,
+			_isPlugin: true,
+		});
+
+		console.log(`Terminal theme '${name}' registered by plugin ${pluginId}`);
+		return true;
+	}
+
+	/**
+	 * Unregister a plugin theme
+	 * @param {string} name - Theme name
+	 * @param {string} pluginId - Plugin ID for verification
+	 */
+	unregisterTheme(name, pluginId) {
+		const theme = this.pluginThemes.get(name);
+
+		if (!theme) {
+			console.warn(`Terminal theme '${name}' not found`);
+			return false;
+		}
+
+		if (theme._pluginId !== pluginId) {
+			console.warn(
+				`Terminal theme '${name}' was not registered by plugin ${pluginId}`,
+			);
+			return false;
+		}
+
+		this.pluginThemes.delete(name);
+		console.log(`Terminal theme '${name}' unregistered`);
+		return true;
+	}
+
+	/**
+	 * Unregister all themes from a plugin
+	 * @param {string} pluginId - Plugin ID
+	 */
+	unregisterPluginThemes(pluginId) {
+		const themesToRemove = [];
+
+		for (const [name, theme] of this.pluginThemes) {
+			if (theme._pluginId === pluginId) {
+				themesToRemove.push(name);
+			}
+		}
+
+		themesToRemove.forEach((name) => {
+			this.pluginThemes.delete(name);
+		});
+
+		if (themesToRemove.length > 0) {
+			console.log(
+				`Unregistered ${themesToRemove.length} terminal themes from plugin ${pluginId}`,
+			);
+		}
+	}
+
+	/**
+	 * Validate theme structure
+	 * @param {object} theme - Theme object to validate
+	 * @returns {boolean} True if valid
+	 */
+	validateTheme(theme) {
+		const requiredColors = [
+			"background",
+			"foreground",
+			"cursor",
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"brightBlack",
+			"brightRed",
+			"brightGreen",
+			"brightYellow",
+			"brightBlue",
+			"brightMagenta",
+			"brightCyan",
+			"brightWhite",
+		];
+
+		if (!theme || typeof theme !== "object") {
+			return false;
+		}
+
+		// Check required colors
+		for (const color of requiredColors) {
+			if (!theme[color] || typeof theme[color] !== "string") {
+				console.warn(`Terminal theme missing or invalid color: ${color}`);
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Create a theme variant based on existing theme
+	 * @param {string} baseName - Base theme name
+	 * @param {object} overrides - Color overrides
+	 * @returns {object} New theme object
+	 */
+	createVariant(baseName, overrides) {
+		const baseTheme = this.getTheme(baseName);
+		return { ...baseTheme, ...overrides };
+	}
+}
+
+// Create singleton instance
+const terminalThemeManager = new TerminalThemeManager();
+
+export default terminalThemeManager;
diff --git a/src/components/terminal/terminalTouchSelection.css b/src/components/terminal/terminalTouchSelection.css
new file mode 100644
index 000000000..2cb7b1896
--- /dev/null
+++ b/src/components/terminal/terminalTouchSelection.css
@@ -0,0 +1,135 @@
+/**
+ * Terminal Touch Selection Styles
+ */
+
+.terminal-selection-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+  z-index: 100;
+  overflow: hidden;
+}
+
+.terminal-selection-handle {
+  position: absolute;
+  background: #2196f3;
+  border: 2px solid #fff;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+  display: none;
+  pointer-events: auto;
+  touch-action: none;
+  z-index: 101;
+  cursor: grab;
+  transition: transform 0.15s ease;
+}
+
+.terminal-selection-handle:active {
+  cursor: grabbing;
+}
+
+.terminal-selection-handle-start,
+.terminal-selection-handle-end {
+  transform: rotate(135deg);
+  border-radius: 50% 50% 50% 0;
+}
+
+.terminal-context-menu {
+  position: absolute;
+  background-color: var(--secondary-color);
+  border-radius: 4px;
+  height: 40px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+  box-shadow: 0 4px 12px var(--box-shadow-color);
+  border: none;
+  border: solid 1px var(--popup-border-color);
+  z-index: 1000;
+  min-width: 200px;
+  animation: fadeIn 0.2s ease;
+  flex-direction: row;
+  align-items: center;
+  justify-content: space-around;
+  pointer-events: auto;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.terminal-context-menu button {
+  display: inline-block;
+  flex: 1;
+  padding: 12px 16px;
+  border: none;
+  background: transparent;
+  color: #fff;
+  font-size: 14px;
+  font-weight: 500;
+  text-align: center;
+  cursor: pointer;
+  border-radius: 16px;
+  margin: 0 4px;
+  transition: background-color 0.15s ease;
+  white-space: nowrap;
+  pointer-events: auto;
+}
+
+.terminal-context-menu button:hover,
+.terminal-context-menu button:focus {
+  background: #616161;
+  outline: none;
+}
+
+.terminal-context-menu button:active {
+  background: #757575;
+}
+
+@media (min-width: 768px) {
+  .terminal-selection-handle {
+    width: 28px;
+    height: 28px;
+  }
+
+  .terminal-context-menu {
+    min-width: 240px;
+  }
+
+  .terminal-context-menu button {
+    padding: 14px 18px;
+    font-size: 16px;
+  }
+}
+
+@media (prefers-contrast: high) {
+  .terminal-selection-handle {
+    border-width: 3px;
+    box-shadow: 0 3px 12px rgba(0, 0, 0, 0.6);
+  }
+
+  .terminal-context-menu {
+    border: 2px solid #000;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .terminal-selection-handle {
+    transition: none;
+  }
+
+  .terminal-context-menu {
+    animation: none;
+  }
+
+  .terminal-context-menu button {
+    transition: none;
+  }
+}
diff --git a/src/components/terminal/terminalTouchSelection.js b/src/components/terminal/terminalTouchSelection.js
new file mode 100644
index 000000000..3a4803714
--- /dev/null
+++ b/src/components/terminal/terminalTouchSelection.js
@@ -0,0 +1,1212 @@
+/**
+ * Touch Selection for Terminal
+ */
+import "./terminalTouchSelection.css";
+
+export default class TerminalTouchSelection {
+	constructor(terminal, container, options = {}) {
+		this.terminal = terminal;
+		this.container = container;
+		this.options = {
+			tapHoldDuration: 600,
+			moveThreshold: 8,
+			handleSize: 24,
+			hapticFeedback: true,
+			showContextMenu: true,
+			fingerOffset: 40, // Offset in pixels to position selection above finger during drag
+			...options,
+		};
+
+		// Selection state
+		this.isSelecting = false;
+		this.isHandleDragging = false;
+		this.selectionStart = null;
+		this.selectionEnd = null;
+		this.currentSelection = null;
+
+		// Touch tracking
+		this.touchStartTime = 0;
+		this.touchStartPos = { x: 0, y: 0 };
+		this.initialTouchPos = { x: 0, y: 0 };
+		this.tapHoldTimeout = null;
+		this.dragHandle = null;
+
+		// Zoom tracking
+		this.pinchStartDistance = 0;
+		this.lastPinchDistance = 0;
+		this.isPinching = false;
+		this.initialFontSize = 0;
+		this.lastZoomTime = 0;
+		this.zoomThrottle = 50; // ms
+
+		// DOM elements
+		this.selectionOverlay = null;
+		this.startHandle = null;
+		this.endHandle = null;
+		this.contextMenu = null;
+
+		// Cell dimensions cache
+		this.cellDimensions = { width: 0, height: 0 };
+
+		// Event handlers
+		this.boundHandlers = {};
+
+		// Focus tracking
+		this.wasFocusedBeforeSelection = false;
+		this.contextMenuShouldStayVisible = false;
+
+		// Selection protection during keyboard events
+		this.selectionProtected = false;
+		this.protectionTimeout = null;
+
+		this.init();
+	}
+
+	init() {
+		this.createSelectionOverlay();
+		this.createHandles();
+		this.attachEventListeners();
+		this.updateCellDimensions();
+	}
+
+	createSelectionOverlay() {
+		this.selectionOverlay = document.createElement("div");
+		this.selectionOverlay.className = "terminal-selection-overlay";
+		this.selectionOverlay.style.cssText = `
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 100;
+      overflow: hidden;
+    `;
+		this.container.appendChild(this.selectionOverlay);
+	}
+
+	createHandles() {
+		this.startHandle = this.createHandle("start");
+		this.startHandle.style.cssText += `
+      transform: rotate(135deg);
+      border-radius: 50% 50% 50% 0;
+    `;
+
+		this.endHandle = this.createHandle("end");
+		this.endHandle.style.cssText += `
+      transform: rotate(135deg);
+      border-radius: 50% 50% 50% 0;
+    `;
+
+		this.selectionOverlay.appendChild(this.startHandle);
+		this.selectionOverlay.appendChild(this.endHandle);
+	}
+
+	createHandle(type) {
+		const handle = document.createElement("div");
+		handle.className = `terminal-selection-handle terminal-selection-handle-${type}`;
+		handle.style.cssText = `
+      position: absolute;
+      width: ${this.options.handleSize}px;
+      height: ${this.options.handleSize}px;
+      background: #2196F3;
+      border: 2px solid #fff;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.3);
+      display: none;
+      pointer-events: auto;
+      touch-action: none;
+      z-index: 101;
+      cursor: grab;
+    `;
+
+		// Ensure dataset is properly set
+		handle.dataset.handleType = type;
+
+		return handle;
+	}
+
+	attachEventListeners() {
+		// Terminal touch events
+		this.boundHandlers.terminalTouchStart =
+			this.onTerminalTouchStart.bind(this);
+		this.boundHandlers.terminalTouchMove = this.onTerminalTouchMove.bind(this);
+		this.boundHandlers.terminalTouchEnd = this.onTerminalTouchEnd.bind(this);
+
+		this.terminal.element.addEventListener(
+			"touchstart",
+			this.boundHandlers.terminalTouchStart,
+			{ passive: false },
+		);
+		this.terminal.element.addEventListener(
+			"touchmove",
+			this.boundHandlers.terminalTouchMove,
+			{ passive: false },
+		);
+		this.terminal.element.addEventListener(
+			"touchend",
+			this.boundHandlers.terminalTouchEnd,
+			{ passive: false },
+		);
+
+		// Handle touch events
+		this.boundHandlers.handleTouchStart = this.onHandleTouchStart.bind(this);
+		this.boundHandlers.handleTouchMove = this.onHandleTouchMove.bind(this);
+		this.boundHandlers.handleTouchEnd = this.onHandleTouchEnd.bind(this);
+
+		this.startHandle.addEventListener(
+			"touchstart",
+			this.boundHandlers.handleTouchStart,
+			{ passive: false },
+		);
+		this.startHandle.addEventListener(
+			"touchmove",
+			this.boundHandlers.handleTouchMove,
+			{ passive: false },
+		);
+		this.startHandle.addEventListener(
+			"touchend",
+			this.boundHandlers.handleTouchEnd,
+			{ passive: false },
+		);
+
+		this.endHandle.addEventListener(
+			"touchstart",
+			this.boundHandlers.handleTouchStart,
+			{ passive: false },
+		);
+		this.endHandle.addEventListener(
+			"touchmove",
+			this.boundHandlers.handleTouchMove,
+			{ passive: false },
+		);
+		this.endHandle.addEventListener(
+			"touchend",
+			this.boundHandlers.handleTouchEnd,
+			{ passive: false },
+		);
+
+		// Selection change listener
+		this.boundHandlers.selectionChange = this.onSelectionChange.bind(this);
+		this.terminal.onSelectionChange(this.boundHandlers.selectionChange);
+
+		// Click outside to clear selection - only within terminal area
+		this.boundHandlers.terminalAreaTouchStart =
+			this.onTerminalAreaTouchStart.bind(this);
+		this.terminal.element.addEventListener(
+			"touchstart",
+			this.boundHandlers.terminalAreaTouchStart,
+			{ passive: false },
+		);
+
+		// Orientation change
+		this.boundHandlers.orientationChange = this.onOrientationChange.bind(this);
+		window.addEventListener(
+			"orientationchange",
+			this.boundHandlers.orientationChange,
+		);
+		window.addEventListener("resize", this.boundHandlers.orientationChange);
+
+		// Terminal scroll listener
+		this.boundHandlers.terminalScroll = this.onTerminalScroll.bind(this);
+		this.terminal.element.addEventListener(
+			"scroll",
+			this.boundHandlers.terminalScroll,
+			{ passive: true },
+		);
+
+		// Terminal resize listener (for keyboard events)
+		this.boundHandlers.terminalResize = this.onTerminalResize.bind(this);
+		this.terminal.onResize(this.boundHandlers.terminalResize);
+	}
+
+	onTerminalTouchStart(event) {
+		// Handle pinch zoom
+		if (event.touches.length === 2) {
+			event.preventDefault();
+			this.startPinchZoom(event);
+			return;
+		}
+
+		// Only handle single touch for selection
+		if (event.touches.length !== 1) return;
+
+		const touch = event.touches[0];
+		this.touchStartTime = Date.now();
+		this.touchStartPos = { x: touch.clientX, y: touch.clientY };
+		this.initialTouchPos = { x: touch.clientX, y: touch.clientY };
+
+		// If already selecting, don't start new selection
+		if (this.isSelecting) {
+			return;
+		}
+
+		// Clear any existing tap-hold timeout
+		if (this.tapHoldTimeout) {
+			clearTimeout(this.tapHoldTimeout);
+		}
+
+		// Start tap-hold timer
+		this.tapHoldTimeout = setTimeout(() => {
+			if (!this.isSelecting && !this.isPinching) {
+				this.startSelection(touch);
+			}
+		}, this.options.tapHoldDuration);
+	}
+
+	onTerminalTouchMove(event) {
+		// Handle pinch zoom
+		if (event.touches.length === 2) {
+			event.preventDefault();
+			this.handlePinchZoom(event);
+			return;
+		}
+
+		if (event.touches.length !== 1) return;
+
+		// Don't handle single touch if we're pinching
+		if (this.isPinching) return;
+
+		const touch = event.touches[0];
+		const deltaX = Math.abs(touch.clientX - this.touchStartPos.x);
+		const deltaY = Math.abs(touch.clientY - this.touchStartPos.y);
+
+		// If significant movement, cancel tap-hold
+		if (
+			deltaX > this.options.moveThreshold ||
+			deltaY > this.options.moveThreshold
+		) {
+			if (this.tapHoldTimeout) {
+				clearTimeout(this.tapHoldTimeout);
+				this.tapHoldTimeout = null;
+			}
+
+			// If we're selecting, extend selection
+			if (this.isSelecting && !this.isHandleDragging) {
+				event.preventDefault();
+				this.extendSelection(touch);
+			}
+		}
+	}
+
+	onTerminalTouchEnd(event) {
+		// Handle end of pinch zoom
+		if (this.isPinching) {
+			this.endPinchZoom();
+			return;
+		}
+
+		if (this.tapHoldTimeout) {
+			clearTimeout(this.tapHoldTimeout);
+			this.tapHoldTimeout = null;
+		}
+
+		// If we were selecting and not dragging handles, finalize selection
+		if (this.isSelecting && !this.isHandleDragging) {
+			this.finalizeSelection();
+		} else if (!this.isSelecting) {
+			// Only focus terminal on touch end if not selecting and terminal was already focused
+			// This prevents keyboard popup when just starting selection
+			const currentlyFocused = this.isTerminalFocused();
+			if (currentlyFocused) {
+				// Terminal is already focused, maintain focus
+				this.terminal.focus();
+			}
+			// If terminal wasn't focused, don't focus it (prevents keyboard popup)
+		}
+	}
+
+	onHandleTouchStart(event) {
+		event.preventDefault();
+		event.stopPropagation();
+
+		if (event.touches.length !== 1) return;
+
+		// Ensure we have the correct handle type
+		let handleType = event.target.dataset.handleType;
+		if (!handleType) {
+			// Fallback to checking which handle was touched
+			if (
+				event.target === this.startHandle ||
+				this.startHandle.contains(event.target)
+			) {
+				handleType = "start";
+			} else if (
+				event.target === this.endHandle ||
+				this.endHandle.contains(event.target)
+			) {
+				handleType = "end";
+			}
+		}
+
+		if (!handleType) {
+			console.warn("Could not determine handle type for drag");
+			return;
+		}
+
+		this.isHandleDragging = true;
+		this.dragHandle = handleType;
+
+		// Store the initial touch position for delta calculations
+		const touch = event.touches[0];
+		this.initialTouchPos = { x: touch.clientX, y: touch.clientY };
+
+		// Update handle appearance - ensure we're updating the correct handle
+		const targetHandle =
+			handleType === "start" ? this.startHandle : this.endHandle;
+		targetHandle.style.cursor = "grabbing";
+		if (!targetHandle.style.transform.includes("scale")) {
+			targetHandle.style.transform += " scale(1.2)";
+		}
+	}
+
+	onHandleTouchMove(event) {
+		if (!this.isHandleDragging || event.touches.length !== 1) return;
+
+		event.preventDefault();
+		event.stopPropagation();
+
+		const touch = event.touches[0];
+
+		// Check if there's significant movement before updating selection
+		const deltaX = Math.abs(touch.clientX - this.initialTouchPos.x);
+		const deltaY = Math.abs(touch.clientY - this.initialTouchPos.y);
+
+		// Only update selection if there's significant movement (prevents micro-movements)
+		if (
+			deltaX < this.options.moveThreshold &&
+			deltaY < this.options.moveThreshold
+		) {
+			return;
+		}
+
+		// Apply finger offset for better visibility during drag
+		const adjustedTouch = {
+			clientX: touch.clientX,
+			clientY: touch.clientY - this.options.fingerOffset,
+		};
+
+		const coords = this.touchToTerminalCoords(adjustedTouch);
+
+		if (coords) {
+			// Allow handle swapping but manage it properly
+			if (this.dragHandle === "start") {
+				this.selectionStart = coords;
+
+				// If start goes past end, swap the handles logically
+				if (
+					this.selectionEnd &&
+					(coords.row > this.selectionEnd.row ||
+						(coords.row === this.selectionEnd.row &&
+							coords.col > this.selectionEnd.col))
+				) {
+					// Swap internally but keep drag handle reference
+					const temp = this.selectionStart;
+					this.selectionStart = this.selectionEnd;
+					this.selectionEnd = temp;
+					this.dragHandle = "end"; // Continue dragging as end handle
+				}
+			} else {
+				this.selectionEnd = coords;
+
+				// If end goes before start, swap the handles logically
+				if (
+					this.selectionStart &&
+					(coords.row < this.selectionStart.row ||
+						(coords.row === this.selectionStart.row &&
+							coords.col < this.selectionStart.col))
+				) {
+					// Swap internally but keep drag handle reference
+					const temp = this.selectionEnd;
+					this.selectionEnd = this.selectionStart;
+					this.selectionStart = temp;
+					this.dragHandle = "start"; // Continue dragging as start handle
+				}
+			}
+			this.updateSelection();
+		}
+	}
+
+	onHandleTouchEnd(event) {
+		if (!this.isHandleDragging) return;
+
+		event.preventDefault();
+		event.stopPropagation();
+
+		// Store the current drag handle before clearing
+		const currentDragHandle = this.dragHandle;
+
+		this.isHandleDragging = false;
+		this.dragHandle = null;
+
+		// Reset handle appearance - reset both handles to be safe
+		const handles = [this.startHandle, this.endHandle];
+		handles.forEach((handle) => {
+			handle.style.cursor = "grab";
+			// More robust transform cleanup
+			handle.style.transform = handle.style.transform
+				.replace(/\s*scale\([^)]*\)/g, "")
+				.trim();
+		});
+
+		this.finalizeSelection();
+	}
+
+	onSelectionChange() {
+		if (!this.isSelecting) return;
+
+		const selection = this.terminal.getSelection();
+		if (selection && selection.length > 0) {
+			this.currentSelection = selection;
+			this.updateHandlePositions();
+		}
+	}
+
+	onTerminalAreaTouchStart(event) {
+		// Clear selection if touching terminal area while selecting, except on handles or context menu
+		if (this.isSelecting) {
+			// Don't clear selection if it's protected (during keyboard events)
+			if (this.selectionProtected) {
+				return;
+			}
+
+			// Don't interfere with context menu at all
+			if (this.contextMenu && this.contextMenu.style.display === "flex") {
+				// Context menu is visible, check if touching it
+				const rect = this.contextMenu.getBoundingClientRect();
+				const touchX = event.touches[0].clientX;
+				const touchY = event.touches[0].clientY;
+
+				if (
+					touchX >= rect.left &&
+					touchX <= rect.right &&
+					touchY >= rect.top &&
+					touchY <= rect.bottom
+				) {
+					// Touching context menu area, don't clear selection
+					return;
+				}
+			}
+
+			const isHandleTouch =
+				this.startHandle.contains(event.target) ||
+				this.endHandle.contains(event.target);
+
+			// Only clear if touching within terminal but not on handles
+			if (!isHandleTouch && this.terminal.element.contains(event.target)) {
+				this.clearSelection();
+			}
+		}
+	}
+
+	onOrientationChange() {
+		// Update cell dimensions and handle positions after orientation change
+		setTimeout(() => {
+			this.updateCellDimensions();
+			if (this.isSelecting) {
+				this.updateHandlePositions();
+			}
+		}, 100);
+	}
+
+	onTerminalScroll() {
+		// Update handle positions when terminal is scrolled
+		if (this.isSelecting) {
+			this.updateHandlePositions();
+			// Hide context menu if it's open during scroll
+			if (this.contextMenu && this.contextMenu.style.display === "flex") {
+				this.hideContextMenu();
+			}
+		}
+	}
+
+	onTerminalResize(size) {
+		// Handle terminal resize (keyboard open/close on Android)
+		setTimeout(() => {
+			this.updateCellDimensions();
+			if (this.isSelecting) {
+				// Don't clear selection if it's protected (during keyboard events)
+				if (this.selectionProtected) {
+					// Just update handle positions during protected period
+					this.updateHandlePositions();
+					return;
+				}
+
+				// Only clear selection if it becomes invalid due to actual content resize
+				// Don't clear selection for keyboard-related resizes
+				if (
+					this.selectionStart &&
+					this.selectionEnd &&
+					(this.selectionStart.row >= size.rows ||
+						this.selectionEnd.row >= size.rows)
+				) {
+					this.clearSelection();
+				} else if (this.isSelecting) {
+					// Maintain selection and update handle positions
+					this.updateHandlePositions();
+					// Temporarily hide context menu during resize but keep selection
+					if (this.contextMenu && this.contextMenu.style.display === "flex") {
+						this.hideContextMenu();
+					}
+					// Re-show context menu after resize if selection is still active
+					setTimeout(() => {
+						if (this.isSelecting && this.options.showContextMenu) {
+							this.showContextMenu();
+						}
+					}, 100);
+				}
+			}
+		}, 50);
+	}
+
+	startSelection(touch) {
+		const coords = this.touchToTerminalCoords(touch);
+		if (!coords) return;
+
+		// Store initial focus state
+		this.wasFocusedBeforeSelection = this.isTerminalFocused();
+
+		// Protect selection from being cancelled by keyboard events
+		this.selectionProtected = true;
+		if (this.protectionTimeout) {
+			clearTimeout(this.protectionTimeout);
+		}
+		// Remove protection after keyboard events have settled
+		this.protectionTimeout = setTimeout(() => {
+			this.selectionProtected = false;
+		}, 1000);
+
+		this.isSelecting = true;
+
+		// Try to auto-select word at touch position
+		const wordBounds = this.getWordBoundsAt(coords);
+		if (wordBounds) {
+			// Select the entire word
+			this.selectionStart = wordBounds.start;
+			this.selectionEnd = wordBounds.end;
+		} else {
+			// Fallback to single character selection
+			this.selectionStart = coords;
+			this.selectionEnd = coords;
+		}
+
+		// Clear any existing selection
+		this.terminal.clearSelection();
+
+		// Apply the selection
+		this.updateSelection();
+
+		// Store current selection for immediate access
+		this.currentSelection = this.terminal.getSelection();
+
+		// Show handles
+		this.showHandles();
+
+		if (this.options.showContextMenu) {
+			this.showContextMenu();
+		}
+
+		// Haptic feedback
+		if (this.options.hapticFeedback && navigator.vibrate) {
+			navigator.vibrate(50);
+		}
+
+		// Don't change focus state during selection
+		// Terminal should maintain its current focus state
+	}
+
+	extendSelection(touch) {
+		const coords = this.touchToTerminalCoords(touch);
+		if (!coords) return;
+
+		this.selectionEnd = coords;
+		this.updateSelection();
+	}
+
+	updateSelection() {
+		if (!this.selectionStart || !this.selectionEnd) return;
+
+		const start = this.selectionStart;
+		const end = this.selectionEnd;
+
+		// Ensure start is before end
+		let startRow = start.row;
+		let startCol = start.col;
+		let endRow = end.row;
+		let endCol = end.col;
+
+		if (startRow > endRow || (startRow === endRow && startCol > endCol)) {
+			[startRow, startCol, endRow, endCol] = [
+				endRow,
+				endCol,
+				startRow,
+				startCol,
+			];
+		}
+
+		// Calculate selection length
+		const length = this.calculateSelectionLength(
+			startRow,
+			startCol,
+			endRow,
+			endCol,
+		);
+
+		// Clear and set new selection
+		this.terminal.clearSelection();
+		this.terminal.select(startCol, startRow, length);
+
+		this.updateHandlePositions();
+
+		// Ensure context menu stays visible if it should be
+		if (this.contextMenuShouldStayVisible && this.options.showContextMenu) {
+			this.showContextMenu();
+		}
+	}
+
+	calculateSelectionLength(startRow, startCol, endRow, endCol) {
+		if (startRow === endRow) {
+			return endCol - startCol + 1;
+		}
+
+		const cols = this.terminal.cols;
+		let length = cols - startCol; // First row
+		length += (endRow - startRow - 1) * cols; // Middle rows
+		length += endCol + 1; // Last row
+
+		return length;
+	}
+
+	finalizeSelection() {
+		if (this.options.showContextMenu && this.currentSelection) {
+			this.showContextMenu();
+		}
+	}
+
+	showHandles() {
+		this.startHandle.style.display = "block";
+		this.endHandle.style.display = "block";
+		this.updateHandlePositions();
+	}
+
+	hideHandles() {
+		this.startHandle.style.display = "none";
+		this.endHandle.style.display = "none";
+	}
+
+	updateHandlePositions() {
+		if (!this.selectionStart || !this.selectionEnd) return;
+
+		let logicalStart, logicalEnd;
+		if (
+			this.selectionStart.row < this.selectionEnd.row ||
+			(this.selectionStart.row === this.selectionEnd.row &&
+				this.selectionStart.col <= this.selectionEnd.col)
+		) {
+			logicalStart = this.selectionStart;
+			logicalEnd = this.selectionEnd;
+		} else {
+			logicalStart = this.selectionEnd;
+			logicalEnd = this.selectionStart;
+		}
+
+		const startPos = this.terminalCoordsToPixels(logicalStart);
+		const endPos = this.terminalCoordsToPixels(logicalEnd);
+
+		// Show/hide start handle at logical start position
+		if (startPos) {
+			this.startHandle.style.display = "block";
+			this.startHandle.style.left = `${startPos.x - this.options.handleSize / 2 - 0.1}px`;
+			this.startHandle.style.top = `${startPos.y + this.cellDimensions.height + 4}px`;
+		} else {
+			this.startHandle.style.display = "none";
+		}
+
+		// Show/hide end handle at logical end position
+		if (endPos) {
+			this.endHandle.style.display = "block";
+			this.endHandle.style.left = `${endPos.x + this.cellDimensions.width - this.options.handleSize / 2 - 1}px`;
+			this.endHandle.style.top = `${endPos.y + this.cellDimensions.height + 4}px`;
+		} else {
+			this.endHandle.style.display = "none";
+		}
+	}
+
+	showContextMenu() {
+		if (!this.contextMenu) {
+			this.createContextMenu();
+		}
+
+		// Mark that context menu should stay visible
+		this.contextMenuShouldStayVisible = true;
+
+		// Position context menu - center it on selection with viewport bounds checking
+		const startPos = this.terminalCoordsToPixels(this.selectionStart);
+		const endPos = this.terminalCoordsToPixels(this.selectionEnd);
+
+		if (startPos || endPos) {
+			// Use whichever position is available, or center between them
+			let centerX, baseY;
+
+			if (startPos && endPos) {
+				centerX = (startPos.x + endPos.x) / 2;
+				// Position below the lower of the two positions
+				baseY = Math.max(startPos.y, endPos.y);
+			} else if (startPos) {
+				centerX = startPos.x;
+				baseY = startPos.y;
+			} else {
+				centerX = endPos.x;
+				baseY = endPos.y;
+			}
+
+			const menuWidth = this.contextMenu.offsetWidth || 200;
+			const menuHeight = this.contextMenu.offsetHeight || 50;
+
+			const containerRect = this.container.getBoundingClientRect();
+
+			// Calculate initial position
+			let menuX = centerX - menuWidth / 2;
+			let menuY = baseY + this.cellDimensions.height + 40;
+
+			// Ensure menu stays within terminal bounds horizontally
+			const minX = 10; // padding from left edge
+			const maxX = containerRect.width - menuWidth - 10; // padding from right edge
+			menuX = Math.max(minX, Math.min(menuX, maxX));
+
+			// Ensure menu stays within terminal bounds vertically
+			const maxY = containerRect.height - menuHeight - 10; // padding from bottom
+			if (menuY > maxY) {
+				// If menu would go below terminal, position it above the selection
+				const topY =
+					startPos && endPos ? Math.min(startPos.y, endPos.y) : baseY;
+				menuY = topY - menuHeight - 10;
+			}
+
+			// Final bounds check
+			menuY = Math.max(10, Math.min(menuY, maxY));
+
+			this.contextMenu.style.left = `${menuX}px`;
+			this.contextMenu.style.top = `${menuY}px`;
+			this.contextMenu.style.display = "flex";
+		}
+	}
+
+	createContextMenu() {
+		this.contextMenu = document.createElement("div");
+		this.contextMenu.className = "terminal-context-menu";
+
+		// Add menu items
+		const menuItems = [
+			{ label: strings["copy"], action: this.copySelection.bind(this) },
+			{ label: strings["paste"], action: this.pasteFromClipboard.bind(this) },
+			{ label: "More...", action: this.showMoreOptions.bind(this) },
+		];
+
+		menuItems.forEach((item) => {
+			const button = document.createElement("button");
+			button.textContent = item.label;
+
+			// Flag to prevent multiple activations
+			let actionExecuted = false;
+
+			// Handle touch interactions
+			button.addEventListener("touchstart", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				actionExecuted = false;
+			});
+
+			button.addEventListener("touchend", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				if (!actionExecuted) {
+					actionExecuted = true;
+					item.action();
+				}
+			});
+
+			// Handle mouse interactions
+			button.addEventListener("mousedown", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				actionExecuted = false;
+			});
+
+			button.addEventListener("mouseup", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+				if (!actionExecuted) {
+					actionExecuted = true;
+					item.action();
+				}
+			});
+
+			// Prevent default click
+			button.addEventListener("click", (e) => {
+				e.preventDefault();
+				e.stopPropagation();
+			});
+
+			this.contextMenu.appendChild(button);
+		});
+
+		this.selectionOverlay.appendChild(this.contextMenu);
+	}
+
+	hideContextMenu() {
+		// Only hide if explicitly requested or if context menu should not stay visible
+		if (this.contextMenu && !this.contextMenuShouldStayVisible) {
+			this.contextMenu.style.display = "none";
+		}
+	}
+
+	forceHideContextMenu() {
+		// Force hide context menu regardless of flags
+		if (this.contextMenu) {
+			this.contextMenu.style.display = "none";
+			this.contextMenuShouldStayVisible = false;
+		}
+	}
+
+	copySelection() {
+		// Store selection before clearing
+		const selectionText = this.currentSelection || this.terminal.getSelection();
+
+		if (selectionText && cordova?.plugins?.clipboard) {
+			cordova.plugins.clipboard.copy(selectionText);
+		}
+
+		this.forceClearSelection();
+	}
+
+	pasteFromClipboard() {
+		if (cordova?.plugins?.clipboard) {
+			cordova.plugins.clipboard.paste((text) => {
+				this.terminal.paste(text);
+				this.forceClearSelection();
+			});
+		}
+	}
+
+	showMoreOptions() {
+		// Implement additional options if needed
+		window.toast("More options are not implemented yet.");
+		this.forceClearSelection();
+	}
+
+	clearSelection() {
+		// Don't clear if selection is protected
+		if (this.selectionProtected) {
+			return;
+		}
+
+		// Store focus state before clearing
+		const shouldRestoreFocus =
+			this.wasFocusedBeforeSelection && this.isSelecting;
+
+		this.isSelecting = false;
+		this.isHandleDragging = false;
+		this.selectionStart = null;
+		this.selectionEnd = null;
+		this.currentSelection = null;
+		this.dragHandle = null;
+
+		this.terminal.clearSelection();
+		this.hideHandles();
+		this.forceHideContextMenu();
+
+		if (this.tapHoldTimeout) {
+			clearTimeout(this.tapHoldTimeout);
+			this.tapHoldTimeout = null;
+		}
+
+		// Clear protection timeout
+		if (this.protectionTimeout) {
+			clearTimeout(this.protectionTimeout);
+			this.protectionTimeout = null;
+		}
+		this.selectionProtected = false;
+
+		// Only restore focus if explicitly clearing selection (not due to keyboard close)
+		// and if terminal was focused before selection
+		if (shouldRestoreFocus && !this.isTerminalFocused()) {
+			setTimeout(() => {
+				if (!this.isSelecting) {
+					this.terminal.focus();
+				}
+			}, 150);
+		}
+
+		// Reset focus tracking
+		this.wasFocusedBeforeSelection = false;
+	}
+
+	forceClearSelection() {
+		// Temporarily disable protection to force clear
+		const wasProtected = this.selectionProtected;
+		this.selectionProtected = false;
+		this.clearSelection();
+		// Don't restore protection state since we're clearing
+	}
+
+	touchToTerminalCoords(touch) {
+		const rect = this.terminal.element.getBoundingClientRect();
+		const x = touch.clientX - rect.left;
+		const y = touch.clientY - rect.top;
+
+		if (x < 0 || y < 0 || x > rect.width || y > rect.height) {
+			return null;
+		}
+
+		const col = Math.floor(x / this.cellDimensions.width);
+		const row =
+			Math.floor(y / this.cellDimensions.height) +
+			this.terminal.buffer.active.viewportY;
+
+		return {
+			col: Math.max(0, Math.min(col, this.terminal.cols - 1)),
+			row: Math.max(0, row),
+		};
+	}
+
+	terminalCoordsToPixels(coords) {
+		const rect = this.terminal.element.getBoundingClientRect();
+		const containerRect = this.container.getBoundingClientRect();
+
+		const x =
+			coords.col * this.cellDimensions.width + (rect.left - containerRect.left);
+		const y =
+			(coords.row - this.terminal.buffer.active.viewportY) *
+				this.cellDimensions.height +
+			(rect.top - containerRect.top);
+
+		// Check if coordinates are within visible viewport
+		const isVisible =
+			coords.row >= this.terminal.buffer.active.viewportY &&
+			coords.row < this.terminal.buffer.active.viewportY + this.terminal.rows;
+
+		return isVisible ? { x, y } : null;
+	}
+
+	updateCellDimensions() {
+		if (this.terminal._core && this.terminal._core._renderService) {
+			const dimensions = this.terminal._core._renderService.dimensions;
+			if (dimensions && dimensions.css && dimensions.css.cell) {
+				this.cellDimensions = {
+					width: dimensions.css.cell.width,
+					height: dimensions.css.cell.height,
+				};
+			}
+		}
+	}
+
+	/**
+	 * Check if terminal is currently focused
+	 */
+	isTerminalFocused() {
+		try {
+			// Check if terminal element has focus
+			return (
+				document.activeElement === this.terminal.element ||
+				this.terminal.element.contains(document.activeElement) ||
+				(this.terminal._core && this.terminal._core._hasFocus)
+			);
+		} catch (error) {
+			return false;
+		}
+	}
+
+	/**
+	 * Get word boundaries at the given coordinates
+	 */
+	getWordBoundsAt(coords) {
+		try {
+			const buffer = this.terminal.buffer.active;
+			const line = buffer.getLine(coords.row);
+			if (!line) return null;
+
+			const lineText = line.translateToString(false);
+			if (!lineText || coords.col >= lineText.length) return null;
+
+			const char = lineText[coords.col];
+			if (!this.isWordCharacter(char)) return null;
+
+			// Find word start
+			let startCol = coords.col;
+			while (startCol > 0 && this.isWordCharacter(lineText[startCol - 1])) {
+				startCol--;
+			}
+
+			// Find word end
+			let endCol = coords.col;
+			while (
+				endCol < lineText.length - 1 &&
+				this.isWordCharacter(lineText[endCol + 1])
+			) {
+				endCol++;
+			}
+
+			// Only auto-select if we found a meaningful word (more than just one character)
+			if (endCol > startCol) {
+				return {
+					start: { row: coords.row, col: startCol },
+					end: { row: coords.row, col: endCol },
+				};
+			}
+
+			return null;
+		} catch (error) {
+			console.warn("Error finding word bounds:", error);
+			return null;
+		}
+	}
+
+	/**
+	 * Check if a character is part of a word
+	 */
+	isWordCharacter(char) {
+		if (!char) return false;
+		// Word characters: letters, numbers, underscore, hyphen, dot
+		return /[a-zA-Z0-9_\-.]/.test(char);
+	}
+
+	/**
+	 * Start pinch zoom gesture
+	 */
+	startPinchZoom(event) {
+		if (event.touches.length !== 2) return;
+
+		this.isPinching = true;
+		this.initialFontSize = this.terminal.options.fontSize;
+
+		const touch1 = event.touches[0];
+		const touch2 = event.touches[1];
+
+		this.pinchStartDistance = this.getDistance(touch1, touch2);
+		this.lastPinchDistance = this.pinchStartDistance;
+
+		// Clear any selection timeouts
+		if (this.tapHoldTimeout) {
+			clearTimeout(this.tapHoldTimeout);
+			this.tapHoldTimeout = null;
+		}
+	}
+
+	/**
+	 * Handle pinch zoom gesture
+	 */
+	handlePinchZoom(event) {
+		if (!this.isPinching || event.touches.length !== 2) return;
+
+		const now = Date.now();
+		if (now - this.lastZoomTime < this.zoomThrottle) return;
+		this.lastZoomTime = now;
+
+		const touch1 = event.touches[0];
+		const touch2 = event.touches[1];
+		const currentDistance = this.getDistance(touch1, touch2);
+
+		const scale = currentDistance / this.pinchStartDistance;
+		const newFontSize = Math.round(this.initialFontSize * scale);
+
+		// Clamp font size between reasonable limits
+		const minFontSize = 8;
+		const maxFontSize = 24;
+		const clampedFontSize = Math.max(
+			minFontSize,
+			Math.min(maxFontSize, newFontSize),
+		);
+
+		if (clampedFontSize !== this.terminal.options.fontSize) {
+			this.options.onFontSizeChange(clampedFontSize);
+		}
+	}
+
+	/**
+	 * End pinch zoom gesture
+	 */
+	endPinchZoom() {
+		this.isPinching = false;
+		this.pinchStartDistance = 0;
+		this.lastPinchDistance = 0;
+		this.initialFontSize = 0;
+	}
+
+	/**
+	 * Get distance between two touch points
+	 */
+	getDistance(touch1, touch2) {
+		const dx = touch2.clientX - touch1.clientX;
+		const dy = touch2.clientY - touch1.clientY;
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+
+	destroy() {
+		// Clear selection
+		this.forceClearSelection();
+
+		// Remove event listeners
+		this.terminal.element.removeEventListener(
+			"touchstart",
+			this.boundHandlers.terminalTouchStart,
+		);
+		this.terminal.element.removeEventListener(
+			"touchmove",
+			this.boundHandlers.terminalTouchMove,
+		);
+		this.terminal.element.removeEventListener(
+			"touchend",
+			this.boundHandlers.terminalTouchEnd,
+		);
+
+		this.startHandle.removeEventListener(
+			"touchstart",
+			this.boundHandlers.handleTouchStart,
+		);
+		this.startHandle.removeEventListener(
+			"touchmove",
+			this.boundHandlers.handleTouchMove,
+		);
+		this.startHandle.removeEventListener(
+			"touchend",
+			this.boundHandlers.handleTouchEnd,
+		);
+
+		this.endHandle.removeEventListener(
+			"touchstart",
+			this.boundHandlers.handleTouchStart,
+		);
+		this.endHandle.removeEventListener(
+			"touchmove",
+			this.boundHandlers.handleTouchMove,
+		);
+		this.endHandle.removeEventListener(
+			"touchend",
+			this.boundHandlers.handleTouchEnd,
+		);
+
+		this.terminal.element.removeEventListener(
+			"touchstart",
+			this.boundHandlers.terminalAreaTouchStart,
+		);
+		this.terminal.element.removeEventListener(
+			"scroll",
+			this.boundHandlers.terminalScroll,
+		);
+		window.removeEventListener(
+			"orientationchange",
+			this.boundHandlers.orientationChange,
+		);
+		window.removeEventListener("resize", this.boundHandlers.orientationChange);
+
+		// Remove selection change listener
+		if (this.terminal.onSelectionChange) {
+			this.terminal.onSelectionChange(null);
+		}
+
+		// Remove DOM elements
+		if (this.selectionOverlay && this.selectionOverlay.parentNode) {
+			this.selectionOverlay.parentNode.removeChild(this.selectionOverlay);
+		}
+	}
+}
diff --git a/src/handlers/quickTools.js b/src/handlers/quickTools.js
index bc9ce6f59..0b9909621 100644
--- a/src/handlers/quickTools.js
+++ b/src/handlers/quickTools.js
@@ -327,6 +327,18 @@ function removeSearch() {
 	$footer.removeAttribute("data-searching");
 	$searchRow1.remove();
 	$searchRow2.remove();
+	const { activeFile } = editorManager;
+
+	// Check if current tab is a terminal
+	if (
+		activeFile &&
+		activeFile.type === "terminal" &&
+		activeFile.terminalComponent
+	) {
+		activeFile.terminalComponent.searchAddon?.clearDecorations();
+		activeFile.terminalComponent.searchAddon?.clearActiveDecoration();
+		return;
+	}
 	focusEditor();
 }
 
@@ -337,20 +349,44 @@ function removeSearch() {
  */
 function find(skip, backward) {
 	const { $searchInput } = quickTools;
-	editorManager.editor.find($searchInput.value, {
-		skipCurrent: skip,
-		...appSettings.value.search,
-		backwards: backward,
-	});
+	const { activeFile } = editorManager;
+
+	// Check if current tab is a terminal
+	if (
+		activeFile &&
+		activeFile.type === "terminal" &&
+		activeFile.terminalComponent
+	) {
+		activeFile.terminalComponent.search($searchInput.value, skip, backward);
+	} else {
+		// Use ACE editor search for regular files
+		editorManager.editor.find($searchInput.value, {
+			skipCurrent: skip,
+			...appSettings.value.search,
+			backwards: backward,
+		});
+	}
 
 	updateSearchState();
 }
 
 function updateSearchState() {
 	const MAX_COUNT = 999;
-	const { editor } = editorManager;
+	const { activeFile } = editorManager;
 	const { $searchPos, $searchTotal } = quickTools;
 
+	// Check if current tab is a terminal
+	if (activeFile && activeFile.type === "terminal") {
+		// For terminal, we can't easily count all matches like in ACE editor
+		// xterm search addon doesn't provide this information
+		// So we just show a generic indicator
+		$searchTotal.textContent = "?";
+		$searchPos.textContent = "?";
+		return;
+	}
+
+	// Use ACE editor search state for regular files
+	const { editor } = editorManager;
 	let regex = editor.$search.$options.re;
 	let all = 0;
 	let before = 0;
diff --git a/src/lang/ar-ye.json b/src/lang/ar-ye.json
index 3227209b6..49140cc75 100644
--- a/src/lang/ar-ye.json
+++ b/src/lang/ar-ye.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "تم تعطيل الإضافة",
 	"enable_plugin": "تفعيل هذه الإضافة",
 	"disable_plugin": "تعطيل هذه الإضافة",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/be-by.json b/src/lang/be-by.json
index 0a7cb86f0..7f74789e1 100644
--- a/src/lang/be-by.json
+++ b/src/lang/be-by.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/bn-bd.json b/src/lang/bn-bd.json
index f61ae3f19..b9bbf5540 100644
--- a/src/lang/bn-bd.json
+++ b/src/lang/bn-bd.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/cs-cz.json b/src/lang/cs-cz.json
index 3225f42ae..41683ad72 100644
--- a/src/lang/cs-cz.json
+++ b/src/lang/cs-cz.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/de-de.json b/src/lang/de-de.json
index 0d3c65dfc..9ed8c65c8 100644
--- a/src/lang/de-de.json
+++ b/src/lang/de-de.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin deaktiviert",
 	"enable_plugin": "Plugin aktivieren",
 	"disable_plugin": "Plugin deaktivieren",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/en-us.json b/src/lang/en-us.json
index 5d5ff093a..c696540d4 100644
--- a/src/lang/en-us.json
+++ b/src/lang/en-us.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/es-sv.json b/src/lang/es-sv.json
index 06373f835..00cf17cc7 100644
--- a/src/lang/es-sv.json
+++ b/src/lang/es-sv.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/fr-fr.json b/src/lang/fr-fr.json
index b286005e6..183071658 100644
--- a/src/lang/fr-fr.json
+++ b/src/lang/fr-fr.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin désactivé",
 	"enable_plugin": "Activer ce plugin",
 	"disable_plugin": "Désactiver ce plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/he-il.json b/src/lang/he-il.json
index 8a07f0d16..df20028a5 100644
--- a/src/lang/he-il.json
+++ b/src/lang/he-il.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "הפלאגין הושבת",
 	"enable_plugin": "הפעל תוסף זה",
 	"disable_plugin": "השבת תוסף זה",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/hi-in.json b/src/lang/hi-in.json
index 116fd875a..a9f06b29c 100644
--- a/src/lang/hi-in.json
+++ b/src/lang/hi-in.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/hu-hu.json b/src/lang/hu-hu.json
index 822fb978b..939b5e960 100644
--- a/src/lang/hu-hu.json
+++ b/src/lang/hu-hu.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Bővítmény letiltva",
 	"enable_plugin": "Bővítmény engedélyezése",
 	"disable_plugin": "Bővítmény letiltása",
-	"open_source": "Nyílt forráskódú"
+	"open_source": "Nyílt forráskódú",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/id-id.json b/src/lang/id-id.json
index e95e49bad..42169f457 100644
--- a/src/lang/id-id.json
+++ b/src/lang/id-id.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin dinonaktifkan",
 	"enable_plugin": "Aktifkan Plugin ini",
 	"disable_plugin": "Nonaktifkan Plugin ini",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/ir-fa.json b/src/lang/ir-fa.json
index 35d1ebe16..94671694d 100644
--- a/src/lang/ir-fa.json
+++ b/src/lang/ir-fa.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/it-it.json b/src/lang/it-it.json
index a02267c54..5d6002336 100644
--- a/src/lang/it-it.json
+++ b/src/lang/it-it.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/ja-jp.json b/src/lang/ja-jp.json
index a7b59da47..af733d482 100644
--- a/src/lang/ja-jp.json
+++ b/src/lang/ja-jp.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/ko-kr.json b/src/lang/ko-kr.json
index 34094364a..d83394f83 100644
--- a/src/lang/ko-kr.json
+++ b/src/lang/ko-kr.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/ml-in.json b/src/lang/ml-in.json
index 35ff63f3f..6f9a0c908 100644
--- a/src/lang/ml-in.json
+++ b/src/lang/ml-in.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/mm-unicode.json b/src/lang/mm-unicode.json
index cc6b1935d..5c39fa27b 100644
--- a/src/lang/mm-unicode.json
+++ b/src/lang/mm-unicode.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/mm-zawgyi.json b/src/lang/mm-zawgyi.json
index 0722ad601..17c3468a8 100644
--- a/src/lang/mm-zawgyi.json
+++ b/src/lang/mm-zawgyi.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/pl-pl.json b/src/lang/pl-pl.json
index d0e038d7a..0198d5385 100644
--- a/src/lang/pl-pl.json
+++ b/src/lang/pl-pl.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/pt-br.json b/src/lang/pt-br.json
index fc96ab2ae..4b45bc7fa 100644
--- a/src/lang/pt-br.json
+++ b/src/lang/pt-br.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/pu-in.json b/src/lang/pu-in.json
index b3695052c..7e39730d4 100644
--- a/src/lang/pu-in.json
+++ b/src/lang/pu-in.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/ru-ru.json b/src/lang/ru-ru.json
index 3b1eaaac1..72fff5c1e 100644
--- a/src/lang/ru-ru.json
+++ b/src/lang/ru-ru.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/tl-ph.json b/src/lang/tl-ph.json
index d654bed33..8a029cc5f 100644
--- a/src/lang/tl-ph.json
+++ b/src/lang/tl-ph.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/tr-tr.json b/src/lang/tr-tr.json
index 1145c62d8..3095788c1 100644
--- a/src/lang/tr-tr.json
+++ b/src/lang/tr-tr.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/uk-ua.json b/src/lang/uk-ua.json
index a1bc1d08b..6b8a81490 100644
--- a/src/lang/uk-ua.json
+++ b/src/lang/uk-ua.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/uz-uz.json b/src/lang/uz-uz.json
index 061df13ff..9b0e2e72f 100644
--- a/src/lang/uz-uz.json
+++ b/src/lang/uz-uz.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/vi-vn.json b/src/lang/vi-vn.json
index 85c8c71c7..da796b43d 100644
--- a/src/lang/vi-vn.json
+++ b/src/lang/vi-vn.json
@@ -409,5 +409,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/zh-cn.json b/src/lang/zh-cn.json
index de3fb2944..7b3dcce02 100644
--- a/src/lang/zh-cn.json
+++ b/src/lang/zh-cn.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/zh-hant.json b/src/lang/zh-hant.json
index b38757ad6..bd0906783 100644
--- a/src/lang/zh-hant.json
+++ b/src/lang/zh-hant.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lang/zh-tw.json b/src/lang/zh-tw.json
index 3fc9d5919..6be60d756 100644
--- a/src/lang/zh-tw.json
+++ b/src/lang/zh-tw.json
@@ -408,5 +408,17 @@
 	"plugin_disabled": "Plugin disabled",
 	"enable_plugin": "Enable this Plugin",
 	"disable_plugin": "Disable this Plugin",
-	"open_source": "Open Source"
+	"open_source": "Open Source",
+	"terminal settings": "Terminal Settings",
+	"font ligatures": "Font Ligatures",
+	"letter spacing": "Letter Spacing",
+	"terminal:tab stop width": "Tab Stop Width",
+	"terminal:scrollback": "Scrollback Lines",
+	"terminal:cursor blink": "Cursor Blink",
+	"terminal:font weight": "Font Weight",
+	"terminal:cursor inactive style": "Cursor Inactive Style",
+	"terminal:cursor style": "Cursor Style",
+	"terminal:font family": "Font Family",
+	"terminal:convert eol": "Convert EOL",
+	"terminal": "Terminal"
 }
diff --git a/src/lib/acode.js b/src/lib/acode.js
index 6ff2dcfc7..7bec984d8 100644
--- a/src/lib/acode.js
+++ b/src/lib/acode.js
@@ -5,6 +5,7 @@ import Page from "components/page";
 import palette from "components/palette";
 import settingsPage from "components/settingsPage";
 import SideButton from "components/sideButton";
+import { TerminalManager, TerminalThemeManager } from "components/terminal";
 import toast from "components/toast";
 import tutorial from "components/tutorial";
 import alert from "dialogs/alert";
@@ -99,6 +100,28 @@ export default class Acode {
 			removeHandler: removeIntentHandler,
 		};
 
+		const terminalModule = {
+			create: (options) => TerminalManager.createTerminal(options),
+			createLocal: (options) => TerminalManager.createLocalTerminal(options),
+			createServer: (options) => TerminalManager.createServerTerminal(options),
+			get: (id) => TerminalManager.getTerminal(id),
+			getAll: () => TerminalManager.getAllTerminals(),
+			write: (id, data) => TerminalManager.writeToTerminal(id, data),
+			clear: (id) => TerminalManager.clearTerminal(id),
+			close: (id) => TerminalManager.closeTerminal(id),
+			themes: {
+				register: (name, theme, pluginId) =>
+					TerminalThemeManager.registerTheme(name, theme, pluginId),
+				unregister: (name, pluginId) =>
+					TerminalThemeManager.unregisterTheme(name, pluginId),
+				get: (name) => TerminalThemeManager.getTheme(name),
+				getAll: () => TerminalThemeManager.getAllThemes(),
+				getNames: () => TerminalThemeManager.getThemeNames(),
+				createVariant: (baseName, overrides) =>
+					TerminalThemeManager.createVariant(baseName, overrides),
+			},
+		};
+
 		this.define("Url", Url);
 		this.define("page", Page);
 		this.define("Color", Color);
@@ -137,6 +160,7 @@ export default class Acode {
 		this.define("themeBuilder", ThemeBuilder);
 		this.define("selectionMenu", selectionMenu);
 		this.define("sidebarApps", sidebarAppsModule);
+		this.define("terminal", terminalModule);
 		this.define("createKeyboardEvent", KeyboardEvent);
 		this.define("toInternalUrl", helpers.toInternalUri);
 	}
diff --git a/src/lib/commands.js b/src/lib/commands.js
index df56953af..e0bf653f3 100644
--- a/src/lib/commands.js
+++ b/src/lib/commands.js
@@ -1,4 +1,5 @@
 import Sidebar from "components/sidebar";
+import { TerminalManager } from "components/terminal";
 import color from "dialogs/color";
 import confirm from "dialogs/confirm";
 import prompt from "dialogs/prompt";
@@ -464,4 +465,12 @@ Additional Info:
 				toast("Failed to get device info");
 			});
 	},
+	async "new-terminal"() {
+		try {
+			await TerminalManager.createServerTerminal();
+		} catch (error) {
+			console.error("Failed to create terminal:", error);
+			window.toast("Failed to create terminal");
+		}
+	},
 };
diff --git a/src/lib/editorFile.js b/src/lib/editorFile.js
index 1b99f3b30..99f9d9034 100644
--- a/src/lib/editorFile.js
+++ b/src/lib/editorFile.js
@@ -209,53 +209,68 @@ export default class EditorFile {
 		if (options?.type) {
 			this.#type = options.type;
 			if (this.#type !== "editor") {
-				const container = tag("div", {
-					className: "tab-page-container",
-				});
-
-				// shadow dom
-				const shadow = container.attachShadow({ mode: "open" });
-
-				// main app styles
-				const mainStyle = tag("link", {
-					rel: "stylesheet",
-					href: "./css/build/main.css",
-				});
-				// icon styles
-				const iconStyle = tag("link", {
-					rel: "stylesheet",
-					href: "./res/icons/style.css",
-				});
-				// file icon styles
-				const fileIconStyle = tag("link", {
-					rel: "stylesheet",
-					href: "./res/file-icons/style.css",
-				});
-
-				// Add base styles to shadow DOM first
-				shadow.appendChild(mainStyle);
-				shadow.appendChild(iconStyle);
-				shadow.appendChild(fileIconStyle);
-
-				// Handle custom stylesheets if provided
-				if (options.stylesheets) {
-					this.#addCustomStyles(options.stylesheets, shadow);
-				}
-
-				const content = tag("div", {
-					className: "tab-page-content",
-				});
-
-				if (typeof options.content === "string") {
-					content.innerHTML = DOMPurify.sanitize(options.content);
+				let container;
+				let shadow;
+
+				if (this.#type === "terminal") {
+					container = tag("div", {
+						className: "tab-page-container",
+					});
+					const content = tag("div", {
+						className: "tab-page-content",
+					});
+					content.appendChild(options?.content);
+					container.appendChild(content);
+					this.#content = container;
 				} else {
-					content.appendChild(options.content);
+					container = tag("div", {
+						className: "tab-page-container",
+					});
+
+					// shadow dom
+					shadow = container.attachShadow({ mode: "open" });
+
+					// main app styles
+					const mainStyle = tag("link", {
+						rel: "stylesheet",
+						href: "./css/build/main.css",
+					});
+					// icon styles
+					const iconStyle = tag("link", {
+						rel: "stylesheet",
+						href: "./res/icons/style.css",
+					});
+					// file icon styles
+					const fileIconStyle = tag("link", {
+						rel: "stylesheet",
+						href: "./res/file-icons/style.css",
+					});
+
+					// Add base styles to shadow DOM first
+					shadow.appendChild(mainStyle);
+					shadow.appendChild(iconStyle);
+					shadow.appendChild(fileIconStyle);
+
+					// Handle custom stylesheets if provided
+					if (options.stylesheets) {
+						this.#addCustomStyles(options.stylesheets, shadow);
+					}
+
+					const content = tag("div", {
+						className: "tab-page-content",
+					});
+
+					if (typeof options.content === "string") {
+						content.innerHTML = DOMPurify.sanitize(options.content);
+					} else {
+						content.appendChild(options.content);
+					}
+
+					// Append content container to shadow DOM
+					shadow.appendChild(content);
+
+					this.#content = container;
 				}
-
-				// Append content container to shadow DOM
-				shadow.appendChild(content);
-
-				this.#content = container;
 			} else {
 				this.#content = options.content;
 			}
diff --git a/src/lib/fonts.js b/src/lib/fonts.js
index 81e440925..bc423fe40 100644
--- a/src/lib/fonts.js
+++ b/src/lib/fonts.js
@@ -28,6 +28,16 @@ add(
 }`,
 );
 
+add(
+	"MesloLGS NF Regular",
+	`@font-face {
+  font-family: 'MesloLGS NF Regular';
+  font-style: normal;
+  font-weight: normal;
+  src: url(../res/fonts/MesloLGSNFRegular.ttf) format('truetype');
+}`,
+);
+
 add(
 	"Source Code",
 	`@font-face {
@@ -172,9 +182,39 @@ async function downloadFont(name, link) {
 	return FONT_FILE;
 }
 
+async function loadFont(name) {
+	const $style = tag.get("style#font-style") ?? <style id="font-style"></style>;
+	let css = get(name);
+
+	if (!css) {
+		throw new Error(`Font ${name} not found`);
+	}
+
+	// Get all URL font references
+	const urls = [...css.matchAll(/url\((.*?)\)/g)].map((match) => match[1]);
+
+	// Download and replace URLs
+	for (const url of urls) {
+		if (!/^https?/.test(url)) continue;
+		if (/^https?:\/\/localhost/.test(url)) continue;
+		const fontFile = await downloadFont(name, url);
+		const internalUrl = await helpers.toInternalUri(fontFile);
+		css = css.replace(url, internalUrl);
+	}
+
+	// Add font face to document if not already present
+	if (!$style.textContent.includes(`font-family: '${name}'`)) {
+		$style.textContent = `${$style.textContent}\n${css}`;
+		document.head.append($style);
+	}
+
+	return css;
+}
+
 export default {
 	add,
 	get,
 	getNames,
 	setFont,
+	loadFont,
 };
diff --git a/src/lib/keyBindings.js b/src/lib/keyBindings.js
index fd41ead5f..3c2cea586 100644
--- a/src/lib/keyBindings.js
+++ b/src/lib/keyBindings.js
@@ -8,16 +8,19 @@ export default {
 		description: "Copy",
 		key: "Ctrl-C",
 		readOnly: true,
+		editorOnly: true,
 	},
 	cut: {
 		description: "Cut",
 		key: "Ctrl-X",
 		readOnly: false,
+		editorOnly: true,
 	},
 	paste: {
 		description: "Paste",
 		key: "Ctrl-V",
 		readOnly: false,
+		editorOnly: true,
 	},
 	findFile: {
 		description: "Find a file",
@@ -59,12 +62,14 @@ export default {
 		key: "Ctrl-S",
 		readOnly: true,
 		action: "save",
+		editorOnly: true,
 	},
 	saveFileAs: {
 		description: "Save as current file",
 		key: "Ctrl-Shift-S",
 		readOnly: true,
 		action: "save-as",
+		editorOnly: true,
 	},
 	nextFile: {
 		description: "Open next file tab",
@@ -83,18 +88,21 @@ export default {
 		key: "F2",
 		readOnly: true,
 		action: "rename",
+		editorOnly: true,
 	},
 	run: {
 		description: "Run current file",
 		key: "F5",
 		readOnly: false,
 		action: "run",
+		editorOnly: true,
 	},
 	selectWord: {
 		description: "Select current word",
 		key: "Ctrl-D",
 		readOnly: false,
 		action: "select-word",
+		editorOnly: true,
 	},
 	autoindent: {
 		key: null,
@@ -134,16 +142,19 @@ export default {
 		key: "Alt-E",
 		description: "Go to next error",
 		readOnly: false,
+		editorOnly: true,
 	},
 	goToPreviousError: {
 		key: "Alt-Shift-E",
 		description: "Go to previous error",
 		readOnly: false,
+		editorOnly: true,
 	},
 	selectall: {
 		description: "Select all",
 		key: "Ctrl-A",
 		readOnly: true,
+		editorOnly: true,
 	},
 	centerselection: {
 		description: "Center selection",
@@ -154,39 +165,47 @@ export default {
 		description: "Go to line...",
 		key: "Ctrl-G",
 		readOnly: true,
+		editorOnly: true,
 	},
 	fold: {
 		description: "Fold",
 		key: "Alt-L|Ctrl-F1",
 		readOnly: false,
+		editorOnly: true,
 	},
 	unfold: {
 		description: "Unfold",
 		key: "Alt-Shift-L|Ctrl-Shift-F1",
 		readOnly: false,
+		editorOnly: true,
 	},
 	toggleFoldWidget: {
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	toggleParentFoldWidget: {
 		key: "Alt-F2",
 		readOnly: false,
+		editorOnly: true,
 	},
 	foldall: {
 		description: "Fold all",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	foldOther: {
 		description: "Fold other",
 		key: "Alt-0",
 		readOnly: false,
+		editorOnly: true,
 	},
 	unfoldall: {
 		description: "Unfold all",
 		key: "Alt-Shift-0",
 		readOnly: false,
+		editorOnly: true,
 	},
 	findnext: {
 		description: "Find next",
@@ -212,6 +231,7 @@ export default {
 		description: "Find",
 		key: "Ctrl-F",
 		readOnly: true,
+		editorOnly: true,
 	},
 	overwrite: {
 		description: "Overwrite",
@@ -222,351 +242,421 @@ export default {
 		description: "Select to start",
 		key: "Ctrl-Shift-Home",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotostart: {
 		description: "Go to start",
 		key: "Ctrl-Home",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectup: {
 		description: "Select up",
 		key: "Shift-Up",
 		readOnly: true,
+		editorOnly: true,
 	},
 	golineup: {
 		description: "Go line up",
 		key: "Up",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selecttoend: {
 		description: "Select to end",
 		key: "Ctrl-Shift-End",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotoend: {
 		description: "Go to end",
 		key: "Ctrl-End",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectdown: {
 		description: "Select down",
 		key: "Shift-Down",
 		readOnly: true,
+		editorOnly: true,
 	},
 	golinedown: {
 		description: "Go line down",
 		key: "Down",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectwordleft: {
 		description: "Select word left",
 		key: "Ctrl-Shift-Left",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotowordleft: {
 		description: "Go to word left",
 		key: "Ctrl-Left",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selecttolinestart: {
 		description: "Select to line start",
 		key: "Alt-Shift-Left",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotolinestart: {
 		description: "Go to line start",
 		key: "Alt-Left|Home",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectleft: {
 		description: "Select left",
 		key: "Shift-Left",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotoleft: {
 		description: "Go to left",
 		key: "Left",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectwordright: {
 		description: "Select word right",
 		key: "Ctrl-Shift-Right",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotowordright: {
 		description: "Go to word right",
 		key: "Ctrl-Right",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selecttolineend: {
 		description: "Select to line end",
 		key: "Alt-Shift-Right",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotolineend: {
 		description: "Go to line end",
 		key: "Alt-Right|End",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectright: {
 		description: "Select right",
 		key: "Shift-Right",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotoright: {
 		description: "Go to right",
 		key: "Right",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectpagedown: {
 		description: "Select page down",
 		key: "Shift-PageDown",
 		readOnly: true,
+		editorOnly: true,
 	},
 	pagedown: {
 		description: "Page down",
 		key: null,
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotopagedown: {
 		description: "Go to page down",
 		key: "PageDown",
 		readOnly: false,
+		editorOnly: true,
 	},
 	selectpageup: {
 		description: "Select page up",
 		key: "Shift-PageUp",
 		readOnly: true,
+		editorOnly: true,
 	},
 	pageup: {
 		description: "Page up",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	problems: {
 		description: "Show problems",
 		key: "Ctrl-Shift-K",
 		readOnly: true,
+		editorOnly: true,
 	},
 	gotopageup: {
 		description: "Go to page up",
 		key: "PageUp",
 		readOnly: true,
+		editorOnly: true,
 	},
 	scrollup: {
 		description: "Scroll up",
 		key: "Ctrl-Up",
 		readOnly: true,
+		editorOnly: true,
 	},
 	scrolldown: {
 		description: "Scroll down",
 		key: "Ctrl-Down",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectlinestart: {
 		description: "Select line start",
 		key: "Shift-Home",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selectlineend: {
 		description: "Select line end",
 		key: "Shift-End",
 		readOnly: true,
+		editorOnly: true,
 	},
 	togglerecording: {
 		description: "Toggle recording",
 		key: "Ctrl-Alt-E",
 		readOnly: true,
+		editorOnly: true,
 	},
 	replaymacro: {
 		description: "Replay macro",
 		key: "Ctrl-Shift-E",
 		readOnly: true,
+		editorOnly: true,
 	},
 	jumptomatching: {
 		description: "Jump to matching",
 		key: "Ctrl-\\",
 		readOnly: true,
+		editorOnly: true,
 	},
 	selecttomatching: {
 		description: "Select to matching",
 		key: "Ctrl-Shift-\\",
 		readOnly: false,
+		editorOnly: true,
 	},
 	expandToMatching: {
 		description: "Expand to matching",
 		key: "Ctrl-Shift-M",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removeline: {
 		description: "Remove line",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	duplicateSelection: {
 		description: "Duplicate selection",
 		key: "Ctrl-Shift-D",
 		readOnly: false,
+		editorOnly: true,
 	},
 	sortlines: {
 		description: "Sort lines",
 		key: "Ctrl-Alt-S",
 		readOnly: false,
+		editorOnly: true,
 	},
 	togglecomment: {
 		description: "Toggle comment",
 		key: "Ctrl-/",
 		readOnly: false,
+		editorOnly: true,
 	},
 	toggleBlockComment: {
 		description: "Toggle block comment",
 		key: "Ctrl-Shift-/",
 		readOnly: false,
+		editorOnly: true,
 	},
 	modifyNumberUp: {
 		description: "Modify number up",
 		key: "Ctrl-Shift-Up",
 		readOnly: false,
+		editorOnly: true,
 	},
 	modifyNumberDown: {
 		description: "Modify number down",
 		key: "Ctrl-Shift-Down",
 		readOnly: false,
+		editorOnly: true,
 	},
 	replace: {
 		description: "Replace",
 		key: "Ctrl-R",
 		readOnly: false,
+		editorOnly: true,
 	},
 	undo: {
 		description: "Undo",
 		key: "Ctrl-Z",
 		readOnly: false,
+		editorOnly: true,
 	},
 	redo: {
 		description: "Redo",
 		key: "Ctrl-Shift-Z|Ctrl-Y",
 		readOnly: false,
+		editorOnly: true,
 	},
 	copylinesup: {
 		description: "Copy lines up",
 		key: "Alt-Shift-Up",
 		readOnly: false,
+		editorOnly: true,
 	},
 	movelinesup: {
 		description: "Move lines up",
 		key: "Alt-Up",
 		readOnly: false,
+		editorOnly: true,
 	},
 	copylinesdown: {
 		description: "Copy lines down",
 		key: "Alt-Shift-Down",
 		readOnly: false,
+		editorOnly: true,
 	},
 	movelinesdown: {
 		description: "Move lines down",
 		key: "Alt-Down",
 		readOnly: false,
+		editorOnly: true,
 	},
 	del: {
 		description: "Delete",
 		key: "Delete",
 		readOnly: true,
+		editorOnly: true,
 	},
 	backspace: {
 		description: "Backspace",
 		key: "Shift-Backspace|Backspace",
 		readOnly: false,
+		editorOnly: true,
 	},
 	cut_or_delete: {
 		description: "Cut or delete",
 		key: "Shift-Delete",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removetolinestart: {
 		description: "Remove to line start",
 		key: "Alt-Backspace",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removetolineend: {
 		description: "Remove to line end",
 		key: "Alt-Delete",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removetolinestarthard: {
 		description: "Remove to line start hard",
 		key: "Ctrl-Shift-Backspace",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removetolineendhard: {
 		description: "Remove to line end hard",
 		key: "Ctrl-Shift-Delete",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removewordleft: {
 		description: "Remove word left",
 		key: "Ctrl-Backspace",
 		readOnly: false,
+		editorOnly: true,
 	},
 	removewordright: {
 		description: "Remove word right",
 		key: "Ctrl-Delete",
 		readOnly: false,
+		editorOnly: true,
 	},
 	outdent: {
 		description: "Outdent",
 		key: "Shift-Tab",
 		readOnly: false,
+		editorOnly: true,
 	},
 	indent: {
 		description: "Indent",
 		key: "Tab",
 		readOnly: true,
+		editorOnly: true,
 	},
 	blockoutdent: {
 		description: "Block outdent",
 		key: "Ctrl-[",
 		readOnly: false,
+		editorOnly: true,
 	},
 	blockindent: {
 		description: "Block indent",
 		key: "Ctrl-]",
 		readOnly: false,
+		editorOnly: true,
 	},
 	splitline: {
 		description: "Split line",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	transposeletters: {
 		description: "Transpose letters",
 		key: "Alt-Shift-X",
 		readOnly: false,
+		editorOnly: true,
 	},
 	touppercase: {
 		description: "To uppercase",
 		key: "Ctrl-U",
 		readOnly: false,
+		editorOnly: true,
 	},
 	tolowercase: {
 		description: "To lowercase",
 		key: "Ctrl-Shift-U",
 		readOnly: false,
+		editorOnly: true,
 	},
 	expandtoline: {
 		description: "Expand to line",
 		key: "Ctrl-Shift-L",
 		readOnly: true,
+		editorOnly: true,
 	},
 	joinlines: {
 		description: "Join lines",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	invertSelection: {
 		description: "Invert selection",
 		key: null,
 		readOnly: false,
+		editorOnly: true,
 	},
 	openCommandPalette: {
 		description: "Open command palette",
@@ -577,17 +667,27 @@ export default {
 		description: "Change language mode",
 		key: "Ctrl-M",
 		readOnly: false,
+		editorOnly: true,
 	},
 	increaseFontSize: {
 		description: "Increase font size",
 		key: "Ctrl-+|Ctrl-=",
+		editorOnly: true,
 	},
 	decreaseFontSize: {
 		description: "Decrease font size",
 		key: "Ctrl+-|Ctrl-_",
+		editorOnly: true,
 	},
 	resetFontSize: {
 		description: "Reset font size",
 		key: "Ctrl+0|Ctrl-Numpad0",
+		editorOnly: true,
+	},
+	openTerminal: {
+		description: "Open Terminal",
+		key: "Ctrl-`",
+		readOnly: true,
+		action: "new-terminal",
 	},
 };
diff --git a/src/lib/main.js b/src/lib/main.js
index fc7d5bae2..7252bdf40 100644
--- a/src/lib/main.js
+++ b/src/lib/main.js
@@ -519,7 +519,7 @@ async function loadApp() {
 		// if (!$editMenuToggler.isConnected) {
 		// 	$header.insertBefore($editMenuToggler, $header.lastChild);
 		// }
-		if (activeFile?.type === "page") {
+		if (activeFile?.type === "page" || activeFile?.type === "terminal") {
 			$editMenuToggler.remove();
 		} else {
 			if (!$editMenuToggler.isConnected) {
diff --git a/src/plugins/system/android/com/foxdebug/system/System.java b/src/plugins/system/android/com/foxdebug/system/System.java
index 049439a88..2d214bf9e 100644
--- a/src/plugins/system/android/com/foxdebug/system/System.java
+++ b/src/plugins/system/android/com/foxdebug/system/System.java
@@ -55,118 +55,140 @@
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
+import android.content.Context;
+import android.net.Uri;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+import android.webkit.MimeTypeMap;
+
+// DocumentFile import (AndroidX library)
+import androidx.documentfile.provider.DocumentFile;
+
+// Java I/O imports
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
 
 
 public class System extends CordovaPlugin {
 
-  private CallbackContext requestPermissionCallback;
-  private Activity activity;
-  private Context context;
-  private int REQ_PERMISSIONS = 1;
-  private int REQ_PERMISSION = 2;
-  private int systemBarColor = 0xFF000000;
-  private Theme theme;
-  private CallbackContext intentHandler;
-  private CordovaWebView webView;
-
-  public void initialize(CordovaInterface cordova, CordovaWebView webView) {
-    super.initialize(cordova, webView);
-    this.context = cordova.getContext();
-    this.activity = cordova.getActivity();
-    this.webView = webView;
-
-    // Set up global exception handler
-    Thread.setDefaultUncaughtExceptionHandler(
-      new Thread.UncaughtExceptionHandler() {
-        @Override
-        public void uncaughtException(Thread thread, Throwable ex) {
-          StringWriter sw = new StringWriter();
-          PrintWriter pw = new PrintWriter(sw);
-          ex.printStackTrace(pw);
-          String stackTrace = sw.toString();
-
-          String errorMsg = String.format(
-            "Uncaught Exception: %s\nStack trace: %s",
-            ex.getMessage(),
-            stackTrace
-          );
-
-          sendLogToJavaScript("error", errorMsg);
-
-          // rethrow to the default handler
-          Thread.getDefaultUncaughtExceptionHandler()
-            .uncaughtException(thread, ex);
-        }
-      }
-    );
-  }
-
-  public boolean execute(
-    String action,
-    final JSONArray args,
-    final CallbackContext callbackContext
-  ) throws JSONException {
-    final String arg1 = args.optString(0);
-    final String arg2 = args.optString(1);
-    final String arg3 = args.optString(2);
-    final String arg4 = args.optString(3);
-    final String arg5 = args.optString(4);
-    final String arg6 = args.optString(5);
-
-    switch (action) {
-      case "get-webkit-info":
-      case "file-action":
-      case "is-powersave-mode":
-      case "get-app-info":
-      case "add-shortcut":
-      case "remove-shortcut":
-      case "pin-shortcut":
-      case "get-android-version":
-      case "request-permissions":
-      case "request-permission":
-      case "has-permission":
-      case "open-in-browser":
-      case "launch-app":
-      case "get-global-setting":
-      case "get-available-encodings":
-      case "decode":
-      case "encode":
-        break;
-      case "get-configuration":
-        getConfiguration(callbackContext);
-        return true;
-      case "set-input-type":
-        setInputType(arg1);
-        callbackContext.success();
-        return true;
-      case "get-cordova-intent":
-        getCordovaIntent(callbackContext);
-        return true;
-      case "set-intent-handler":
-        setIntentHandler(callbackContext);
-        return true;
-      case "set-ui-theme":
-        this.cordova.getActivity()
-          .runOnUiThread(
-            new Runnable() {
-              public void run() {
-                setUiTheme(arg1, args.optJSONObject(1), callbackContext);
-              }
-            }
-          );
-        return true;
-      case "clear-cache":
-        this.cordova.getActivity()
-          .runOnUiThread(
-            new Runnable() {
-              public void run() {
-                clearCache(callbackContext);
-              }
+    private CallbackContext requestPermissionCallback;
+    private Activity activity;
+    private Context context;
+    private int REQ_PERMISSIONS = 1;
+    private int REQ_PERMISSION = 2;
+    private int systemBarColor = 0xFF000000;
+    private Theme theme;
+    private CallbackContext intentHandler;
+    private CordovaWebView webView;
+
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        this.context = cordova.getContext();
+        this.activity = cordova.getActivity();
+        this.webView = webView;
+
+        // Set up global exception handler
+        Thread.setDefaultUncaughtExceptionHandler(
+            new Thread.UncaughtExceptionHandler() {
+                @Override
+                public void uncaughtException(Thread thread, Throwable ex) {
+                    StringWriter sw = new StringWriter();
+                    PrintWriter pw = new PrintWriter(sw);
+                    ex.printStackTrace(pw);
+                    String stackTrace = sw.toString();
+
+                    String errorMsg = String.format(
+                        "Uncaught Exception: %s\nStack trace: %s",
+                        ex.getMessage(),
+                        stackTrace
+                    );
+
+                    sendLogToJavaScript("error", errorMsg);
+
+                    // rethrow to the default handler
+                    Thread.getDefaultUncaughtExceptionHandler()
+                        .uncaughtException(thread, ex);
+                }
             }
-          );
-        return true;
-      case "fileExists":
-                callbackContext.success(fileExists(args.getString(0),args.getString(1)) ? 1 : 0);
+        );
+    }
+
+    public boolean execute(
+        String action,
+        final JSONArray args,
+        final CallbackContext callbackContext
+    ) throws JSONException {
+        final String arg1 = args.optString(0);
+        final String arg2 = args.optString(1);
+        final String arg3 = args.optString(2);
+        final String arg4 = args.optString(3);
+        final String arg5 = args.optString(4);
+        final String arg6 = args.optString(5);
+
+        switch (action) {
+            case "get-webkit-info":
+            case "file-action":
+            case "is-powersave-mode":
+            case "get-app-info":
+            case "add-shortcut":
+            case "remove-shortcut":
+            case "pin-shortcut":
+            case "get-android-version":
+            case "request-permissions":
+            case "request-permission":
+            case "has-permission":
+            case "open-in-browser":
+            case "launch-app":
+            case "get-global-setting":
+            case "get-available-encodings":
+            case "decode":
+            case "encode":
+            case "copyToUri":
+                break;
+            case "get-configuration":
+                getConfiguration(callbackContext);
+                return true;
+            case "set-input-type":
+                setInputType(arg1);
+                callbackContext.success();
+                return true;
+            case "get-cordova-intent":
+                getCordovaIntent(callbackContext);
+                return true;
+            case "set-intent-handler":
+                setIntentHandler(callbackContext);
+                return true;
+            case "set-ui-theme":
+                this.cordova.getActivity()
+                    .runOnUiThread(
+                        new Runnable() {
+                            public void run() {
+                                setUiTheme(arg1, args.optJSONObject(1), callbackContext);
+                            }
+                        }
+                    );
+                return true;
+            case "clear-cache":
+                this.cordova.getActivity()
+                    .runOnUiThread(
+                        new Runnable() {
+                            public void run() {
+                                clearCache(callbackContext);
+                            }
+                        }
+                    );
+                return true;
+            case "fileExists":
+                callbackContext.success(fileExists(args.getString(0), args.getString(1)) ? 1 : 0);
                 return true;
 
             case "createSymlink":
@@ -189,310 +211,430 @@ public void run() {
             case "listChildren":
                 callbackContext.success(listChildren(args.getString(0)));
                 return true;
-            case "writeText": {
-    try {
-        String filePath = args.getString(0);
-        String content = args.getString(1);
-
-        Files.write(Paths.get(filePath),
-                    Collections.singleton(content),
-                    StandardOpenOption.CREATE,
-                    StandardOpenOption.TRUNCATE_EXISTING);
-
-        callbackContext.success("File written successfully");
-    } catch (Exception e) {
-        callbackContext.error("Failed to write file: " + e.getMessage());
-    }
-    return true;
-}
+            case "writeText":
+                {
+                    try {
+                        String filePath = args.getString(0);
+                        String content = args.getString(1);
+
+                        Files.write(Paths.get(filePath),
+                            Collections.singleton(content),
+                            StandardOpenOption.CREATE,
+                            StandardOpenOption.TRUNCATE_EXISTING);
+
+                        callbackContext.success("File written successfully");
+                    } catch (Exception e) {
+                        callbackContext.error("Failed to write file: " + e.getMessage());
+                    }
+                    return true;
+                }
 
             case "getArch":
                 String arch;
 
-            if (android.os.Build.VERSION.SDK_INT >= 21) {
-                arch = android.os.Build.SUPPORTED_ABIS[0];
-            } else {
-                arch = android.os.Build.CPU_ABI;
-            }
+                if (android.os.Build.VERSION.SDK_INT >= 21) {
+                    arch = android.os.Build.SUPPORTED_ABIS[0];
+                } else {
+                    arch = android.os.Build.CPU_ABI;
+                }
 
-            callbackContext.success(arch);
-            return true;
-             case "mkdirs":
+                callbackContext.success(arch);
+                return true;
+            case "mkdirs":
                 File file = new File(args.getString(0));
-                if(file.mkdirs()){
-                  callbackContext.success();
-                }else{
-                  callbackContext.error("mkdirs failed");
+                if (file.mkdirs()) {
+                    callbackContext.success();
+                } else {
+                    callbackContext.error("mkdirs failed");
                 }
                 return true;
-      default:
-        return false;
-    }
 
-    cordova
-      .getThreadPool()
-      .execute(
-        new Runnable() {
-          public void run() {
-            switch (action) {
-              case "get-webkit-info":
-                getWebkitInfo(callbackContext);
-                break;
-              case "file-action":
-                fileAction(arg1, arg2, arg3, arg4, callbackContext);
-                break;
-              case "is-powersave-mode":
-                isPowerSaveMode(callbackContext);
-                break;
-              case "get-app-info":
-                getAppInfo(callbackContext);
-                break;
-              case "add-shortcut":
-                addShortcut(
-                  arg1,
-                  arg2,
-                  arg3,
-                  arg4,
-                  arg5,
-                  arg6,
-                  callbackContext
-                );
-                break;
-              case "remove-shortcut":
-                removeShortcut(arg1, callbackContext);
-                break;
-              case "pin-shortcut":
-                pinShortcut(arg1, callbackContext);
-                break;
-              case "get-android-version":
-                getAndroidVersion(callbackContext);
-                break;
-              case "request-permissions":
-                requestPermissions(args.optJSONArray(0), callbackContext);
-                break;
-              case "request-permission":
-                requestPermission(arg1, callbackContext);
-                break;
-              case "has-permission":
-                hasPermission(arg1, callbackContext);
-                break;
-              case "open-in-browser":
-                openInBrowser(arg1, callbackContext);
-                break;
-              case "launch-app":
-                launchApp(arg1, arg2, arg3, callbackContext);
-                break;
-              case "get-global-setting":
-                getGlobalSetting(arg1, callbackContext);
-                break;
-              case "get-available-encodings":
-                getAvailableEncodings(callbackContext);
-                break;
-              case "decode":
-                decode(arg1, arg2, callbackContext);
-                break;
-              case "encode":
-                encode(arg1, arg2, callbackContext);
-                break;
-              default:
-                break;
-            }
-          }
+            default:
+                return false;
         }
-      );
-
-    return true;
-  }
-
-  private void sendLogToJavaScript(String level, String message) {
-    final String js =
-      "window.log('" + level + "', " + JSONObject.quote(message) + ");";
-    cordova
-      .getActivity()
-      .runOnUiThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            webView.loadUrl("javascript:" + js);
-          }
-        }
-      );
-  }
 
-  private void getConfiguration(CallbackContext callback) {
+        cordova
+            .getThreadPool()
+            .execute(
+                new Runnable() {
+                    public void run() {
+                        switch (action) {
+                            case "copyToUri":
     try {
-      JSONObject result = new JSONObject();
-      Configuration config = context.getResources().getConfiguration();
-      InputMethodManager imm = (InputMethodManager) context.getSystemService(
-        Context.INPUT_METHOD_SERVICE
-      );
-      Method method =
-        InputMethodManager.class.getMethod("getInputMethodWindowVisibleHeight");
-
-      result.put("isAcceptingText", imm.isAcceptingText());
-      result.put("keyboardHeight", method.invoke(imm));
-      result.put("locale", config.locale.toString());
-      result.put("fontScale", config.fontScale);
-      result.put("keyboard", config.keyboard);
-      result.put("keyboardHidden", config.keyboardHidden);
-      result.put("hardKeyboardHidden", config.hardKeyboardHidden);
-      result.put("navigationHidden", config.navigationHidden);
-      result.put("navigation", config.navigation);
-      result.put("orientation", config.orientation);
-      callback.success(result);
-    } catch (
-      JSONException
-      | NoSuchMethodException
-      | IllegalAccessException
-      | InvocationTargetException error
-    ) {
-      callback.error(error.toString());
-    }
-  }
+        //srcUri is a file
+        Uri srcUri = Uri.parse(args.getString(0));
 
-  private void decode(
-    String content, // base64 encoded string
-    String charSetName,
-    CallbackContext callback
-  ) {
-    try {
-      byte[] bytes = Base64.decode(content, Base64.DEFAULT);
+        //destUri is a directory
+        Uri destUri = Uri.parse(args.getString(1));
 
-      if (Charset.isSupported(charSetName) == false) {
-        callback.error("Charset not supported: " + charSetName);
-        return;
-      }
+        //create a file named this into the dest Directory and copy the srcUri into it
+        String fileName = args.getString(2);
+
+        InputStream in = null;
+        OutputStream out = null;
+        try {
+            // Open input stream from the source URI
+            if ("file".equalsIgnoreCase(srcUri.getScheme())) {
+                File file = new File(srcUri.getPath());
+                in = new FileInputStream(file);
+            } else {
+                in = context.getContentResolver().openInputStream(srcUri);
+            }
 
-      Charset charSet = Charset.forName(charSetName);
-      CharBuffer charBuffer = charSet.decode(ByteBuffer.wrap(bytes));
-      String result = String.valueOf(charBuffer);
-      callback.success(result);
+            // Create the destination file using DocumentFile for better URI handling
+            DocumentFile destFile = null;
+            
+            if ("file".equalsIgnoreCase(destUri.getScheme())) {
+                // Handle file:// scheme using DocumentFile
+                File destDir = new File(destUri.getPath());
+                if (!destDir.exists()) {
+                    destDir.mkdirs(); // Create directory if it doesn't exist
+                }
+                DocumentFile destDocDir = DocumentFile.fromFile(destDir);
+                
+                // Check if file already exists and delete it
+                DocumentFile existingFile = destDocDir.findFile(fileName);
+                if (existingFile != null && existingFile.exists()) {
+                    existingFile.delete();
+                }
+                
+                // Create new file
+                String mimeType = getMimeTypeFromExtension(fileName);
+                destFile = destDocDir.createFile(mimeType, fileName);
+            } else {
+                // Handle content:// scheme using DocumentFile
+                DocumentFile destDocDir = DocumentFile.fromTreeUri(context, destUri);
+                
+                if (destDocDir == null || !destDocDir.exists() || !destDocDir.isDirectory()) {
+                    callbackContext.error("Destination directory does not exist or is not accessible");
+                    return;
+                }
+                
+                // Check if file already exists and delete it
+                DocumentFile existingFile = destDocDir.findFile(fileName);
+                if (existingFile != null && existingFile.exists()) {
+                    existingFile.delete();
+                }
+                
+                // Create new file
+                String mimeType = getMimeTypeFromExtension(fileName);
+                destFile = destDocDir.createFile(mimeType, fileName);
+            }
+
+            if (destFile == null || !destFile.exists()) {
+                callbackContext.error("Failed to create destination file");
+                return;
+            }
+
+            // Open output stream to the created file
+            out = context.getContentResolver().openOutputStream(destFile.getUri());
+
+            if (in == null || out == null) {
+                callbackContext.error("uri streams are null");
+                return;
+            }
+
+            // Copy stream
+            byte[] buffer = new byte[8192];
+            int len;
+            while ((len = in.read(buffer)) > 0) {
+                out.write(buffer, 0, len);
+            }
+
+            out.flush();
+            callbackContext.success();
+        } catch (IOException e) {
+            e.printStackTrace();
+            callbackContext.error(e.toString());
+        } finally {
+            try {
+                if (in != null) in.close();
+                if (out != null) out.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+                callbackContext.error(e.toString());
+            }
+        }
     } catch (Exception e) {
-      callback.error(e.toString());
+        e.printStackTrace();
+        callbackContext.error(e.toString());
     }
-  }
+    break;
+                            case "get-webkit-info":
+                                getWebkitInfo(callbackContext);
+                                break;
+                            case "file-action":
+                                fileAction(arg1, arg2, arg3, arg4, callbackContext);
+                                break;
+                            case "is-powersave-mode":
+                                isPowerSaveMode(callbackContext);
+                                break;
+                            case "get-app-info":
+                                getAppInfo(callbackContext);
+                                break;
+                            case "add-shortcut":
+                                addShortcut(
+                                    arg1,
+                                    arg2,
+                                    arg3,
+                                    arg4,
+                                    arg5,
+                                    arg6,
+                                    callbackContext
+                                );
+                                break;
+                            case "remove-shortcut":
+                                removeShortcut(arg1, callbackContext);
+                                break;
+                            case "pin-shortcut":
+                                pinShortcut(arg1, callbackContext);
+                                break;
+                            case "get-android-version":
+                                getAndroidVersion(callbackContext);
+                                break;
+                            case "request-permissions":
+                                requestPermissions(args.optJSONArray(0), callbackContext);
+                                break;
+                            case "request-permission":
+                                requestPermission(arg1, callbackContext);
+                                break;
+                            case "has-permission":
+                                hasPermission(arg1, callbackContext);
+                                break;
+                            case "open-in-browser":
+                                openInBrowser(arg1, callbackContext);
+                                break;
+                            case "launch-app":
+                                launchApp(arg1, arg2, arg3, callbackContext);
+                                break;
+                            case "get-global-setting":
+                                getGlobalSetting(arg1, callbackContext);
+                                break;
+                            case "get-available-encodings":
+                                getAvailableEncodings(callbackContext);
+                                break;
+                            case "decode":
+                                decode(arg1, arg2, callbackContext);
+                                break;
+                            case "encode":
+                                encode(arg1, arg2, callbackContext);
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+            );
 
-  private void encode(
-    String content, // string to encode
-    String charSetName,
-    CallbackContext callback
-  ) {
-    try {
-      if (Charset.isSupported(charSetName) == false) {
-        callback.error("Charset not supported: " + charSetName);
-        return;
-      }
+        return true;
+    }
 
-      Charset charSet = Charset.forName(charSetName);
-      ByteBuffer byteBuffer = charSet.encode(content);
-      byte[] bytes = new byte[byteBuffer.remaining()];
-      byteBuffer.get(bytes);
-      callback.success(bytes);
-    } catch (Exception e) {
-      callback.error(e.toString());
+    private void sendLogToJavaScript(String level, String message) {
+        final String js =
+            "window.log('" + level + "', " + JSONObject.quote(message) + ");";
+        cordova
+            .getActivity()
+            .runOnUiThread(
+                new Runnable() {
+                    @Override
+                    public void run() {
+                        webView.loadUrl("javascript:" + js);
+                    }
+                }
+            );
     }
-  }
 
-  private void getAvailableEncodings(CallbackContext callback) {
-    try {
-      Map<String, Charset> charsets = Charset.availableCharsets();
-      JSONObject result = new JSONObject();
-      for (Map.Entry<String, Charset> entry : charsets.entrySet()) {
-        JSONObject obj = new JSONObject();
-        Charset charset = entry.getValue();
-        obj.put("label", charset.displayName());
-        obj.put("aliases", new JSONArray(charset.aliases()));
-        obj.put("name", charset.name());
-        result.put(charset.name(), obj);
-      }
-      callback.success(result);
-    } catch (Exception e) {
-      callback.error(e.toString());
+    // Helper method to determine MIME type using Android's built-in MimeTypeMap
+private String getMimeTypeFromExtension(String fileName) {
+    String extension = "";
+    int lastDotIndex = fileName.lastIndexOf('.');
+    if (lastDotIndex > 0 && lastDotIndex < fileName.length() - 1) {
+        extension = fileName.substring(lastDotIndex + 1).toLowerCase();
     }
-  }
+    
+    String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+    return mimeType != null ? mimeType : "application/octet-stream";
+}
 
-  private void requestPermissions(JSONArray arr, CallbackContext callback) {
-    try {
-      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-        int[] res = new int[arr.length()];
-        for (int i = 0; i < res.length; ++i) {
-          res[i] = 1;
+    private void getConfiguration(CallbackContext callback) {
+        try {
+            JSONObject result = new JSONObject();
+            Configuration config = context.getResources().getConfiguration();
+            InputMethodManager imm = (InputMethodManager) context.getSystemService(
+                Context.INPUT_METHOD_SERVICE
+            );
+            Method method =
+                InputMethodManager.class.getMethod("getInputMethodWindowVisibleHeight");
+
+            result.put("isAcceptingText", imm.isAcceptingText());
+            result.put("keyboardHeight", method.invoke(imm));
+            result.put("locale", config.locale.toString());
+            result.put("fontScale", config.fontScale);
+            result.put("keyboard", config.keyboard);
+            result.put("keyboardHidden", config.keyboardHidden);
+            result.put("hardKeyboardHidden", config.hardKeyboardHidden);
+            result.put("navigationHidden", config.navigationHidden);
+            result.put("navigation", config.navigation);
+            result.put("orientation", config.orientation);
+            callback.success(result);
+        } catch (
+            JSONException |
+            NoSuchMethodException |
+            IllegalAccessException |
+            InvocationTargetException error
+        ) {
+            callback.error(error.toString());
         }
-        callback.success(1);
-        return;
-      }
+    }
 
-      String[] permissions = checkPermissions(arr);
+    private void decode(
+        String content, // base64 encoded string
+        String charSetName,
+        CallbackContext callback
+    ) {
+        try {
+            byte[] bytes = Base64.decode(content, Base64.DEFAULT);
 
-      if (permissions.length > 0) {
-        requestPermissionCallback = callback;
-        cordova.requestPermissions(this, REQ_PERMISSIONS, permissions);
-        return;
-      }
-      callback.success(new JSONArray());
-    } catch (Exception e) {
-      callback.error(e.toString());
+            if (Charset.isSupported(charSetName) == false) {
+                callback.error("Charset not supported: " + charSetName);
+                return;
+            }
+
+            Charset charSet = Charset.forName(charSetName);
+            CharBuffer charBuffer = charSet.decode(ByteBuffer.wrap(bytes));
+            String result = String.valueOf(charBuffer);
+            callback.success(result);
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
     }
-  }
 
-  private void requestPermission(String permission, CallbackContext callback) {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-      callback.success(1);
-      return;
+    private void encode(
+        String content, // string to encode
+        String charSetName,
+        CallbackContext callback
+    ) {
+        try {
+            if (Charset.isSupported(charSetName) == false) {
+                callback.error("Charset not supported: " + charSetName);
+                return;
+            }
+
+            Charset charSet = Charset.forName(charSetName);
+            ByteBuffer byteBuffer = charSet.encode(content);
+            byte[] bytes = new byte[byteBuffer.remaining()];
+            byteBuffer.get(bytes);
+            callback.success(bytes);
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
     }
 
-    if (permission != null || !permission.equals("")) {
-      if (!cordova.hasPermission(permission)) {
-        requestPermissionCallback = callback;
-        cordova.requestPermission(this, REQ_PERMISSION, permission);
-        return;
-      }
+    private void getAvailableEncodings(CallbackContext callback) {
+        try {
+            Map < String, Charset > charsets = Charset.availableCharsets();
+            JSONObject result = new JSONObject();
+            for (Map.Entry < String, Charset > entry: charsets.entrySet()) {
+                JSONObject obj = new JSONObject();
+                Charset charset = entry.getValue();
+                obj.put("label", charset.displayName());
+                obj.put("aliases", new JSONArray(charset.aliases()));
+                obj.put("name", charset.name());
+                result.put(charset.name(), obj);
+            }
+            callback.success(result);
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
+    }
+
+    private void requestPermissions(JSONArray arr, CallbackContext callback) {
+        try {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                int[] res = new int[arr.length()];
+                for (int i = 0; i < res.length; ++i) {
+                    res[i] = 1;
+                }
+                callback.success(1);
+                return;
+            }
+
+            String[] permissions = checkPermissions(arr);
 
-      callback.success(1);
-      return;
+            if (permissions.length > 0) {
+                requestPermissionCallback = callback;
+                cordova.requestPermissions(this, REQ_PERMISSIONS, permissions);
+                return;
+            }
+            callback.success(new JSONArray());
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
     }
 
-    callback.error("No permission passed to request.");
-  }
+    private void requestPermission(String permission, CallbackContext callback) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            callback.success(1);
+            return;
+        }
+
+        if (permission != null || !permission.equals("")) {
+            if (!cordova.hasPermission(permission)) {
+                requestPermissionCallback = callback;
+                cordova.requestPermission(this, REQ_PERMISSION, permission);
+                return;
+            }
 
-  private void hasPermission(String permission, CallbackContext callback) {
-    if (permission != null || !permission.equals("")) {
-      int res = 0;
-      if (cordova.hasPermission(permission)) {
-        res = 1;
-      }
+            callback.success(1);
+            return;
+        }
 
-      callback.success(res);
-      return;
+        callback.error("No permission passed to request.");
     }
-    callback.error("No permission passed to check.");
-  }
 
-  public boolean fileExists(String path, String countSymlinks) {
-    Path p = new File(path).toPath();
-    try {
-        if (Boolean.parseBoolean(countSymlinks)) {
-            // This will return true even for broken symlinks
-            return Files.exists(p, LinkOption.NOFOLLOW_LINKS);
-        } else {
-            // Check target file, not symlink itself
-            return Files.exists(p) && !Files.isSymbolicLink(p);
+    private void hasPermission(String permission, CallbackContext callback) {
+        if (permission != null || !permission.equals("")) {
+            int res = 0;
+            if (cordova.hasPermission(permission)) {
+                res = 1;
+            }
+
+            callback.success(res);
+            return;
         }
-    } catch (Exception e) {
-        return false;
+        callback.error("No permission passed to check.");
     }
-}
 
-   public boolean createSymlink(String target, String linkPath) {
+    public boolean fileExists(String path, String countSymlinks) {
+        Path p = new File(path).toPath();
         try {
-            Process process = Runtime.getRuntime().exec(new String[]{"ln", "-s", target, linkPath});
+            if (Boolean.parseBoolean(countSymlinks)) {
+                // This will return true even for broken symlinks
+                return Files.exists(p, LinkOption.NOFOLLOW_LINKS);
+            } else {
+                // Check target file, not symlink itself
+                return Files.exists(p) && !Files.isSymbolicLink(p);
+            }
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public boolean createSymlink(String target, String linkPath) {
+        try {
+            Process process = Runtime.getRuntime().exec(new String[] {
+                "ln",
+                "-s",
+                target,
+                linkPath
+            });
             return process.waitFor() == 0;
         } catch (Exception e) {
             return false;
         }
     }
 
-   public String getNativeLibraryPath() {
+    public String getNativeLibraryPath() {
         ApplicationInfo appInfo = context.getApplicationInfo();
         return appInfo.nativeLibraryDir;
     }
@@ -501,7 +643,7 @@ public String getFilesDir() {
         return context.getFilesDir().getAbsolutePath();
     }
 
-   public String getParentPath(String path) {
+    public String getParentPath(String path) {
         File file = new File(path);
         File parent = file.getParentFile();
         return parent != null ? parent.getAbsolutePath() : null;
@@ -513,7 +655,7 @@ public JSONArray listChildren(String path) throws JSONException {
         if (dir.exists() && dir.isDirectory()) {
             File[] files = dir.listFiles();
             if (files != null) {
-                for (File file : files) {
+                for (File file: files) {
                     result.put(file.getAbsolutePath());
                 }
             }
@@ -521,519 +663,518 @@ public JSONArray listChildren(String path) throws JSONException {
         return result;
     }
 
-  public void onRequestPermissionResult(
-    int code,
-    String[] permissions,
-    int[] resCodes
-  ) {
-    if (requestPermissionCallback == null) return;
-
-    if (code == REQ_PERMISSIONS) {
-      JSONArray resAr = new JSONArray();
-      for (int res : resCodes) {
-        if (res == PackageManager.PERMISSION_DENIED) {
-          resAr.put(0);
-        }
-        resAr.put(1);
-      }
+    public void onRequestPermissionResult(
+        int code,
+        String[] permissions,
+        int[] resCodes
+    ) {
+        if (requestPermissionCallback == null) return;
 
-      requestPermissionCallback.success(resAr);
-      requestPermissionCallback = null;
-      return;
-    }
+        if (code == REQ_PERMISSIONS) {
+            JSONArray resAr = new JSONArray();
+            for (int res: resCodes) {
+                if (res == PackageManager.PERMISSION_DENIED) {
+                    resAr.put(0);
+                }
+                resAr.put(1);
+            }
 
-    if (
-      resCodes.length >= 1 && resCodes[0] == PackageManager.PERMISSION_DENIED
-    ) {
-      requestPermissionCallback.success(0);
-      requestPermissionCallback = null;
-      return;
-    }
-    requestPermissionCallback.success(1);
-    requestPermissionCallback = null;
-    return;
-  }
-
-  private String[] checkPermissions(JSONArray arr) throws Exception {
-    List<String> list = new ArrayList<String>();
-    for (int i = 0; i < arr.length(); i++) {
-      try {
-        String permission = arr.getString(i);
-        if (permission != null || !permission.equals("")) {
-          throw new Exception("Permission cannot be null or empty");
+            requestPermissionCallback.success(resAr);
+            requestPermissionCallback = null;
+            return;
         }
-        if (!cordova.hasPermission(permission)) {
-          list.add(permission);
+
+        if (
+            resCodes.length >= 1 && resCodes[0] == PackageManager.PERMISSION_DENIED
+        ) {
+            requestPermissionCallback.success(0);
+            requestPermissionCallback = null;
+            return;
         }
-      } catch (JSONException e) {}
+        requestPermissionCallback.success(1);
+        requestPermissionCallback = null;
+        return;
     }
 
-    String[] res = new String[list.size()];
-    return list.toArray(res);
-  }
+    private String[] checkPermissions(JSONArray arr) throws Exception {
+        List < String > list = new ArrayList < String > ();
+        for (int i = 0; i < arr.length(); i++) {
+            try {
+                String permission = arr.getString(i);
+                if (permission != null || !permission.equals("")) {
+                    throw new Exception("Permission cannot be null or empty");
+                }
+                if (!cordova.hasPermission(permission)) {
+                    list.add(permission);
+                }
+            } catch (JSONException e) {}
+        }
 
-  private void getAndroidVersion(CallbackContext callback) {
-    callback.success(Build.VERSION.SDK_INT);
-  }
+        String[] res = new String[list.size()];
+        return list.toArray(res);
+    }
 
-  private void getWebkitInfo(CallbackContext callback) {
-    PackageInfo info = null;
-    JSONObject res = new JSONObject();
+    private void getAndroidVersion(CallbackContext callback) {
+        callback.success(Build.VERSION.SDK_INT);
+    }
 
-    try {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        info = WebView.getCurrentWebViewPackage();
-      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-        Class webViewFactory = Class.forName("android.webkit.WebViewFactory");
-        Method method = webViewFactory.getMethod("getLoadedPackageInfo");
-        info = (PackageInfo) method.invoke(null);
-      } else {
-        PackageManager packageManager = activity.getPackageManager();
+    private void getWebkitInfo(CallbackContext callback) {
+        PackageInfo info = null;
+        JSONObject res = new JSONObject();
 
         try {
-          info = packageManager.getPackageInfo("com.google.android.webview", 0);
-        } catch (PackageManager.NameNotFoundException e) {
-          callback.error("Package not found");
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                info = WebView.getCurrentWebViewPackage();
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                Class webViewFactory = Class.forName("android.webkit.WebViewFactory");
+                Method method = webViewFactory.getMethod("getLoadedPackageInfo");
+                info = (PackageInfo) method.invoke(null);
+            } else {
+                PackageManager packageManager = activity.getPackageManager();
+
+                try {
+                    info = packageManager.getPackageInfo("com.google.android.webview", 0);
+                } catch (PackageManager.NameNotFoundException e) {
+                    callback.error("Package not found");
+                }
+
+                return;
+            }
+
+            res.put("packageName", info.packageName);
+            res.put("versionName", info.versionName);
+            res.put("versionCode", info.versionCode);
+
+            callback.success(res);
+        } catch (
+            JSONException |
+            InvocationTargetException |
+            ClassNotFoundException |
+            NoSuchMethodException |
+            IllegalAccessException e
+        ) {
+            callback.error(
+                "Cannot determine current WebView engine. (" + e.getMessage() + ")"
+            );
+
+            return;
         }
+    }
 
-        return;
-      }
-
-      res.put("packageName", info.packageName);
-      res.put("versionName", info.versionName);
-      res.put("versionCode", info.versionCode);
-
-      callback.success(res);
-    } catch (
-      JSONException
-      | InvocationTargetException
-      | ClassNotFoundException
-      | NoSuchMethodException
-      | IllegalAccessException e
-    ) {
-      callback.error(
-        "Cannot determine current WebView engine. (" + e.getMessage() + ")"
-      );
+    private void isPowerSaveMode(CallbackContext callback) {
+        PowerManager powerManager = (PowerManager) context.getSystemService(
+            Context.POWER_SERVICE
+        );
+        boolean powerSaveMode = powerManager.isPowerSaveMode();
 
-      return;
+        callback.success(powerSaveMode ? 1 : 0);
     }
-  }
-
-  private void isPowerSaveMode(CallbackContext callback) {
-    PowerManager powerManager = (PowerManager) context.getSystemService(
-      Context.POWER_SERVICE
-    );
-    boolean powerSaveMode = powerManager.isPowerSaveMode();
-
-    callback.success(powerSaveMode ? 1 : 0);
-  }
-
-  private void fileAction(
-    String fileURI,
-    String filename,
-    String action,
-    String mimeType,
-    CallbackContext callback
-  ) {
-    Activity activity = this.activity;
-    Context context = this.context;
-    Uri uri = this.getContentProviderUri(fileURI);
-    try {
-      Intent intent = new Intent(action);
 
-      if (mimeType.equals("")) {
-        mimeType = "text/plain";
-      }
+    private void fileAction(
+        String fileURI,
+        String filename,
+        String action,
+        String mimeType,
+        CallbackContext callback
+    ) {
+        Activity activity = this.activity;
+        Context context = this.context;
+        Uri uri = this.getContentProviderUri(fileURI);
+        try {
+            Intent intent = new Intent(action);
 
-      if (action.equals(Intent.ACTION_SEND)) {
-        intent.putExtra(Intent.EXTRA_STREAM, uri);
-        if (!filename.equals("")) {
-          intent.putExtra(Intent.EXTRA_TEXT, filename);
-        }
-        intent.setType(mimeType);
-      } else {
-        int flags =
-          Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION |
-          Intent.FLAG_GRANT_READ_URI_PERMISSION;
-
-        if (action.equals(Intent.ACTION_EDIT)) {
-          flags |= Intent.FLAG_GRANT_WRITE_URI_PERMISSION;
-        }
+            if (mimeType.equals("")) {
+                mimeType = "text/plain";
+            }
 
-        intent.setFlags(flags);
-        intent.setDataAndType(uri, mimeType);
-      }
+            if (action.equals(Intent.ACTION_SEND)) {
+                intent.putExtra(Intent.EXTRA_STREAM, uri);
+                if (!filename.equals("")) {
+                    intent.putExtra(Intent.EXTRA_TEXT, filename);
+                }
+                intent.setType(mimeType);
+            } else {
+                int flags =
+                    Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION |
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION;
 
-      activity.startActivity(intent);
-      callback.success(uri.toString());
-    } catch (Exception e) {
-      callback.error(e.getMessage());
-    }
-  }
+                if (action.equals(Intent.ACTION_EDIT)) {
+                    flags |= Intent.FLAG_GRANT_WRITE_URI_PERMISSION;
+                }
 
-  private void getAppInfo(CallbackContext callback) {
-    JSONObject res = new JSONObject();
-    try {
-      PackageManager pm = activity.getPackageManager();
-      PackageInfo pInfo = pm.getPackageInfo(context.getPackageName(), 0);
-      ApplicationInfo appInfo = context.getApplicationInfo();
-      int isDebuggable = appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE;
-
-      res.put("firstInstallTime", pInfo.firstInstallTime);
-      res.put("lastUpdateTime", pInfo.lastUpdateTime);
-      res.put("label", appInfo.loadLabel(pm).toString());
-      res.put("packageName", pInfo.packageName);
-      res.put("versionName", pInfo.versionName);
-      res.put("versionCode", pInfo.getLongVersionCode());
-      res.put("isDebuggable", isDebuggable);
-
-      callback.success(res);
-    } catch (JSONException e) {
-      callback.error(e.getMessage());
-    } catch (Exception e) {
-      callback.error(e.getMessage());
+                intent.setFlags(flags);
+                intent.setDataAndType(uri, mimeType);
+            }
+
+            activity.startActivity(intent);
+            callback.success(uri.toString());
+        } catch (Exception e) {
+            callback.error(e.getMessage());
+        }
     }
-  }
-
-  private void openInBrowser(String src, CallbackContext callback) {
-    Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(src));
-    activity.startActivity(browserIntent);
-  }
-
-  private void launchApp(
-    String appId,
-    String className,
-    String data,
-    CallbackContext callback
-) {
-    if (appId == null || appId.equals("")) {
-      callback.error("No package name provided.");
-      return;
+
+    private void getAppInfo(CallbackContext callback) {
+        JSONObject res = new JSONObject();
+        try {
+            PackageManager pm = activity.getPackageManager();
+            PackageInfo pInfo = pm.getPackageInfo(context.getPackageName(), 0);
+            ApplicationInfo appInfo = context.getApplicationInfo();
+            int isDebuggable = appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE;
+
+            res.put("firstInstallTime", pInfo.firstInstallTime);
+            res.put("lastUpdateTime", pInfo.lastUpdateTime);
+            res.put("label", appInfo.loadLabel(pm).toString());
+            res.put("packageName", pInfo.packageName);
+            res.put("versionName", pInfo.versionName);
+            res.put("versionCode", pInfo.getLongVersionCode());
+            res.put("isDebuggable", isDebuggable);
+
+            callback.success(res);
+        } catch (JSONException e) {
+            callback.error(e.getMessage());
+        } catch (Exception e) {
+            callback.error(e.getMessage());
+        }
     }
 
-    if (className == null || className.equals("")) {
-      callback.error("No activity class name provided.");
-      return;
+    private void openInBrowser(String src, CallbackContext callback) {
+        Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(src));
+        activity.startActivity(browserIntent);
     }
 
-    try{
-        Intent intent = new Intent(Intent.ACTION_MAIN);
-        intent.addCategory(Intent.CATEGORY_LAUNCHER);
-        intent.setPackage(appId);
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    private void launchApp(
+        String appId,
+        String className,
+        String data,
+        CallbackContext callback
+    ) {
+        if (appId == null || appId.equals("")) {
+            callback.error("No package name provided.");
+            return;
+        }
 
-        if (data != null && !data.equals("")) {
-          intent.putExtra("acode_data", data);
+        if (className == null || className.equals("")) {
+            callback.error("No activity class name provided.");
+            return;
         }
-       
-        intent.setClassName(appId, className);
-        activity.startActivity(intent);
-        callback.success("Launched " + appId);
-    }catch(Exception e){
-      callback.error(e.toString());
-      return;
-    }
 
+        try {
+            Intent intent = new Intent(Intent.ACTION_MAIN);
+            intent.addCategory(Intent.CATEGORY_LAUNCHER);
+            intent.setPackage(appId);
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+            if (data != null && !data.equals("")) {
+                intent.putExtra("acode_data", data);
+            }
+
+            intent.setClassName(appId, className);
+            activity.startActivity(intent);
+            callback.success("Launched " + appId);
+        } catch (Exception e) {
+            callback.error(e.toString());
+            return;
+        }
 
-    
-}
 
 
-  private void addShortcut(
-    String id,
-    String label,
-    String description,
-    String iconSrc,
-    String action,
-    String data,
-    CallbackContext callback
-  ) {
-    try {
-      Intent intent;
-      ImageDecoder.Source imgSrc;
-      Bitmap bitmap;
-      IconCompat icon;
-
-      imgSrc = ImageDecoder.createSource(
-        context.getContentResolver(),
-        Uri.parse(iconSrc)
-      );
-      bitmap = ImageDecoder.decodeBitmap(imgSrc);
-      icon = IconCompat.createWithBitmap(bitmap);
-      intent = activity
-        .getPackageManager()
-        .getLaunchIntentForPackage(activity.getPackageName());
-      intent.putExtra("action", action);
-      intent.putExtra("data", data);
-
-      ShortcutInfoCompat shortcut = new ShortcutInfoCompat.Builder(context, id)
-        .setShortLabel(label)
-        .setLongLabel(description)
-        .setIcon(icon)
-        .setIntent(intent)
-        .build();
-
-      ShortcutManagerCompat.pushDynamicShortcut(context, shortcut);
-      callback.success();
-    } catch (Exception e) {
-      callback.error(e.toString());
     }
-  }
-
-  private void pinShortcut(String id, CallbackContext callback) {
-    ShortcutManager shortcutManager = context.getSystemService(
-      ShortcutManager.class
-    );
-
-    if (shortcutManager.isRequestPinShortcutSupported()) {
-      ShortcutInfo pinShortcutInfo = new ShortcutInfo.Builder(
-        context,
-        id
-      ).build();
-
-      Intent pinnedShortcutCallbackIntent =
-        shortcutManager.createShortcutResultIntent(pinShortcutInfo);
-
-      PendingIntent successCallback = PendingIntent.getBroadcast(
-        context,
-        0,
-        pinnedShortcutCallbackIntent,
-        PendingIntent.FLAG_IMMUTABLE
-      );
-
-      shortcutManager.requestPinShortcut(
-        pinShortcutInfo,
-        successCallback.getIntentSender()
-      );
-
-      callback.success();
-      return;
+
+
+    private void addShortcut(
+        String id,
+        String label,
+        String description,
+        String iconSrc,
+        String action,
+        String data,
+        CallbackContext callback
+    ) {
+        try {
+            Intent intent;
+            ImageDecoder.Source imgSrc;
+            Bitmap bitmap;
+            IconCompat icon;
+
+            imgSrc = ImageDecoder.createSource(
+                context.getContentResolver(),
+                Uri.parse(iconSrc)
+            );
+            bitmap = ImageDecoder.decodeBitmap(imgSrc);
+            icon = IconCompat.createWithBitmap(bitmap);
+            intent = activity
+                .getPackageManager()
+                .getLaunchIntentForPackage(activity.getPackageName());
+            intent.putExtra("action", action);
+            intent.putExtra("data", data);
+
+            ShortcutInfoCompat shortcut = new ShortcutInfoCompat.Builder(context, id)
+                .setShortLabel(label)
+                .setLongLabel(description)
+                .setIcon(icon)
+                .setIntent(intent)
+                .build();
+
+            ShortcutManagerCompat.pushDynamicShortcut(context, shortcut);
+            callback.success();
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
     }
 
-    callback.error("Not supported");
-  }
+    private void pinShortcut(String id, CallbackContext callback) {
+        ShortcutManager shortcutManager = context.getSystemService(
+            ShortcutManager.class
+        );
+
+        if (shortcutManager.isRequestPinShortcutSupported()) {
+            ShortcutInfo pinShortcutInfo = new ShortcutInfo.Builder(
+                context,
+                id
+            ).build();
+
+            Intent pinnedShortcutCallbackIntent =
+                shortcutManager.createShortcutResultIntent(pinShortcutInfo);
+
+            PendingIntent successCallback = PendingIntent.getBroadcast(
+                context,
+                0,
+                pinnedShortcutCallbackIntent,
+                PendingIntent.FLAG_IMMUTABLE
+            );
+
+            shortcutManager.requestPinShortcut(
+                pinShortcutInfo,
+                successCallback.getIntentSender()
+            );
+
+            callback.success();
+            return;
+        }
 
-  private void removeShortcut(String id, CallbackContext callback) {
-    try {
-      List<String> list = new ArrayList<String>();
-      list.add(id);
-      ShortcutManagerCompat.removeDynamicShortcuts(context, list);
-      callback.success();
-    } catch (Exception e) {
-      callback.error(e.toString());
+        callback.error("Not supported");
+    }
+
+    private void removeShortcut(String id, CallbackContext callback) {
+        try {
+            List < String > list = new ArrayList < String > ();
+            list.add(id);
+            ShortcutManagerCompat.removeDynamicShortcuts(context, list);
+            callback.success();
+        } catch (Exception e) {
+            callback.error(e.toString());
+        }
     }
-  }
-
-  private void setUiTheme(
-    final String systemBarColor,
-    final JSONObject schema,
-    final CallbackContext callback
-  ) {
-    this.systemBarColor = Color.parseColor(systemBarColor);
-    this.theme = new Theme(schema);
-
-    final Window window = activity.getWindow();
-    // Method and constants not available on all SDKs but we want to be able to compile this code with any SDK
-    window.clearFlags(0x04000000); // SDK 19: WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
-    window.addFlags(0x80000000); // SDK 21: WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
-    try {
-      // Using reflection makes sure any 5.0+ device will work without having to compile with SDK level 21
 
-      window
-        .getClass()
-        .getMethod("setNavigationBarColor", int.class)
-        .invoke(window, this.systemBarColor);
+    private void setUiTheme(
+        final String systemBarColor,
+        final JSONObject schema,
+        final CallbackContext callback
+    ) {
+        this.systemBarColor = Color.parseColor(systemBarColor);
+        this.theme = new Theme(schema);
 
-      window
-        .getClass()
-        .getMethod("setStatusBarColor", int.class)
-        .invoke(window, this.systemBarColor);
+        final Window window = activity.getWindow();
+        // Method and constants not available on all SDKs but we want to be able to compile this code with any SDK
+        window.clearFlags(0x04000000); // SDK 19: WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
+        window.addFlags(0x80000000); // SDK 21: WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
+        try {
+            // Using reflection makes sure any 5.0+ device will work without having to compile with SDK level 21
+
+            window
+                .getClass()
+                .getMethod("setNavigationBarColor", int.class)
+                .invoke(window, this.systemBarColor);
 
-      window.getDecorView().setBackgroundColor(this.systemBarColor);
+            window
+                .getClass()
+                .getMethod("setStatusBarColor", int.class)
+                .invoke(window, this.systemBarColor);
 
-      if (Build.VERSION.SDK_INT < 30) {
-        setStatusBarStyle(window);
-        setNavigationBarStyle(window);
-      } else {
+            window.getDecorView().setBackgroundColor(this.systemBarColor);
+
+            if (Build.VERSION.SDK_INT < 30) {
+                setStatusBarStyle(window);
+                setNavigationBarStyle(window);
+            } else {
+                String themeType = theme.getType();
+                WindowInsetsController controller = window.getInsetsController();
+                int appearance =
+                    WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS |
+                    WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS;
+
+                if (themeType.equals("light")) {
+                    controller.setSystemBarsAppearance(appearance, appearance);
+                } else {
+                    controller.setSystemBarsAppearance(0, appearance);
+                }
+            }
+            callback.success("OK");
+        } catch (IllegalArgumentException error) {
+            callback.error(error.toString());
+        } catch (Exception error) {
+            callback.error(error.toString());
+        }
+    }
+
+    private void setStatusBarStyle(final Window window) {
+        View decorView = window.getDecorView();
+        int uiOptions = decorView.getSystemUiVisibility();
         String themeType = theme.getType();
-        WindowInsetsController controller = window.getInsetsController();
-        int appearance =
-          WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS |
-          WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS;
 
         if (themeType.equals("light")) {
-          controller.setSystemBarsAppearance(appearance, appearance);
-        } else {
-          controller.setSystemBarsAppearance(0, appearance);
+            decorView.setSystemUiVisibility(
+                uiOptions | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
+            );
+            return;
         }
-      }
-      callback.success("OK");
-    } catch (IllegalArgumentException error) {
-      callback.error(error.toString());
-    } catch (Exception error) {
-      callback.error(error.toString());
+        decorView.setSystemUiVisibility(
+            uiOptions & ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
+        );
     }
-  }
-
-  private void setStatusBarStyle(final Window window) {
-    View decorView = window.getDecorView();
-    int uiOptions = decorView.getSystemUiVisibility();
-    String themeType = theme.getType();
-
-    if (themeType.equals("light")) {
-      decorView.setSystemUiVisibility(
-        uiOptions | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-      );
-      return;
+
+    private void setNavigationBarStyle(final Window window) {
+        View decorView = window.getDecorView();
+        int uiOptions = decorView.getSystemUiVisibility();
+        String themeType = theme.getType();
+
+        // 0x80000000 FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
+        // 0x00000010 SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
+
+        if (themeType.equals("light")) {
+            decorView.setSystemUiVisibility(uiOptions | 0x80000000 | 0x00000010);
+            return;
+        }
+        decorView.setSystemUiVisibility(uiOptions | (0x80000000 & ~0x00000010));
     }
-    decorView.setSystemUiVisibility(
-      uiOptions & ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-    );
-  }
-
-  private void setNavigationBarStyle(final Window window) {
-    View decorView = window.getDecorView();
-    int uiOptions = decorView.getSystemUiVisibility();
-    String themeType = theme.getType();
-
-    // 0x80000000 FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS
-    // 0x00000010 SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
-
-    if (themeType.equals("light")) {
-      decorView.setSystemUiVisibility(uiOptions | 0x80000000 | 0x00000010);
-      return;
+
+    private void getCordovaIntent(CallbackContext callback) {
+        Intent intent = activity.getIntent();
+        callback.sendPluginResult(
+            new PluginResult(PluginResult.Status.OK, getIntentJson(intent))
+        );
     }
-    decorView.setSystemUiVisibility(uiOptions | (0x80000000 & ~0x00000010));
-  }
-
-  private void getCordovaIntent(CallbackContext callback) {
-    Intent intent = activity.getIntent();
-    callback.sendPluginResult(
-      new PluginResult(PluginResult.Status.OK, getIntentJson(intent))
-    );
-  }
-
-  private void setIntentHandler(CallbackContext callback) {
-    intentHandler = callback;
-    PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
-    result.setKeepCallback(true);
-    callback.sendPluginResult(result);
-  }
-
-  @Override
-  public void onNewIntent(Intent intent) {
-    if (intentHandler != null) {
-      PluginResult result = new PluginResult(
-        PluginResult.Status.OK,
-        getIntentJson(intent)
-      );
-      result.setKeepCallback(true);
-      intentHandler.sendPluginResult(result);
+
+    private void setIntentHandler(CallbackContext callback) {
+        intentHandler = callback;
+        PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
+        result.setKeepCallback(true);
+        callback.sendPluginResult(result);
     }
-  }
 
-  private JSONObject getIntentJson(Intent intent) {
-    JSONObject json = new JSONObject();
-    try {
-      json.put("action", intent.getAction());
-      json.put("data", intent.getDataString());
-      json.put("type", intent.getType());
-      json.put("package", intent.getPackage());
-      json.put("extras", getExtrasJson(intent.getExtras()));
-    } catch (JSONException e) {
-      e.printStackTrace();
+    @Override
+    public void onNewIntent(Intent intent) {
+        if (intentHandler != null) {
+            PluginResult result = new PluginResult(
+                PluginResult.Status.OK,
+                getIntentJson(intent)
+            );
+            result.setKeepCallback(true);
+            intentHandler.sendPluginResult(result);
+        }
     }
-    return json;
-  }
 
-  private JSONObject getExtrasJson(Bundle extras) {
-    JSONObject json = new JSONObject();
-    if (extras != null) {
-      for (String key : extras.keySet()) {
+    private JSONObject getIntentJson(Intent intent) {
+        JSONObject json = new JSONObject();
         try {
-          Object value = extras.get(key);
-          if (value instanceof String) {
-            json.put(key, (String) value);
-          } else if (value instanceof Integer) {
-            json.put(key, (Integer) value);
-          } else if (value instanceof Long) {
-            json.put(key, (Long) value);
-          } else if (value instanceof Double) {
-            json.put(key, (Double) value);
-          } else if (value instanceof Float) {
-            json.put(key, (Float) value);
-          } else if (value instanceof Boolean) {
-            json.put(key, (Boolean) value);
-          } else if (value instanceof Bundle) {
-            json.put(key, getExtrasJson((Bundle) value));
-          } else {
-            json.put(key, value.toString());
-          }
+            json.put("action", intent.getAction());
+            json.put("data", intent.getDataString());
+            json.put("type", intent.getType());
+            json.put("package", intent.getPackage());
+            json.put("extras", getExtrasJson(intent.getExtras()));
         } catch (JSONException e) {
-          e.printStackTrace();
+            e.printStackTrace();
         }
-      }
+        return json;
     }
-    return json;
-  }
-
-  private Uri getContentProviderUri(String fileUri) {
-    return this.getContentProviderUri(fileUri, "");
-  }
-
-  private Uri getContentProviderUri(String fileUri, String filename) {
-    Uri uri = Uri.parse(fileUri);
-    String Id = context.getPackageName();
-    if (fileUri.matches("file:///(.*)")) {
-      File file = new File(uri.getPath());
-      if (filename.equals("")) {
-        return FileProvider.getUriForFile(context, Id + ".provider", file);
-      }
-
-      return FileProvider.getUriForFile(
-        context,
-        Id + ".provider",
-        file,
-        filename
-      );
+
+    private JSONObject getExtrasJson(Bundle extras) {
+        JSONObject json = new JSONObject();
+        if (extras != null) {
+            for (String key: extras.keySet()) {
+                try {
+                    Object value = extras.get(key);
+                    if (value instanceof String) {
+                        json.put(key, (String) value);
+                    } else if (value instanceof Integer) {
+                        json.put(key, (Integer) value);
+                    } else if (value instanceof Long) {
+                        json.put(key, (Long) value);
+                    } else if (value instanceof Double) {
+                        json.put(key, (Double) value);
+                    } else if (value instanceof Float) {
+                        json.put(key, (Float) value);
+                    } else if (value instanceof Boolean) {
+                        json.put(key, (Boolean) value);
+                    } else if (value instanceof Bundle) {
+                        json.put(key, getExtrasJson((Bundle) value));
+                    } else {
+                        json.put(key, value.toString());
+                    }
+                } catch (JSONException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return json;
     }
-    return uri;
-  }
-
-  private boolean isPackageInstalled(
-    String packageName,
-    PackageManager packageManager,
-    CallbackContext callback
-  ) {
-    try {
-      packageManager.getPackageInfo(packageName, 0);
-      return true;
-    } catch (PackageManager.NameNotFoundException e) {
-      return false;
+
+    private Uri getContentProviderUri(String fileUri) {
+        return this.getContentProviderUri(fileUri, "");
     }
-  }
-
-  private void getGlobalSetting(String setting, CallbackContext callback) {
-    int value = (int) Global.getFloat(
-      context.getContentResolver(),
-      setting,
-      -1
-    );
-    callback.success(value);
-  }
-
-  private void clearCache(CallbackContext callback) {
-    webView.clearCache(true);
-    callback.success("Cache cleared");
-  }
-
-  private void setInputType(String type) {
-    int mode = -1;
-    if (type.equals("NO_SUGGESTIONS")) {
-      mode = 0;
-    } else if (type.equals("NO_SUGGESTIONS_AGGRESSIVE")) {
-      mode = 1;
+
+    private Uri getContentProviderUri(String fileUri, String filename) {
+        Uri uri = Uri.parse(fileUri);
+        String Id = context.getPackageName();
+        if (fileUri.matches("file:///(.*)")) {
+            File file = new File(uri.getPath());
+            if (filename.equals("")) {
+                return FileProvider.getUriForFile(context, Id + ".provider", file);
+            }
+
+            return FileProvider.getUriForFile(
+                context,
+                Id + ".provider",
+                file,
+                filename
+            );
+        }
+        return uri;
     }
-    webView.setInputType(mode);
-  }
-}
+
+    private boolean isPackageInstalled(
+        String packageName,
+        PackageManager packageManager,
+        CallbackContext callback
+    ) {
+        try {
+            packageManager.getPackageInfo(packageName, 0);
+            return true;
+        } catch (PackageManager.NameNotFoundException e) {
+            return false;
+        }
+    }
+
+    private void getGlobalSetting(String setting, CallbackContext callback) {
+        int value = (int) Global.getFloat(
+            context.getContentResolver(),
+            setting, -1
+        );
+        callback.success(value);
+    }
+
+    private void clearCache(CallbackContext callback) {
+        webView.clearCache(true);
+        callback.success("Cache cleared");
+    }
+
+    private void setInputType(String type) {
+        int mode = -1;
+        if (type.equals("NO_SUGGESTIONS")) {
+            mode = 0;
+        } else if (type.equals("NO_SUGGESTIONS_AGGRESSIVE")) {
+            mode = 1;
+        }
+        webView.setInputType(mode);
+    }
+}
\ No newline at end of file
diff --git a/src/plugins/system/plugin.xml b/src/plugins/system/plugin.xml
index e42796afb..2ddfb25a1 100644
--- a/src/plugins/system/plugin.xml
+++ b/src/plugins/system/plugin.xml
@@ -40,5 +40,6 @@
 
     <framework src="androidx.core:core:1.6.0" />
     <framework src="androidx.core:core-google-shortcuts:1.0.0" />
+    <framework src="androidx.documentfile:documentfile:1.0.1" />
   </platform>
 </plugin>
\ No newline at end of file
diff --git a/src/plugins/system/www/plugin.js b/src/plugins/system/www/plugin.js
index 89314ac35..17c616281 100644
--- a/src/plugins/system/www/plugin.js
+++ b/src/plugins/system/www/plugin.js
@@ -1,4 +1,7 @@
 module.exports = {
+  copyToUri: function (srcUri,destUri,fileName, success, error) {
+    cordova.exec(success, error, 'System', 'copyToUri', [srcUri,destUri,fileName]);
+  },
   fileExists: function (path,countSymlinks, success, error) {
       cordova.exec(success, error, 'System', 'fileExists', [path,String(countSymlinks)]);
     },
diff --git a/src/plugins/terminal/src/android/Executor.java b/src/plugins/terminal/src/android/Executor.java
index a02942cd3..015a3ca7a 100644
--- a/src/plugins/terminal/src/android/Executor.java
+++ b/src/plugins/terminal/src/android/Executor.java
@@ -68,6 +68,7 @@ public boolean execute(String action, JSONArray args, CallbackContext callbackCo
     }
 
     private void exec(String cmd,String alpine, CallbackContext callbackContext) {
+        cordova.getThreadPool().execute(() -> {
         try {
             if (cmd != null && !cmd.isEmpty()) {
                 String xcmd = cmd;
@@ -126,6 +127,7 @@ private void exec(String cmd,String alpine, CallbackContext callbackContext) {
             e.printStackTrace();
             callbackContext.error("Exception: " + e.getMessage());
         }
+        });
     }
 
     private void startProcess(String pid, String cmd,String alpine, CallbackContext callbackContext) {
diff --git a/src/plugins/terminal/www/Executor.js b/src/plugins/terminal/www/Executor.js
index ec8301970..4675d12c6 100644
--- a/src/plugins/terminal/www/Executor.js
+++ b/src/plugins/terminal/www/Executor.js
@@ -28,7 +28,13 @@ const Executor = {
    *   Executor.stop(uuid);
    * });
    */
-  start(command, onData, alpine = false) {
+
+
+  start(command,onData){
+    this.start(command,onData,false)
+  },
+
+  start(command, onData, alpine) {
     return new Promise((resolve, reject) => {
       exec(
         (message) => {
@@ -109,7 +115,11 @@ const Executor = {
    *   .then(console.log)
    *   .catch(console.error);
    */
-  execute(command, alpine = false) {
+  execute(command){
+    this.execute(command,false)
+  }
+  ,
+  execute(command, alpine) {
     return new Promise((resolve, reject) => {
       exec(resolve, reject, "Executor", "exec", [command, String(alpine)]);
     });
diff --git a/src/plugins/terminal/www/Terminal.js b/src/plugins/terminal/www/Terminal.js
index 9187ee957..f376c5bbb 100644
--- a/src/plugins/terminal/www/Terminal.js
+++ b/src/plugins/terminal/www/Terminal.js
@@ -1,37 +1,57 @@
 const Executor = require("./Executor");
 
-/**
- * AXS server version tag to be used in downloads.
- * @constant {string}
- */
-const AXS_VERSION_TAG = "v0.2.5";
-
 const Terminal = {
     /**
      * Starts the AXS environment by writing init scripts and executing the sandbox.
      * @param {boolean} [installing=false] - Whether AXS is being started during installation.
      * @param {Function} [logger=console.log] - Function to log standard output.
      * @param {Function} [err_logger=console.error] - Function to log errors.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Returns true if installation completes with exit code 0, void if not installing
      */
     async startAxs(installing = false, logger = console.log, err_logger = console.error) {
         const filesDir = await new Promise((resolve, reject) => {
             system.getFilesDir(resolve, reject);
         });
 
-        readAsset("init-alpine.sh", async (content) => {
-            system.writeText(`${filesDir}/init-alpine.sh`, content, logger, err_logger);
-        });
+        if (installing) {
+            return new Promise((resolve, reject) => {
+                readAsset("init-alpine.sh", async (content) => {
+                    system.writeText(`${filesDir}/init-alpine.sh`, content, logger, err_logger);
+                });
 
-        readAsset("init-sandbox.sh", (content) => {
-            system.writeText(`${filesDir}/init-sandbox.sh`, content, logger, err_logger);
+                readAsset("init-sandbox.sh", (content) => {
+                    system.writeText(`${filesDir}/init-sandbox.sh`, content, logger, err_logger);
+
+                    Executor.start("sh", (type, data) => {
+                        logger(`${type} ${data}`);
+
+                        // Check for exit code during installation
+                        if (type === "exit") {
+                            resolve(data === "0");
+                        }
+                    }).then(async (uuid) => {
+                        await Executor.write(uuid, `source ${filesDir}/init-sandbox.sh ${installing ? "--installing" : ""}; exit`);
+                    }).catch((error) => {
+                        err_logger("Failed to start AXS:", error);
+                        resolve(false);
+                    });
+                });
+            });
+        } else {
+            readAsset("init-alpine.sh", async (content) => {
+                system.writeText(`${filesDir}/init-alpine.sh`, content, logger, err_logger);
+            });
 
-            Executor.start("sh", (type, data) => {
-                logger(`${type} ${data}`);
-            }).then(async (uuid) => {
-                await Executor.write(uuid, `source ${filesDir}/init-sandbox.sh ${installing ? "--installing" : ""}; exit`);
+            readAsset("init-sandbox.sh", (content) => {
+                system.writeText(`${filesDir}/init-sandbox.sh`, content, logger, err_logger);
+
+                Executor.start("sh", (type, data) => {
+                    logger(`${type} ${data}`);
+                }).then(async (uuid) => {
+                    await Executor.write(uuid, `source ${filesDir}/init-sandbox.sh ${installing ? "--installing" : ""}; exit`);
+                });
             });
-        });
+        }
     },
 
     /**
@@ -68,11 +88,11 @@ const Terminal = {
      * Also sets up additional dependencies for F-Droid variant.
      * @param {Function} [logger=console.log] - Function to log standard output.
      * @param {Function} [err_logger=console.error] - Function to log errors.
-     * @returns {Promise<void>}
+     * @returns {Promise<boolean>} - Returns true if installation completes with exit code 0
      */
     async install(logger = console.log, err_logger = console.error) {
-        if (await this.isInstalled()) return;
-        if (!(await this.isSupported())) return;
+        if (await this.isInstalled()) return true;
+        if (!(await this.isSupported())) return false;
 
         const filesDir = await new Promise((resolve, reject) => {
             system.getFilesDir(resolve, reject);
@@ -91,17 +111,17 @@ const Terminal = {
             if (arch === "arm64-v8a") {
                 libTalloc = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/arm64/libtalloc.so";
                 prootUrl = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/arm64/libproot-xed.so";
-                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/download/${AXS_VERSION_TAG}/axs-musl-android-arm64`;
+                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/latest/download/axs-musl-android-arm64`;
                 alpineUrl = "https://dl-cdn.alpinelinux.org/alpine/v3.21/releases/aarch64/alpine-minirootfs-3.21.0-aarch64.tar.gz";
             } else if (arch === "armeabi-v7a") {
                 libTalloc = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/arm32/libtalloc.so";
                 prootUrl = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/arm32/libproot-xed.so";
-                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/download/${AXS_VERSION_TAG}/axs-musl-android-armv7`;
+                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/latest/download/axs-musl-android-armv7`;
                 alpineUrl = "https://dl-cdn.alpinelinux.org/alpine/v3.21/releases/armhf/alpine-minirootfs-3.21.0-armhf.tar.gz";
             } else if (arch === "x86_64") {
                 libTalloc = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/x64/libtalloc.so";
                 prootUrl = "https://raw.githubusercontent.com/Acode-Foundation/Acode/main/src/plugins/proot/libs/x64/libproot-xed.so";
-                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/download/${AXS_VERSION_TAG}/axs-musl-android-x86_64`;
+                axsUrl = `https://github.com/bajrangCoder/acodex_server/releases/latest/download/axs-musl-android-x86_64`;
                 alpineUrl = "https://dl-cdn.alpinelinux.org/alpine/v3.21/releases/x86_64/alpine-minirootfs-3.21.0-x86_64.tar.gz";
             } else {
                 throw new Error(`Unsupported architecture: ${arch}`);
@@ -168,10 +188,12 @@ const Terminal = {
                 system.mkdirs(`${filesDir}/.extracted`, resolve, reject);
             });
 
-            this.startAxs(true, logger, err_logger);
+            const installResult = await this.startAxs(true, logger, err_logger);
+            return installResult;
 
         } catch (e) {
             err_logger("Installation failed:", e);
+            return false;
         }
     },
 
@@ -186,7 +208,7 @@ const Terminal = {
             });
 
             const alpineExists = await new Promise((resolve, reject) => {
-                system.fileExists(`${filesDir}/alpine.tar.gz`, false, (result) => {
+                system.fileExists(`${filesDir}/alpine`, false, (result) => {
                     resolve(result == 1);
                 }, reject);
             });
@@ -217,6 +239,146 @@ const Terminal = {
                 resolve(["arm64-v8a", "armeabi-v7a", "x86_64"].includes(arch));
             }, reject);
         });
+    },
+    /**
+     * Creates a backup of the Alpine Linux installation
+     * @async
+     * @function backup
+     * @description Creates a compressed tar archive of the Alpine installation
+     * @returns {Promise<string>} Promise that resolves to the file URI of the created backup file (aterm_backup.tar)
+     * @throws {string} Rejects with "Alpine is not installed." if Alpine is not currently installed
+     * @throws {string} Rejects with command output if backup creation fails
+     * @example
+     * try {
+     *   const backupPath = await backup();
+     *   console.log(`Backup created at: ${backupPath}`);
+     * } catch (error) {
+     *   console.error(`Backup failed: ${error}`);
+     * }
+     */
+    backup() {
+        return new Promise(async (resolve, reject) => {
+            if (!await this.isInstalled()) {
+                reject("Alpine is not installed.");
+                return;
+            }
+
+            const cmd = `
+            set -e
+
+            INCLUDE_FILES="alpine .downloaded .extracted axs"
+            if [ "$FDROID" = "true" ]; then
+                INCLUDE_FILES="$INCLUDE_FILES libtalloc.so.2 libproot-xed.so"
+            fi
+
+            EXCLUDE="--exclude=alpine/data --exclude=alpine/system --exclude=alpine/vendor --exclude=alpine/sdcard --exclude=alpine/storage"
+
+            tar -cf "$PREFIX/aterm_backup.tar" -C "$PREFIX" $EXCLUDE $INCLUDE_FILES
+            echo "ok"
+            `;
+
+            const result = await Executor.execute(cmd);
+            if (result === "ok") {
+                resolve(cordova.file.dataDirectory + "aterm_backup.tar");
+            } else {
+                reject(result);
+            }
+        });
+    },
+    /**
+     * Restores Alpine Linux installation from a backup file
+     * @async
+     * @function restore
+     * @description Restores the Alpine installation from a previously created backup file (aterm_backup.tar).
+     * This function stops any running Alpine processes, removes existing installation files, and extracts
+     * the backup to restore the previous state. The backup file must exist in the expected location.
+     * @returns {Promise<string>} Promise that resolves to "ok" when restoration completes successfully
+     * @throws {string} Rejects with "Backup File does not exist" if aterm_backup.tar is not found
+     * @throws {string} Rejects with command output if restoration fails
+     * @example
+     * try {
+     *   await restore();
+     *   console.log("Alpine installation restored successfully");
+     * } catch (error) {
+     *   console.error(`Restore failed: ${error}`);
+     * }
+     */
+    restore() {
+        return new Promise(async (resolve, reject) => {
+            if (await this.isAxsRunning()) {
+                await this.stopAxs();
+            }
+
+            const cmd = `
+            sleep 2
+
+            INCLUDE_FILES="$PREFIX/alpine $PREFIX/.downloaded $PREFIX/.extracted $PREFIX/axs"
+
+            if [ "$FDROID" = "true" ]; then
+                INCLUDE_FILES="$INCLUDE_FILES $PREFIX/libtalloc.so.2 $PREFIX/libproot-xed.so"
+            fi
+
+            for item in $INCLUDE_FILES; do
+                rm -rf -- "$item"
+            done
+
+            tar -xf "$PREFIX/aterm_backup.bin" -C "$PREFIX"
+            echo "ok"
+            `;
+
+            const result = await Executor.execute(cmd);
+            if (result === "ok") {
+                resolve(result);
+            } else {
+                reject(result);
+            }
+        });
+    },
+    /**
+     * Uninstalls the Alpine Linux installation
+     * @async
+     * @function uninstall
+     * @description Completely removes the Alpine Linux installation from the device by deleting all
+     * Alpine-related files and directories. This function stops any running Alpine processes before
+     * removal. NOTE: This does not perform cleanup of $PREFIX
+     * @returns {Promise<string>} Promise that resolves to "ok" when uninstallation completes successfully
+     * @throws {string} Rejects with command output if uninstallation fails
+     * @example
+     * try {
+     *   await uninstall();
+     *   console.log("Alpine installation removed successfully");
+     * } catch (error) {
+     *   console.error(`Uninstall failed: ${error}`);
+     * }
+     */
+    uninstall(){
+        return new Promise(async (resolve, reject) => {
+            if(await this.isAxsRunning()){
+                await this.stopAxs()
+            }
+
+            const cmd = `
+            set -e
+
+            INCLUDE_FILES="$PREFIX/alpine $PREFIX/.downloaded $PREFIX/.extracted $PREFIX/axs"
+
+            if [ "$FDROID" = "true" ]; then
+                INCLUDE_FILES="$INCLUDE_FILES $PREFIX/libtalloc.so.2 $PREFIX/libproot-xed.so"
+            fi
+
+            for item in $INCLUDE_FILES; do
+                rm -rf -- "$item"
+            done
+
+            echo "ok"
+            `
+           const result = await Executor.execute(cmd)
+           if(result === "ok"){
+            resolve(result)
+           }else{
+            reject(result)
+           }
+        });
     }
 };
 
diff --git a/src/settings/mainSettings.js b/src/settings/mainSettings.js
index 07c5924e3..491418172 100644
--- a/src/settings/mainSettings.js
+++ b/src/settings/mainSettings.js
@@ -20,6 +20,7 @@ import formatterSettings from "./formatterSettings";
 import previewSettings from "./previewSettings";
 import scrollSettings from "./scrollSettings";
 import searchSettings from "./searchSettings";
+import terminalSettings from "./terminalSettings";
 
 export default function mainSettings() {
 	const title = strings.settings.capitalize();
@@ -79,7 +80,7 @@ export default function mainSettings() {
 			key: "reset",
 			text: strings["restore default settings"],
 			icon: "historyrestore",
-			index: 5,
+			index: 6,
 		},
 		{
 			key: "preview-settings",
@@ -87,6 +88,12 @@ export default function mainSettings() {
 			icon: "play_arrow",
 			index: 4,
 		},
+		{
+			key: "terminal-settings",
+			text: `${strings["terminal settings"]}`,
+			icon: "licons terminal",
+			index: 5,
+		},
 		{
 			key: "editSettings",
 			text: `${strings["edit"]} settings.json`,
@@ -118,6 +125,7 @@ export default function mainSettings() {
 			case "backup-restore":
 			case "editor-settings":
 			case "preview-settings":
+			case "terminal-settings":
 				appSettings.uiSettings[key].show();
 				break;
 
@@ -191,4 +199,5 @@ export default function mainSettings() {
 	appSettings.uiSettings["scroll-settings"] = scrollSettings();
 	appSettings.uiSettings["search-settings"] = searchSettings();
 	appSettings.uiSettings["preview-settings"] = previewSettings();
+	appSettings.uiSettings["terminal-settings"] = terminalSettings();
 }
diff --git a/src/settings/terminalSettings.js b/src/settings/terminalSettings.js
new file mode 100644
index 000000000..f5f450c7a
--- /dev/null
+++ b/src/settings/terminalSettings.js
@@ -0,0 +1,343 @@
+import settingsPage from "components/settingsPage";
+import {
+	DEFAULT_TERMINAL_SETTINGS,
+	TerminalThemeManager,
+} from "components/terminal";
+import toast from "components/toast";
+import alert from "dialogs/alert";
+import loader from "dialogs/loader";
+import fsOperation from "fileSystem";
+import fonts from "lib/fonts";
+import appSettings from "lib/settings";
+import FileBrowser from "pages/fileBrowser";
+
+export default function terminalSettings() {
+	const title = strings["terminal settings"];
+	const values = appSettings.value;
+
+	// Initialize terminal settings with defaults if not present
+	if (!values.terminalSettings) {
+		values.terminalSettings = {
+			...DEFAULT_TERMINAL_SETTINGS,
+			fontFamily:
+				DEFAULT_TERMINAL_SETTINGS.fontFamily || appSettings.value.fontFamily,
+		};
+	}
+
+	const terminalValues = values.terminalSettings;
+
+	const items = [
+		{
+			key: "fontSize",
+			text: strings["font size"],
+			value: terminalValues.fontSize,
+			prompt: strings["font size"],
+			promptType: "number",
+			promptOptions: {
+				test(value) {
+					value = Number.parseInt(value);
+					return value >= 8 && value <= 32;
+				},
+			},
+			info: "The font size used to render text.",
+		},
+		{
+			key: "fontFamily",
+			text: strings["terminal:font family"],
+			value: terminalValues.fontFamily,
+			get select() {
+				return fonts.getNames();
+			},
+			info: "The font family used to render text.",
+		},
+		{
+			key: "theme",
+			text: strings["theme"],
+			value: terminalValues.theme,
+			info: "The color theme of the terminal.",
+			get select() {
+				return TerminalThemeManager.getThemeNames().map((name) => [
+					name,
+					name.charAt(0).toUpperCase() + name.slice(1),
+				]);
+			},
+			valueText(value) {
+				const option = this.select.find(([v]) => v === value);
+				return option ? option[1] : value;
+			},
+		},
+		{
+			key: "cursorStyle",
+			text: strings["terminal:cursor style"],
+			value: terminalValues.cursorStyle,
+			select: ["block", "underline", "bar"],
+			info: "The style of the cursor when the terminal is focused.",
+		},
+		{
+			key: "cursorInactiveStyle",
+			text: strings["terminal:cursor inactive style"],
+			value: terminalValues.cursorInactiveStyle,
+			select: ["outline", "block", "bar", "underline", "none"],
+			info: "The style of the cursor when the terminal is not focused.",
+		},
+		{
+			key: "fontWeight",
+			text: strings["terminal:font weight"],
+			value: terminalValues.fontWeight,
+			select: [
+				"normal",
+				"bold",
+				"100",
+				"200",
+				"300",
+				"400",
+				"500",
+				"600",
+				"700",
+				"800",
+				"900",
+			],
+			info: "The font weight used to render non-bold text.",
+		},
+		{
+			key: "cursorBlink",
+			text: strings["terminal:cursor blink"],
+			checkbox: terminalValues.cursorBlink,
+			info: "Whether the cursor blinks.",
+		},
+		{
+			key: "scrollback",
+			text: strings["terminal:scrollback"],
+			value: terminalValues.scrollback,
+			prompt: strings["terminal:scrollback"],
+			promptType: "number",
+			promptOptions: {
+				test(value) {
+					value = Number.parseInt(value);
+					return value >= 100 && value <= 10000;
+				},
+			},
+			info: "The amount of scrollback in the terminal. Scrollback is the amount of rows that are retained when lines are scrolled beyond the initial viewport.",
+		},
+		{
+			key: "tabStopWidth",
+			text: strings["terminal:tab stop width"],
+			value: terminalValues.tabStopWidth,
+			prompt: strings["terminal:tab stop width"],
+			promptType: "number",
+			promptOptions: {
+				test(value) {
+					value = Number.parseInt(value);
+					return value >= 1 && value <= 8;
+				},
+			},
+			info: "The size of tab stops in the terminal.",
+		},
+		{
+			key: "letterSpacing",
+			text: strings["letter spacing"],
+			value: terminalValues.letterSpacing,
+			prompt: strings["letter spacing"],
+			promptType: "number",
+			info: "The spacing in whole pixels between characters.",
+		},
+		{
+			key: "convertEol",
+			text: strings["terminal:convert eol"],
+			checkbox: terminalValues.convertEol,
+		},
+		{
+			key: "imageSupport",
+			text: `${strings["image"]} Support`,
+			checkbox: terminalValues.imageSupport,
+			info: "Whether images are supported in the terminal.",
+		},
+		{
+			key: "fontLigatures",
+			text: strings["font ligatures"],
+			checkbox: terminalValues.fontLigatures,
+			info: "Whether font ligatures are enabled in the terminal.",
+		},
+		{
+			key: "backup",
+			text: strings.backup.capitalize(),
+			info: "Creates a backup of the terminal installation",
+		},
+		{
+			key: "restore",
+			text: strings.restore.capitalize(),
+			info: "Restores a backup of the terminal installation",
+		},
+	];
+
+	return settingsPage(title, items, callback);
+
+	/**
+	 * Callback for settings page when an item is clicked
+	 * @param {string} key
+	 * @param {string} value
+	 */
+	function callback(key, value) {
+		switch (key) {
+			case "backup":
+				terminalBackup();
+				return;
+
+			case "restore":
+				terminalRestore();
+				return;
+
+			default:
+				appSettings.update({
+					terminalSettings: {
+						...values.terminalSettings,
+						[key]: value,
+					},
+				});
+
+				// Update any active terminal instances
+				updateActiveTerminals(key, value);
+				break;
+		}
+	}
+
+	/**
+	 * Creates a backup of the terminal installation
+	 */
+	async function terminalBackup() {
+		try {
+			// Ask user to select backup location
+			const { url } = await FileBrowser("folder", strings["select folder"]);
+
+			loader.showTitleLoader();
+
+			// Create backup
+			const backupPath = await Terminal.backup();
+			await system.copyToUri(
+				backupPath,
+				url,
+				"aterm_backup.tar",
+				console.log,
+				console.error,
+			);
+			loader.removeTitleLoader();
+			alert(strings.success.toUpperCase(), `${strings["backup successful"]}.`);
+		} catch (error) {
+			loader.removeTitleLoader();
+			console.error("Terminal backup failed:", error);
+			toast(error.toString());
+		}
+	}
+
+	/**
+	 * Restores terminal installation
+	 */
+	async function terminalRestore() {
+		try {
+			sdcard.openDocumentFile(
+				async (data) => {
+					loader.showTitleLoader();
+					//this will create a file at $PREFIX/atem_backup.bin
+					await system.copyToUri(
+						data.uri,
+						cordova.file.dataDirectory,
+						"aterm_backup",
+						console.log,
+						console.error,
+					);
+
+					// Restore
+					await Terminal.restore();
+
+					// Clean up
+					const backupFilename = "aterm_backup.bin";
+					const tempBackupPath = cordova.file.dataDirectory + backupFilename;
+					const tempFS = fsOperation(tempBackupPath);
+					await tempFS.delete();
+					loader.removeTitleLoader();
+					alert(
+						strings.success.toUpperCase(),
+						"Terminal restored successfully",
+					);
+				},
+				toast,
+				"application/x-tar",
+			);
+		} catch (error) {
+			loader.removeTitleLoader();
+			console.error("Terminal restore failed:", error);
+			toast(error.toString());
+		}
+	}
+}
+
+/**
+ * Update active terminal instances with new settings
+ * @param {string} key
+ * @param {any} value
+ */
+async function updateActiveTerminals(key, value) {
+	// Find all terminal tabs and update their settings
+	const terminalTabs = editorManager.files.filter(
+		(file) => file.type === "terminal",
+	);
+
+	terminalTabs.forEach(async (tab) => {
+		if (tab.terminalComponent) {
+			const terminalOptions = {};
+
+			switch (key) {
+				case "fontSize":
+					tab.terminalComponent.terminal.options.fontSize = value;
+					break;
+				case "fontFamily":
+					// Load font if it's not already loaded
+					try {
+						await fonts.loadFont(value);
+					} catch (error) {
+						console.warn(`Failed to load font ${value}:`, error);
+					}
+					tab.terminalComponent.terminal.options.fontFamily = value;
+					tab.terminalComponent.terminal.refresh(
+						0,
+						tab.terminalComponent.terminal.rows - 1,
+					);
+					break;
+				case "fontWeight":
+					tab.terminalComponent.terminal.options.fontWeight = value;
+					break;
+				case "cursorBlink":
+					tab.terminalComponent.terminal.options.cursorBlink = value;
+					break;
+				case "cursorStyle":
+					tab.terminalComponent.terminal.options.cursorStyle = value;
+					break;
+				case "cursorInactiveStyle":
+					tab.terminalComponent.terminal.options.cursorInactiveStyle = value;
+					break;
+				case "scrollback":
+					tab.terminalComponent.terminal.options.scrollback = value;
+					break;
+				case "tabStopWidth":
+					tab.terminalComponent.terminal.options.tabStopWidth = value;
+					break;
+				case "convertEol":
+					tab.terminalComponent.terminal.options.convertEol = value;
+					break;
+				case "letterSpacing":
+					tab.terminalComponent.terminal.options.letterSpacing = value;
+					break;
+				case "theme":
+					tab.terminalComponent.terminal.options.theme =
+						TerminalThemeManager.getTheme(value);
+					break;
+				case "imageSupport":
+					tab.terminalComponent.updateImageSupport(value);
+					break;
+				case "fontLigatures":
+					tab.terminalComponent.updateFontLigatures(value);
+					break;
+			}
+		}
+	});
+}
diff --git a/src/views/menu.hbs b/src/views/menu.hbs
index ec0b0370f..b7b967f9a 100644
--- a/src/views/menu.hbs
+++ b/src/views/menu.hbs
@@ -30,6 +30,10 @@
   <span class="text">{{console}}</span>
   <span class="icon code"></span>
 </li>
+<li action="new-terminal">
+  <span class="text">{{terminal}}</span>
+  <span class="licons terminal"></span>
+</li>
 <hr>
 <li action="open" value="settings">
   <span class="text">{{settings}}</span>
@@ -43,4 +47,4 @@
 <li action="exit">
   <span class="text">{{exit}}</span>
   <span class="icon logout"></span>
-</li>
\ No newline at end of file
+</li>
diff --git a/utils/extra-icons/terminal.svg b/utils/extra-icons/terminal.svg
new file mode 100644
index 000000000..013dda9be
--- /dev/null
+++ b/utils/extra-icons/terminal.svg
@@ -0,0 +1,6 @@
+<!-- Generated by IcoMoon.io -->
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024">
+<g id="icomoon-ignore">
+</g>
+<path fill="#000" d="M155.435 173.611c-15.019 5.291-27.435 23.253-27.435 39.723 0 3.413 1.237 9.984 2.773 14.635 2.517 7.637 13.312 18.987 118.997 124.885l116.267 116.48-116.267 116.48c-105.685 105.899-116.48 117.248-118.997 124.885-5.504 16.64-1.877 32.683 10.027 44.587 7.622 7.668 18.176 12.414 29.839 12.414 6.92 0 13.45-1.671 19.208-4.631l-0.236 0.11c5.419-2.603 44.715-40.875 140.843-137.216 126.507-126.72 133.504-134.059 136.32-142.72 1.409-4.083 2.223-8.788 2.223-13.683 0-6.984-1.656-13.58-4.597-19.419l0.113 0.248c-2.603-5.419-40.875-44.672-137.216-140.843-121.813-121.6-134.315-133.589-141.995-136.107-4.377-1.59-9.429-2.509-14.695-2.509-5.445 0-10.66 0.982-15.478 2.78l0.306-0.1zM497.664 770.688c-9.756 3.576-17.648 10.295-22.631 18.908l-0.11 0.206c-4.053 6.869-4.736 9.941-4.736 20.864s0.683 13.995 4.736 20.864c2.603 4.395 7.253 9.984 10.368 12.331 12.928 9.856 4.693 9.472 197.291 9.472 199.040 0 187.136 0.768 200.661-12.757 7.731-7.619 12.521-18.205 12.521-29.909s-4.79-22.29-12.516-29.904l-0.005-0.005c-13.525-13.525-1.493-12.757-201.301-12.629-149.717 0.085-178.688 0.512-184.277 2.56z"></path>
+</svg>
diff --git a/www/index.html b/www/index.html
index ae9aa7f4d..6ceca12d1 100644
--- a/www/index.html
+++ b/www/index.html
@@ -165,17 +165,17 @@
 
     <title>Acode</title>
       <!--styles-->
+<link rel="stylesheet" href="./css/build/218.css">
+<link rel="stylesheet" href="./css/build/32.css">
+<link rel="stylesheet" href="./css/build/383.css">
+<link rel="stylesheet" href="./css/build/53.css">
+<link rel="stylesheet" href="./css/build/609.css">
 <link rel="stylesheet" href="./css/build/about.css">
 <link rel="stylesheet" href="./css/build/customTheme.css">
 <link rel="stylesheet" href="./css/build/donate.css">
 <link rel="stylesheet" href="./css/build/fileBrowser.css">
 <link rel="stylesheet" href="./css/build/main.css">
 <link rel="stylesheet" href="./css/build/plugins.css">
-<link rel="stylesheet" href="./css/build/src_pages_quickTools_quickTools_js.css">
-<link rel="stylesheet" href="./css/build/src_sidebarApps_extensions_index_js.css">
-<link rel="stylesheet" href="./css/build/src_sidebarApps_files_index_js.css">
-<link rel="stylesheet" href="./css/build/src_sidebarApps_notification_index_js.css">
-<link rel="stylesheet" href="./css/build/src_sidebarApps_searchInFiles_index_js.css">
 <link rel="stylesheet" href="./css/build/themeSetting.css">
 <!--styles_end-->
 </head>
diff --git a/www/res/fonts/MesloLGSNFRegular.ttf b/www/res/fonts/MesloLGSNFRegular.ttf
new file mode 100644
index 000000000..b829758ea
Binary files /dev/null and b/www/res/fonts/MesloLGSNFRegular.ttf differ
diff --git a/www/res/icons/li-icons.ttf b/www/res/icons/li-icons.ttf
index 05b3cf556..2880af54f 100644
Binary files a/www/res/icons/li-icons.ttf and b/www/res/icons/li-icons.ttf differ
diff --git a/www/res/icons/style.css b/www/res/icons/style.css
index dfeececdb..1fb38d5fe 100644
--- a/www/res/icons/style.css
+++ b/www/res/icons/style.css
@@ -8,7 +8,7 @@
 
 @font-face {
   font-family: "li-icon";
-  src: url("li-icons.ttf?59d3hz") format("truetype");
+  src: url("li-icons.ttf?6wte0b") format("truetype");
   font-weight: normal;
   font-style: normal;
   font-display: block;
@@ -44,18 +44,21 @@
   -moz-osx-font-smoothing: grayscale;
 }
 
-.licons.verified:before {
+.licons.terminal:before {
   content: "\e900";
 }
-.licons.tag:before {
+.licons.cart:before {
   content: "\e901";
 }
 .licons.scale:before {
   content: "\e902";
 }
-.licons.cart:before {
+.licons.tag:before {
   content: "\e903";
 }
+.licons.verified:before {
+  content: "\e904";
+}
 
 .icon.acode:before {
   content: "\ea0d";