diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index d89ad3c..43f7e18 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -63,9 +63,13 @@ dependencies {
     implementation(libs.transition)
     implementation(libs.fragment)
     implementation(libs.activity)
-    implementation(project(":filetree"))
+    implementation(libs.terminal.view)
+    implementation(libs.terminal.emulator)
+    implementation(libs.utilcodex)
 
 
+    // with Paths
+    implementation(project(":filetree"))
 
     //tests
     coreLibraryDesugaring(libs.desugar.jdk.libs)
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButton.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButton.java
new file mode 100755
index 0000000..a2b367c
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButton.java
@@ -0,0 +1,49 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import androidx.annotation.NonNull;
+import java.util.HashMap;
+
+/** The {@link Class} that implements special buttons for {@link VirtualKeysView}. */
+public class SpecialButton {
+
+  private static final HashMap<String, SpecialButton> map = new HashMap<>();
+  public static final SpecialButton CTRL = new SpecialButton("CTRL");
+  public static final SpecialButton ALT = new SpecialButton("ALT");
+  public static final SpecialButton SHIFT = new SpecialButton("SHIFT");
+  public static final SpecialButton FN = new SpecialButton("FN");
+
+  /** The special button key. */
+  private final String key;
+
+  /**
+   * Initialize a {@link SpecialButton}.
+   *
+   * @param key The unique key name for the special button. The key is registered in {@link #map}
+   *     with which the {@link SpecialButton} can be retrieved via a call to {@link
+   *     #valueOf(String)}.
+   */
+  public SpecialButton(@NonNull final String key) {
+    this.key = key;
+    map.put(key, this);
+  }
+
+  /**
+   * Get the {@link SpecialButton} for {@code key}.
+   *
+   * @param key The unique key name for the special button.
+   */
+  public static SpecialButton valueOf(String key) {
+    return map.get(key);
+  }
+
+  /** Get {@link #key} for this {@link SpecialButton}. */
+  public String getKey() {
+    return key;
+  }
+
+  @NonNull
+  @Override
+  public String toString() {
+    return key;
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButtonState.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButtonState.java
new file mode 100755
index 0000000..ffa11ad
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/SpecialButtonState.java
@@ -0,0 +1,56 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import android.widget.Button;
+import java.util.ArrayList;
+import java.util.List;
+
+/** The {@link Class} that maintains a state of a {@link SpecialButton} */
+public class SpecialButtonState {
+
+  /** If special button has been created for the {@link VirtualKeysView}. */
+  boolean isCreated = false;
+
+  /** If special button is active. */
+  boolean isActive = false;
+
+  /**
+   * If special button is locked due to long hold on it and should not be deactivated if its state
+   * is read.
+   */
+  boolean isLocked = false;
+
+  List<Button> buttons = new ArrayList<>();
+
+  VirtualKeysView mVirtualKeysView;
+
+  /**
+   * Initialize a {@link SpecialButtonState} to maintain state of a {@link SpecialButton}.
+   *
+   * @param extraKeysView The {@link VirtualKeysView} instance in which the {@link SpecialButton} is
+   *     to be registered.
+   */
+  public SpecialButtonState(VirtualKeysView extraKeysView) {
+    mVirtualKeysView = extraKeysView;
+  }
+
+  /** Set {@link #isCreated}. */
+  public void setIsCreated(boolean value) {
+    isCreated = value;
+  }
+
+  /** Set {@link #isActive}. */
+  public void setIsActive(boolean value) {
+    isActive = value;
+    for (Button button : buttons) {
+      button.setTextColor(
+          value
+              ? mVirtualKeysView.getButtonActiveTextColor()
+              : mVirtualKeysView.getButtonTextColor());
+    }
+  }
+
+  /** Set {@link #isLocked}. */
+  public void setIsLocked(boolean value) {
+    isLocked = value;
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyButton.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyButton.java
new file mode 100755
index 0000000..43fc955
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyButton.java
@@ -0,0 +1,165 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class VirtualKeyButton {
+
+  /**
+   * The key name for the name of the extra key if using a dict to define the extra key. {key: name,
+   * ...}
+   */
+  public static final String KEY_KEY_NAME = "key";
+
+  /**
+   * The key name for the macro value of the extra key if using a dict to define the extra key.
+   * {macro: value, ...}
+   */
+  public static final String KEY_MACRO = "macro";
+
+  /**
+   * The key name for the alternate display name of the extra key if using a dict to define the
+   * extra key. {display: name, ...}
+   */
+  public static final String KEY_DISPLAY_NAME = "display";
+
+  /**
+   * The key name for the nested dict to define popup extra key info if using a dict to define the
+   * extra key. {popup: {key: name, ...}, ...}
+   */
+  public static final String KEY_POPUP = "popup";
+
+  /**
+   * The key that will be sent to the terminal, either a control character, like defined in {@link
+   * VirtualKeysConstants#PRIMARY_KEY_CODES_FOR_STRINGS} (LEFT, RIGHT, PGUP...) or some text.
+   */
+  private final String key;
+
+  /** If the key is a macro, i.e. a sequence of keys separated by space. */
+  private final boolean macro;
+
+  /** The text that will be displayed on the button. */
+  private final String display;
+
+  /**
+   * The {@link VirtualKeyButton} containing the information of the popup button (triggered by swipe
+   * up).
+   */
+  @Nullable private final VirtualKeyButton popup;
+
+  /**
+   * Initialize a {@link VirtualKeyButton}.
+   *
+   * @param config The {@link JSONObject} containing the info to create the {@link
+   *     VirtualKeyButton}.
+   * @param extraKeyDisplayMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines
+   *     the display text mapping for the keys if a custom value is not defined by {@link
+   *     #KEY_DISPLAY_NAME}.
+   * @param extraKeyAliasMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines the
+   *     aliases for the actual key names.
+   */
+  public VirtualKeyButton(
+      @NonNull JSONObject config,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyDisplayMap,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap)
+      throws JSONException {
+    this(config, null, extraKeyDisplayMap, extraKeyAliasMap);
+  }
+
+  /**
+   * Initialize a {@link VirtualKeyButton}.
+   *
+   * @param config The {@link JSONObject} containing the info to create the {@link
+   *     VirtualKeyButton}.
+   * @param popup The {@link VirtualKeyButton} optional {@link #popup} button.
+   * @param extraKeyDisplayMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines
+   *     the display text mapping for the keys if a custom value is not defined by {@link
+   *     #KEY_DISPLAY_NAME}.
+   * @param extraKeyAliasMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines the
+   *     aliases for the actual key names.
+   */
+  public VirtualKeyButton(
+      @NonNull JSONObject config,
+      @Nullable VirtualKeyButton popup,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyDisplayMap,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap)
+      throws JSONException {
+    String keyFromConfig = getStringFromJson(config, KEY_KEY_NAME);
+    String macroFromConfig = getStringFromJson(config, KEY_MACRO);
+    String[] keys;
+    if (keyFromConfig != null && macroFromConfig != null) {
+      throw new JSONException(
+          "Both key and macro can't be set for the same key. key: \""
+              + keyFromConfig
+              + "\", macro: \""
+              + macroFromConfig
+              + "\"");
+    } else if (keyFromConfig != null) {
+      keys = new String[] {keyFromConfig};
+      this.macro = false;
+    } else if (macroFromConfig != null) {
+      keys = macroFromConfig.split(" ");
+      this.macro = true;
+    } else {
+      throw new JSONException("All keys have to specify either key or macro");
+    }
+
+    for (int i = 0; i < keys.length; i++) {
+      keys[i] = replaceAlias(extraKeyAliasMap, keys[i]);
+    }
+
+    this.key = TextUtils.join(" ", keys);
+
+    String displayFromConfig = getStringFromJson(config, KEY_DISPLAY_NAME);
+    if (displayFromConfig != null) {
+      this.display = displayFromConfig;
+    } else {
+      this.display =
+          Arrays.stream(keys)
+              .map(key -> extraKeyDisplayMap.get(key, key))
+              .collect(Collectors.joining(" "));
+    }
+
+    this.popup = popup;
+  }
+
+  public String getStringFromJson(@NonNull JSONObject config, @NonNull String key) {
+    try {
+      return config.getString(key);
+    } catch (JSONException e) {
+      return null;
+    }
+  }
+
+  /** Replace the alias with its actual key name if found in extraKeyAliasMap. */
+  public static String replaceAlias(
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap, String key) {
+    return extraKeyAliasMap.get(key, key);
+  }
+
+  /** Get {@link #key}. */
+  public String getKey() {
+    return key;
+  }
+
+  /** Check whether a {@link #macro} is defined or not. */
+  public boolean isMacro() {
+    return macro;
+  }
+
+  /** Get {@link #display}. */
+  public String getDisplay() {
+    return display;
+  }
+
+  /** Get {@link #popup}. */
+  @Nullable
+  public VirtualKeyButton getPopup() {
+    return popup;
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyClient.kt b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyClient.kt
new file mode 100755
index 0000000..7421984
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeyClient.kt
@@ -0,0 +1,39 @@
+package com.sparkleseditor.components.virtualkeys
+
+import android.view.View
+import android.widget.Button
+import com.termux.terminal.TerminalSession
+
+class VirtualKeyClient(val session: TerminalSession) : VirtualKeysView.IVirtualKeysView {
+  override fun onVirtualKeyButtonClick(
+    view: View?,
+    buttonInfo: VirtualKeyButton?,
+    button: Button?,
+  ) {
+    val key = buttonInfo?.key
+    if (key.isNullOrEmpty()) {
+      return
+    }
+    when (key) {
+      "ESC" -> session.write("\u001B") // ESC
+      "TAB" -> session.write("\u0009") // TAB
+      "HOME" -> session.write("\u001B[H") // HOME
+      "UP" -> session.write("\u001B[A") // UP Arrow (ANSI escape code)
+      "DOWN" -> session.write("\u001B[B") // DOWN Arrow (ANSI escape code)
+      "LEFT" -> session.write("\u001B[D") // LEFT Arrow (ANSI escape code)
+      "RIGHT" -> session.write("\u001B[C") // RIGHT Arrow (ANSI escape code)
+      "PGUP" -> session.write("\u001B[5~") // Page Up (ANSI escape code)
+      "PGDN" -> session.write("\u001B[6~") // Page Down (ANSI escape code)
+      "END" -> session.write("\u001B[4~") // End (ANSI escape code, may vary)
+      else -> session.write(buttonInfo.key)
+    }
+  }
+
+  override fun performVirtualKeyButtonHapticFeedback(
+    view: View?,
+    buttonInfo: VirtualKeyButton?,
+    button: Button?,
+  ): Boolean {
+    return false
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysConstants.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysConstants.java
new file mode 100755
index 0000000..d648e0d
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysConstants.java
@@ -0,0 +1,246 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import android.view.KeyEvent;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class VirtualKeysConstants {
+
+  /** Aliases for the keys */
+  public static final VirtualKeyDisplayMap CONTROL_CHARS_ALIASES =
+      new VirtualKeyDisplayMap() {
+        {
+          put("ESCAPE", "ESC");
+          put("CONTROL", "CTRL");
+          put("SHFT", "SHIFT");
+          put("RETURN", "ENTER"); // Technically different keys, but most applications won't see
+          // the
+          // difference
+          put("FUNCTION", "FN");
+          // no alias for ALT
+
+          // Directions are sometimes written as first and last letter for brevety
+          put("LT", "LEFT");
+          put("RT", "RIGHT");
+          put("DN", "DOWN");
+          // put("UP", "UP"); well, "UP" is already two letters
+
+          put("PAGEUP", "PGUP");
+          put("PAGE_UP", "PGUP");
+          put("PAGE UP", "PGUP");
+          put("PAGE-UP", "PGUP");
+
+          // no alias for HOME
+          // no alias for END
+
+          put("PAGEDOWN", "PGDN");
+          put("PAGE_DOWN", "PGDN");
+          put("PAGE-DOWN", "PGDN");
+
+          put("DELETE", "DEL");
+          put("BACKSPACE", "BKSP");
+
+          // easier for writing in termux.properties
+          put("BACKSLASH", "\\");
+          put("QUOTE", "\"");
+          put("APOSTROPHE", "'");
+        }
+      };
+
+  /**
+   * Defines the repetitive keys that can be passed to {@link
+   * VirtualKeysView#setRepetitiveKeys(List)}.
+   */
+  public static List<String> PRIMARY_REPETITIVE_KEYS =
+      Arrays.asList("UP", "DOWN", "LEFT", "RIGHT", "BKSP", "DEL");
+
+  /** Defines the {@link KeyEvent} for common keys. */
+  public static Map<String, Integer> PRIMARY_KEY_CODES_FOR_STRINGS =
+      new HashMap<String, Integer>() {
+        {
+          put("SPACE", KeyEvent.KEYCODE_SPACE);
+          put("ESC", KeyEvent.KEYCODE_ESCAPE);
+          put("TAB", KeyEvent.KEYCODE_TAB);
+          put("HOME", KeyEvent.KEYCODE_MOVE_HOME);
+          put("END", KeyEvent.KEYCODE_MOVE_END);
+          put("PGUP", KeyEvent.KEYCODE_PAGE_UP);
+          put("PGDN", KeyEvent.KEYCODE_PAGE_DOWN);
+          put("INS", KeyEvent.KEYCODE_INSERT);
+          put("DEL", KeyEvent.KEYCODE_FORWARD_DEL);
+          put("BKSP", KeyEvent.KEYCODE_DEL);
+          put("UP", KeyEvent.KEYCODE_DPAD_UP);
+          put("LEFT", KeyEvent.KEYCODE_DPAD_LEFT);
+          put("RIGHT", KeyEvent.KEYCODE_DPAD_RIGHT);
+          put("DOWN", KeyEvent.KEYCODE_DPAD_DOWN);
+          put("ENTER", KeyEvent.KEYCODE_ENTER);
+          put("F1", KeyEvent.KEYCODE_F1);
+          put("F2", KeyEvent.KEYCODE_F2);
+          put("F3", KeyEvent.KEYCODE_F3);
+          put("F4", KeyEvent.KEYCODE_F4);
+          put("F5", KeyEvent.KEYCODE_F5);
+          put("F6", KeyEvent.KEYCODE_F6);
+          put("F7", KeyEvent.KEYCODE_F7);
+          put("F8", KeyEvent.KEYCODE_F8);
+          put("F9", KeyEvent.KEYCODE_F9);
+          put("F10", KeyEvent.KEYCODE_F10);
+          put("F11", KeyEvent.KEYCODE_F11);
+          put("F12", KeyEvent.KEYCODE_F12);
+        }
+      };
+
+  public static class VirtualKeyDisplayMap extends CleverMap<String, String> {}
+
+  /*
+   * Multiple maps are available to quickly change
+   * the style of the keys.
+   */
+
+  public static class EXTRA_KEY_DISPLAY_MAPS {
+    /** Keys are displayed in a natural looking way, like "→" for "RIGHT" */
+    public static final VirtualKeyDisplayMap CLASSIC_ARROWS_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            // classic arrow keys (for ◀ ▶ ▲ ▼ @see arrowVariationDisplay)
+            put("LEFT", "←"); // U+2190 ← LEFTWARDS ARROW
+            put("RIGHT", "→"); // U+2192 → RIGHTWARDS ARROW
+            put("UP", "↑"); // U+2191 ↑ UPWARDS ARROW
+            put("DOWN", "↓"); // U+2193 ↓ DOWNWARDS ARROW
+          }
+        };
+
+    public static final VirtualKeyDisplayMap WELL_KNOWN_CHARACTERS_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            // well known characters // https://en.wikipedia.org/wiki/{Enter_key,
+            // Tab_key,
+            // Delete_key}
+            put("ENTER", "↲"); // U+21B2 ↲ DOWNWARDS ARROW WITH TIP LEFTWARDS
+            put("TAB", "↹"); // U+21B9 ↹ LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO
+            // BAR
+            put("BKSP", "⌫"); // U+232B ⌫ ERASE TO THE LEFT sometimes seen and easy to
+            // understand
+            put("DEL", "⌦"); // U+2326 ⌦ ERASE TO THE RIGHT not well known but easy to
+            // understand
+            put("DRAWER", "☰"); // U+2630 ☰ TRIGRAM FOR HEAVEN not well known but easy to
+            // understand
+            put("KEYBOARD", "⌨"); // U+2328 ⌨ KEYBOARD not well known but easy to understand
+            put("PASTE", "⎘"); // U+2398
+          }
+        };
+
+    public static final VirtualKeyDisplayMap LESS_KNOWN_CHARACTERS_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            // https://en.wikipedia.org/wiki/{Home_key, End_key,
+            // Page_Up_and_Page_Down_keys}
+            // home key can mean "goto the beginning of line" or "goto first page"
+            // depending on
+            // context, hence the diagonal
+            put("HOME", "⇱"); // from IEC 9995 // U+21F1 ⇱ NORTH WEST ARROW TO CORNER
+            put("END", "⇲"); // from IEC 9995 // ⇲ // U+21F2 ⇲ SOUTH EAST ARROW TO CORNER
+            put("PGUP", "⇑"); // no ISO character exists, U+21D1 ⇑ UPWARDS DOUBLE ARROW will
+            // do the trick
+            put("PGDN", "⇓"); // no ISO character exists, U+21D3 ⇓ DOWNWARDS DOUBLE ARROW
+            // will do the trick
+          }
+        };
+
+    public static final VirtualKeyDisplayMap ARROW_TRIANGLE_VARIATION_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            // alternative to classic arrow keys
+            put("LEFT", "◀"); // U+25C0 ◀ BLACK LEFT-POINTING TRIANGLE
+            put("RIGHT", "▶"); // U+25B6 ▶ BLACK RIGHT-POINTING TRIANGLE
+            put("UP", "▲"); // U+25B2 ▲ BLACK UP-POINTING TRIANGLE
+            put("DOWN", "▼"); // U+25BC ▼ BLACK DOWN-POINTING TRIANGLE
+          }
+        };
+
+    public static final VirtualKeyDisplayMap NOT_KNOWN_ISO_CHARACTERS =
+        new VirtualKeyDisplayMap() {
+          {
+            // Control chars that are more clear as text //
+            // https://en.wikipedia.org/wiki/{Function_key, Alt_key, Control_key,
+            // Esc_key}
+            // put("FN", "FN"); // no ISO character exists
+            put("CTRL", "⎈"); // ISO character "U+2388 ⎈ HELM SYMBOL" is unknown to people
+            // and never printed
+            // on computers, however "U+25C7 ◇ WHITE DIAMOND" is a nice presentation,
+            // and
+            // "^" for terminal app and mac is often used
+            put("ALT", "⎇"); // ISO character "U+2387 ⎇ ALTERNATIVE KEY SYMBOL'" is unknown
+            // to people and
+            // only printed as the Option key "⌥" on Mac computer
+            put("ESC", "⎋"); // ISO character "U+238B ⎋ BROKEN CIRCLE WITH NORTHWEST ARROW"
+            // is unknown to
+            // people and not often printed on computers
+          }
+        };
+
+    public static final VirtualKeyDisplayMap NICER_LOOKING_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            // nicer looking for most cases
+            put("-", "―"); // U+2015 ― HORIZONTAL BAR
+          }
+        };
+
+    /** Full Iso */
+    public static final VirtualKeyDisplayMap FULL_ISO_CHAR_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            putAll(CLASSIC_ARROWS_DISPLAY);
+            putAll(WELL_KNOWN_CHARACTERS_DISPLAY);
+            putAll(LESS_KNOWN_CHARACTERS_DISPLAY); // NEW
+            putAll(NICER_LOOKING_DISPLAY);
+            putAll(NOT_KNOWN_ISO_CHARACTERS); // NEW
+          }
+        };
+
+    /** Only arrows */
+    public static final VirtualKeyDisplayMap ARROWS_ONLY_CHAR_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            putAll(CLASSIC_ARROWS_DISPLAY);
+            // putAll(wellKnownCharactersDisplay); // REMOVED
+            // putAll(lessKnownCharactersDisplay); // REMOVED
+            putAll(NICER_LOOKING_DISPLAY);
+          }
+        };
+
+    /** Classic symbols and less known symbols */
+    public static final VirtualKeyDisplayMap LOTS_OF_ARROWS_CHAR_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            putAll(CLASSIC_ARROWS_DISPLAY);
+            putAll(WELL_KNOWN_CHARACTERS_DISPLAY);
+            putAll(LESS_KNOWN_CHARACTERS_DISPLAY); // NEW
+            putAll(NICER_LOOKING_DISPLAY);
+          }
+        };
+
+    /** Some classic symbols everybody knows */
+    public static final VirtualKeyDisplayMap DEFAULT_CHAR_DISPLAY =
+        new VirtualKeyDisplayMap() {
+          {
+            putAll(CLASSIC_ARROWS_DISPLAY);
+            putAll(WELL_KNOWN_CHARACTERS_DISPLAY);
+            putAll(NICER_LOOKING_DISPLAY);
+            // all other characters are displayed as themselves
+          }
+        };
+  }
+
+  /**
+   * HashMap that implements Python dict.get(key, default) function. Default java.util .get(key) is
+   * then the same as .get(key, null);
+   */
+  static class CleverMap<K, V> extends HashMap<K, V> {
+    V get(K key, V defaultValue) {
+      if (containsKey(key)) return get(key);
+      else return defaultValue;
+    }
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysInfo.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysInfo.java
new file mode 100755
index 0000000..b630354
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysInfo.java
@@ -0,0 +1,199 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import android.view.View;
+import android.widget.Button;
+import androidx.annotation.NonNull;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * A {@link Class} that defines the info needed by {@link VirtualKeysView} to display the extra key
+ * views.
+ *
+ * <p>The {@code propertiesInfo} passed to the constructors of this class must be json array of
+ * arrays. Each array element of the json array will be considered a separate row of keys. Each key
+ * can either be simple string that defines the name of the key or a json dict that defines advance
+ * info for the key. The syntax can be `'KEY'` or `{key: 'KEY'}`. For example `HOME` or `{key:
+ * 'HOME', ...}.
+ *
+ * <p>In advance json dict mode, the key can also be a sequence of space separated keys instead of
+ * one key. This can be done by replacing `key` key/value pair of the dict with a `macro` key/value
+ * pair. The syntax is `{macro: 'KEY COMBINATION'}`. For example {macro: 'HOME RIGHT', ...}.
+ *
+ * <p>In advance json dict mode, you can define a nested json dict with the `popup` key which will
+ * be used as the popup key and will be triggered on swipe up. The syntax can be `{key: 'KEY',
+ * popup: 'POPUP_KEY'}` or `{key: 'KEY', popup: {macro: 'KEY COMBINATION', display: 'Key combo'}}`.
+ * For example `{key: 'HOME', popup: {KEY: 'END', ...}, ...}`.
+ *
+ * <p>In advance json dict mode, the key can also have a custom display name that can be used as the
+ * text to display on the button by defining the `display` key. The syntax is `{display:
+ * 'DISPLAY'}`. For example {display: 'Custom name', ...}.
+ *
+ * <p>Examples: {@code # Empty: []
+ *
+ * <p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p>#
+ * Single row: [[ESC, TAB, CTRL, ALT, {key: '-', popup: '|'}, DOWN, UP]]
+ *
+ * <p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p>#
+ * 2 row: [['ESC','/',{key: '-', popup: '|'},'HOME','UP','END','PGUP'],
+ * ['TAB','CTRL','ALT','LEFT','DOWN','RIGHT','PGDN']]
+ *
+ * <p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p>#
+ * Advance: [[ {key: ESC, popup: {macro: "CTRL f d", display: "tmux exit"}}, {key: CTRL, popup:
+ * {macro: "CTRL f BKSP", display: "tmux ←"}}, {key: ALT, popup: {macro: "CTRL f TAB", display:
+ * "tmux →"}}, {key: TAB, popup: {macro: "ALT a", display: A-a}}, {key: LEFT, popup: HOME}, {key:
+ * DOWN, popup: PGDN}, {key: UP, popup: PGUP}, {key: RIGHT, popup: END}, {macro: "ALT j", display:
+ * A-j, popup: {macro: "ALT g", display: A-g}}, {key: KEYBOARD, popup: {macro: "CTRL d", display:
+ * exit}} ]]
+ *
+ * <p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p><p>}
+ *
+ * <p>Aliases are also allowed for the keys that you can pass as {@code extraKeyAliasMap}. Check
+ * {@link VirtualKeysConstants#CONTROL_CHARS_ALIASES}.
+ *
+ * <p>Its up to the {@link VirtualKeysView.IVirtualKeysView} client on how to handle individual key
+ * values of an {@link VirtualKeyButton}. They are sent as is via {@link
+ * VirtualKeysView.IVirtualKeysView#onVirtualKeyButtonClick(View, VirtualKeyButton, Button)}. The
+ * {TerminalVirtualKeys} which is an implementation of the interface, checks if the key is one of
+ * {@link VirtualKeysConstants#PRIMARY_KEY_CODES_FOR_STRINGS} and generates a {@link
+ * android.view.KeyEvent} for it, and if its not, then converts the key to code points by calling
+ * {@link CharSequence#codePoints()} and passes them to the terminal as literal strings.
+ *
+ * <p>Examples: {@code "ENTER" will trigger the ENTER keycode "LEFT" will trigger the LEFT keycode
+ * and be displayed as "←" "→" will input a "→" character "−" will input a "−" character "-_-" will
+ * input the string "-_-" }
+ *
+ * <p>For more info, check https://wiki.termux.com/wiki/Touch_Keyboard.
+ */
+public class VirtualKeysInfo {
+
+  /** Matrix of buttons to be displayed in {@link VirtualKeysView}. */
+  private final VirtualKeyButton[][] mButtons;
+
+  /**
+   * Initialize {@link VirtualKeysInfo}.
+   *
+   * @param propertiesInfo The {@link String} containing the info to create the {@link
+   *     VirtualKeysInfo}. Check the class javadoc for details.
+   * @param style The style to pass to {@link #getCharDisplayMapForStyle(String)} to get the {@link
+   *     VirtualKeysConstants.VirtualKeyDisplayMap} that defines the display text mapping for the
+   *     keys if a custom value is not defined by {@link VirtualKeyButton#KEY_DISPLAY_NAME} for a
+   *     key.
+   * @param extraKeyAliasMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines the
+   *     aliases for the actual key names. You can create your own or optionally pass {@link
+   *     VirtualKeysConstants#CONTROL_CHARS_ALIASES}.
+   */
+  public VirtualKeysInfo(
+      @NonNull String propertiesInfo,
+      String style,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap)
+      throws JSONException {
+    mButtons =
+        initVirtualKeysInfo(propertiesInfo, getCharDisplayMapForStyle(style), extraKeyAliasMap);
+  }
+
+  private VirtualKeyButton[][] initVirtualKeysInfo(
+      @NonNull String propertiesInfo,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyDisplayMap,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap)
+      throws JSONException {
+    // Convert String propertiesInfo to Array of Arrays
+    JSONArray arr = new JSONArray(propertiesInfo);
+    Object[][] matrix = new Object[arr.length()][];
+    for (int i = 0; i < arr.length(); i++) {
+      JSONArray line = arr.getJSONArray(i);
+      matrix[i] = new Object[line.length()];
+      for (int j = 0; j < line.length(); j++) {
+        matrix[i][j] = line.get(j);
+      }
+    }
+
+    // convert matrix to buttons
+    VirtualKeyButton[][] buttons = new VirtualKeyButton[matrix.length][];
+    for (int i = 0; i < matrix.length; i++) {
+      buttons[i] = new VirtualKeyButton[matrix[i].length];
+      for (int j = 0; j < matrix[i].length; j++) {
+        Object key = matrix[i][j];
+
+        JSONObject jobject = normalizeKeyConfig(key);
+
+        VirtualKeyButton button;
+
+        if (!jobject.has(VirtualKeyButton.KEY_POPUP)) {
+          // no popup
+          button = new VirtualKeyButton(jobject, extraKeyDisplayMap, extraKeyAliasMap);
+        } else {
+          // a popup
+          JSONObject popupJobject = normalizeKeyConfig(jobject.get(VirtualKeyButton.KEY_POPUP));
+          VirtualKeyButton popup =
+              new VirtualKeyButton(popupJobject, extraKeyDisplayMap, extraKeyAliasMap);
+          button = new VirtualKeyButton(jobject, popup, extraKeyDisplayMap, extraKeyAliasMap);
+        }
+
+        buttons[i][j] = button;
+      }
+    }
+
+    return buttons;
+  }
+
+  /**
+   * Convert "value" -> {"key": "value"}. Required by {@link
+   * VirtualKeyButton#VirtualKeyButton(JSONObject, VirtualKeyButton,
+   * VirtualKeysConstants.VirtualKeyDisplayMap, VirtualKeysConstants.VirtualKeyDisplayMap)}.
+   */
+  private static JSONObject normalizeKeyConfig(Object key) throws JSONException {
+    JSONObject jobject;
+    if (key instanceof String) {
+      jobject = new JSONObject();
+      jobject.put(VirtualKeyButton.KEY_KEY_NAME, key);
+    } else if (key instanceof JSONObject) {
+      jobject = (JSONObject) key;
+    } else {
+      throw new JSONException("An key in the extra-key matrix must be a string or an object");
+    }
+    return jobject;
+  }
+
+  @NonNull
+  public static VirtualKeysConstants.VirtualKeyDisplayMap getCharDisplayMapForStyle(String style) {
+    switch (style) {
+      case "arrows-only":
+        return VirtualKeysConstants.EXTRA_KEY_DISPLAY_MAPS.ARROWS_ONLY_CHAR_DISPLAY;
+      case "arrows-all":
+        return VirtualKeysConstants.EXTRA_KEY_DISPLAY_MAPS.LOTS_OF_ARROWS_CHAR_DISPLAY;
+      case "all":
+        return VirtualKeysConstants.EXTRA_KEY_DISPLAY_MAPS.FULL_ISO_CHAR_DISPLAY;
+      case "none":
+        return new VirtualKeysConstants.VirtualKeyDisplayMap();
+      default:
+        return VirtualKeysConstants.EXTRA_KEY_DISPLAY_MAPS.DEFAULT_CHAR_DISPLAY;
+    }
+  }
+
+  /**
+   * Initialize {@link VirtualKeysInfo}.
+   *
+   * @param propertiesInfo The {@link String} containing the info to create the {@link
+   *     VirtualKeysInfo}. Check the class javadoc for details.
+   * @param extraKeyDisplayMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines
+   *     the display text mapping for the keys if a custom value is not defined by {@link
+   *     VirtualKeyButton#KEY_DISPLAY_NAME} for a key. You can create your own or optionally pass
+   *     one of the values defined in {@link #getCharDisplayMapForStyle(String)}.
+   * @param extraKeyAliasMap The {@link VirtualKeysConstants.VirtualKeyDisplayMap} that defines the
+   *     aliases for the actual key names. You can create your own or optionally pass {@link
+   *     VirtualKeysConstants#CONTROL_CHARS_ALIASES}.
+   */
+  public VirtualKeysInfo(
+      @NonNull String propertiesInfo,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyDisplayMap,
+      @NonNull VirtualKeysConstants.VirtualKeyDisplayMap extraKeyAliasMap)
+      throws JSONException {
+    mButtons = initVirtualKeysInfo(propertiesInfo, extraKeyDisplayMap, extraKeyAliasMap);
+  }
+
+  public VirtualKeyButton[][] getMatrix() {
+    return mButtons;
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysListener.kt b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysListener.kt
new file mode 100755
index 0000000..09bfb00
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysListener.kt
@@ -0,0 +1,42 @@
+package com.sparkleseditor.components.virtualkeys
+
+import android.view.View
+import android.widget.Button
+import com.termux.terminal.TerminalSession
+
+class VirtualKeysListener(val session: TerminalSession) : VirtualKeysView.IVirtualKeysView {
+
+  override fun onVirtualKeyButtonClick(
+    view: View?,
+    buttonInfo: VirtualKeyButton?,
+    button: Button?,
+  ) {
+
+    val key = buttonInfo?.key ?: return
+    val writeable: String =
+      when (key) {
+        "UP" -> "\u001B[A" // Escape sequence for Up Arrow
+        "DOWN" -> "\u001B[B" // Escape sequence for Down Arrow
+        "LEFT" -> "\u001B[D" // Escape sequence for Left Arrow
+        "RIGHT" -> "\u001B[C" // Escape sequence for Right Arrow
+        "ENTER" -> "\u000D" // Carriage Return for Enter
+        "PGUP" -> "\u001B[5~" // Escape sequence for Page Up
+        "PGDN" -> "\u001B[6~" // Escape sequence for Page Down
+        "TAB" -> "\u0009" // Horizontal Tab
+        "HOME" -> "\u001B[H" // Escape sequence for Home
+        "END" -> "\u001B[F" // Escape sequence for End
+        "ESC" -> "\u001B" // Escape
+        else -> key
+      }
+
+    session.write(writeable)
+  }
+
+  override fun performVirtualKeyButtonHapticFeedback(
+    view: View?,
+    buttonInfo: VirtualKeyButton?,
+    button: Button?,
+  ): Boolean {
+    return false
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysView.java b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysView.java
new file mode 100755
index 0000000..7e66372
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/components/virtualkeys/VirtualKeysView.java
@@ -0,0 +1,667 @@
+package com.sparkleseditor.components.virtualkeys;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.Settings;
+import android.util.AttributeSet;
+import android.view.HapticFeedbackConstants;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.GridLayout;
+import android.widget.PopupWindow;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * A {@link View} showing extra keys (such as Escape, Ctrl, Alt) not normally available on an Android soft
+ * keyboards.
+ *
+ * To use it, add following to a layout file and import it in your activity layout file or inflate
+ * it with a {@link androidx.viewpager.widget.ViewPager}.:
+ * {@code
+ * <?xml version="1.0" encoding="utf-8"?>
+ * <com.termux.shared.terminal.io.extrakeys.VirtualKeysView xmlns:android="http://schemas.android.com/apk/res/android"
+ *     android:id="@+id/extra_keys"
+ *     style="?android:attr/buttonBarStyle"
+ *     android:layout_width="match_parent"
+ *     android:layout_height="match_parent"
+ *     android:layout_alignParentBottom="true"
+ *     android:orientation="horizontal" />
+ * }
+ *
+ * Then in your activity, get its reference by a call to {@link android.app.Activity#findViewById(int)}
+ * or {@link LayoutInflater#inflate(int, ViewGroup)} if using {@link androidx.viewpager.widget.ViewPager}.
+ * Then call {@link #setVirtualKeysViewClient(IVirtualKeysView)} and pass it the implementation of
+ * {@link IVirtualKeysView} so that you can receive callbacks. You can also override other values set
+ * in {@link VirtualKeysView#VirtualKeysView(Context, AttributeSet)} by calling the respective functions.
+ * If you extend {@link VirtualKeysView}, you can also set them in the constructor, but do call super().
+ *
+ * After this you will have to make a call to {@link VirtualKeysView#reload(VirtualKeysInfo) and pass
+ * it the {@link VirtualKeysInfo} to load and display the extra keys. Read its class javadocs for more
+ * info on how to create it.
+ *
+ * Termux app defines the view in res/layout/view_terminal_toolbar_extra_keys and
+ * inflates it in TerminalToolbarViewPager.instantiateItem() and sets the {@link VirtualKeysView} client
+ * and calls {@link VirtualKeysView#reload(VirtualKeysInfo).
+ * The {@link VirtualKeysInfo} is created by TermuxAppSharedProperties.setVirtualKeys().
+ * Then its got and the view height is adjusted in TermuxActivity.setTerminalToolbarHeight().
+ * The client used is TermuxTerminalVirtualKeys, which extends
+ * {TerminalVirtualKeys} to handle Termux app specific logic and
+ * leave the rest to the super class.
+ */
+public final class VirtualKeysView extends GridLayout {
+
+  /** Defines the default value for {@link #mButtonTextColor}. */
+  public static final int DEFAULT_BUTTON_TEXT_COLOR = 0xFFFFFFFF;
+
+  /** Defines the default value for {@link #mButtonActiveTextColor}. */
+  public static final int DEFAULT_BUTTON_ACTIVE_TEXT_COLOR = 0xFFf44336;
+
+  /** Defines the default value for {@link #mButtonBackgroundColor}. */
+  public static final int DEFAULT_BUTTON_BACKGROUND_COLOR = 0x00000000;
+
+  /** Defines the default value for {@link #mButtonActiveBackgroundColor}. */
+  public static final int DEFAULT_BUTTON_ACTIVE_BACKGROUND_COLOR = 0xFF7F7F7F;
+
+  /** Defines the minimum allowed duration in milliseconds for {@link #mLongPressTimeout}. */
+  public static final int MIN_LONG_PRESS_DURATION = 200;
+
+  /** Defines the maximum allowed duration in milliseconds for {@link #mLongPressTimeout}. */
+  public static final int MAX_LONG_PRESS_DURATION = 3000;
+
+  /** Defines the fallback duration in milliseconds for {@link #mLongPressTimeout}. */
+  public static final int FALLBACK_LONG_PRESS_DURATION = 400;
+
+  /** Defines the minimum allowed duration in milliseconds for {@link #mLongPressRepeatDelay}. */
+  public static final int MIN_LONG_PRESS__REPEAT_DELAY = 5;
+
+  /** Defines the maximum allowed duration in milliseconds for {@link #mLongPressRepeatDelay}. */
+  public static final int MAX_LONG_PRESS__REPEAT_DELAY = 2000;
+
+  /** Defines the default duration in milliseconds for {@link #mLongPressRepeatDelay}. */
+  public static final int DEFAULT_LONG_PRESS_REPEAT_DELAY = 80;
+
+  /**
+   * The implementation of the {@link IVirtualKeysView} that acts as a client for the {@link
+   * VirtualKeysView}.
+   */
+  private IVirtualKeysView mVirtualKeysViewClient;
+
+  /**
+   * The map for the {@link SpecialButton} and their {@link SpecialButtonState}. Defaults to the one
+   * returned by {@link #getDefaultSpecialButtons(VirtualKeysView)}.
+   */
+  private Map<SpecialButton, SpecialButtonState> mSpecialButtons;
+
+  /**
+   * The keys for the {@link SpecialButton} added to {@link #mSpecialButtons}. This is automatically
+   * set when the call to {@link #setSpecialButtons(Map)} is made.
+   */
+  private Set<String> mSpecialButtonsKeys;
+
+  /**
+   * The list of keys for which auto repeat of key should be triggered if its extra keys button is
+   * long pressed. This is done by calling {@link IVirtualKeysView#onVirtualKeyButtonClick(View,
+   * VirtualKeyButton, Button)} every {@link #mLongPressRepeatDelay} seconds after {@link
+   * #mLongPressTimeout} has passed. The default keys are defined by {@link
+   * VirtualKeysConstants#PRIMARY_REPETITIVE_KEYS}.
+   */
+  private List<String> mRepetitiveKeys;
+
+  /** The text color for the extra keys button. Defaults to {@link #DEFAULT_BUTTON_TEXT_COLOR}. */
+  private int mButtonTextColor;
+
+  /**
+   * The text color for the extra keys button when its active. Defaults to {@link
+   * #DEFAULT_BUTTON_ACTIVE_TEXT_COLOR}.
+   */
+  private int mButtonActiveTextColor;
+
+  /**
+   * The background color for the extra keys button. Defaults to {@link
+   * #DEFAULT_BUTTON_BACKGROUND_COLOR}.
+   */
+  private int mButtonBackgroundColor;
+
+  /**
+   * The background color for the extra keys button when its active. Defaults to {@link
+   * #DEFAULT_BUTTON_ACTIVE_BACKGROUND_COLOR}.
+   */
+  private int mButtonActiveBackgroundColor;
+
+  /** Defines whether text for the extra keys button should be all capitalized automatically. */
+  private boolean mButtonTextAllCaps = true;
+
+  /**
+   * Defines the duration in milliseconds before a press turns into a long press. The default
+   * duration used is the one returned by a call to {@link ViewConfiguration#getLongPressTimeout()}
+   * which will return the system defined duration which can be changed in accessibility settings.
+   * The duration must be in between {@link #MIN_LONG_PRESS_DURATION} and {@link
+   * #MAX_LONG_PRESS_DURATION}, otherwise {@link #FALLBACK_LONG_PRESS_DURATION} is used.
+   */
+  private int mLongPressTimeout;
+
+  /**
+   * Defines the duration in milliseconds for the delay between trigger of each repeat of {@link
+   * #mRepetitiveKeys}. The default value is defined by {@link #DEFAULT_LONG_PRESS_REPEAT_DELAY}.
+   * The duration must be in between {@link #MIN_LONG_PRESS__REPEAT_DELAY} and {@link
+   * #MAX_LONG_PRESS__REPEAT_DELAY}, otherwise {@link #DEFAULT_LONG_PRESS_REPEAT_DELAY} is used.
+   */
+  private int mLongPressRepeatDelay;
+
+  /**
+   * The popup window shown if {@link VirtualKeyButton#getPopup()} returns a {@code non-null} value
+   * and a swipe up action is done on an extra key.
+   */
+  private PopupWindow mPopupWindow;
+
+  private ScheduledExecutorService mScheduledExecutor;
+  private Handler mHandler;
+  private SpecialButtonsLongHoldRunnable mSpecialButtonsLongHoldRunnable;
+  private int mLongPressCount;
+
+  public VirtualKeysView(Context context, AttributeSet attrs) {
+    super(context, attrs);
+
+    setRepetitiveKeys(VirtualKeysConstants.PRIMARY_REPETITIVE_KEYS);
+    setSpecialButtons(getDefaultSpecialButtons(this));
+    setButtonColors(
+        DEFAULT_BUTTON_TEXT_COLOR,
+        DEFAULT_BUTTON_ACTIVE_TEXT_COLOR,
+        DEFAULT_BUTTON_BACKGROUND_COLOR,
+        DEFAULT_BUTTON_ACTIVE_BACKGROUND_COLOR);
+    setLongPressTimeout(ViewConfiguration.getLongPressTimeout());
+    setLongPressRepeatDelay(DEFAULT_LONG_PRESS_REPEAT_DELAY);
+  }
+
+  /**
+   * Set the {@link VirtualKeysView} button colors.
+   *
+   * @param buttonTextColor The value for {@link #mButtonTextColor}.
+   * @param buttonActiveTextColor The value for {@link #mButtonActiveTextColor}.
+   * @param buttonBackgroundColor The value for {@link #mButtonBackgroundColor}.
+   * @param buttonActiveBackgroundColor The value for {@link #mButtonActiveBackgroundColor}.
+   */
+  public void setButtonColors(
+      int buttonTextColor,
+      int buttonActiveTextColor,
+      int buttonBackgroundColor,
+      int buttonActiveBackgroundColor) {
+    mButtonTextColor = buttonTextColor;
+    mButtonActiveTextColor = buttonActiveTextColor;
+    mButtonBackgroundColor = buttonBackgroundColor;
+    mButtonActiveBackgroundColor = buttonActiveBackgroundColor;
+  }
+
+  /** Get the default map that can be used for {@link #mSpecialButtons}. */
+  @NonNull
+  public Map<SpecialButton, SpecialButtonState> getDefaultSpecialButtons(
+      VirtualKeysView extraKeysView) {
+    return new HashMap<SpecialButton, SpecialButtonState>() {
+      {
+        put(SpecialButton.CTRL, new SpecialButtonState(extraKeysView));
+        put(SpecialButton.ALT, new SpecialButtonState(extraKeysView));
+        put(SpecialButton.SHIFT, new SpecialButtonState(extraKeysView));
+        put(SpecialButton.FN, new SpecialButtonState(extraKeysView));
+      }
+    };
+  }
+
+  /** Get {@link #mVirtualKeysViewClient}. */
+  public IVirtualKeysView getVirtualKeysViewClient() {
+    return mVirtualKeysViewClient;
+  }
+
+  /** Set {@link #mVirtualKeysViewClient}. */
+  public void setVirtualKeysViewClient(IVirtualKeysView extraKeysViewClient) {
+    mVirtualKeysViewClient = extraKeysViewClient;
+  }
+
+  /** Get {@link #mRepetitiveKeys}. */
+  public List<String> getRepetitiveKeys() {
+    if (mRepetitiveKeys == null) return null;
+    return mRepetitiveKeys.stream().map(String::new).collect(Collectors.toList());
+  }
+
+  /** Set {@link #mRepetitiveKeys}. Must not be {@code null}. */
+  public void setRepetitiveKeys(@NonNull List<String> repetitiveKeys) {
+    mRepetitiveKeys = repetitiveKeys;
+  }
+
+  /** Get {@link #mSpecialButtons}. */
+  public Map<SpecialButton, SpecialButtonState> getSpecialButtons() {
+    if (mSpecialButtons == null) return null;
+    return mSpecialButtons.entrySet().stream()
+        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+  }
+
+  /** Set {@link #mSpecialButtonsKeys}. Must not be {@code null}. */
+  public void setSpecialButtons(@NonNull Map<SpecialButton, SpecialButtonState> specialButtons) {
+    mSpecialButtons = specialButtons;
+    mSpecialButtonsKeys =
+        this.mSpecialButtons.keySet().stream()
+            .map(SpecialButton::getKey)
+            .collect(Collectors.toSet());
+  }
+
+  /** Get {@link #mSpecialButtonsKeys}. */
+  public Set<String> getSpecialButtonsKeys() {
+    if (mSpecialButtonsKeys == null) return null;
+    return mSpecialButtonsKeys.stream().map(String::new).collect(Collectors.toSet());
+  }
+
+  /** Get {@link #mButtonTextColor}. */
+  public int getButtonTextColor() {
+    return mButtonTextColor;
+  }
+
+  /** Set {@link #mButtonTextColor}. */
+  public void setButtonTextColor(int buttonTextColor) {
+    mButtonTextColor = buttonTextColor;
+  }
+
+  /** Get {@link #mButtonActiveTextColor}. */
+  public int getButtonActiveTextColor() {
+    return mButtonActiveTextColor;
+  }
+
+  /** Set {@link #mButtonActiveTextColor}. */
+  public void setButtonActiveTextColor(int buttonActiveTextColor) {
+    mButtonActiveTextColor = buttonActiveTextColor;
+  }
+
+  /** Get {@link #mButtonBackgroundColor}. */
+  public int getButtonBackgroundColor() {
+    return mButtonBackgroundColor;
+  }
+
+  /** Set {@link #mButtonBackgroundColor}. */
+  public void setButtonBackgroundColor(int buttonBackgroundColor) {
+    mButtonBackgroundColor = buttonBackgroundColor;
+  }
+
+  /** Get {@link #mButtonActiveBackgroundColor}. */
+  public int getButtonActiveBackgroundColor() {
+    return mButtonActiveBackgroundColor;
+  }
+
+  /** Set {@link #mButtonActiveBackgroundColor}. */
+  public void setButtonActiveBackgroundColor(int buttonActiveBackgroundColor) {
+    mButtonActiveBackgroundColor = buttonActiveBackgroundColor;
+  }
+
+  /** Set {@link #mButtonTextAllCaps}. */
+  public void setButtonTextAllCaps(boolean buttonTextAllCaps) {
+    mButtonTextAllCaps = buttonTextAllCaps;
+  }
+
+  /** Get {@link #mLongPressTimeout}. */
+  public int getLongPressTimeout() {
+    return mLongPressTimeout;
+  }
+
+  /** Set {@link #mLongPressTimeout}. */
+  public void setLongPressTimeout(int longPressDuration) {
+    if (longPressDuration >= MIN_LONG_PRESS_DURATION
+        && longPressDuration <= MAX_LONG_PRESS_DURATION) {
+      mLongPressTimeout = longPressDuration;
+    } else {
+      mLongPressTimeout = FALLBACK_LONG_PRESS_DURATION;
+    }
+  }
+
+  /** Get {@link #mLongPressRepeatDelay}. */
+  public int getLongPressRepeatDelay() {
+    return mLongPressRepeatDelay;
+  }
+
+  /** Set {@link #mLongPressRepeatDelay}. */
+  public void setLongPressRepeatDelay(int longPressRepeatDelay) {
+    if (mLongPressRepeatDelay >= MIN_LONG_PRESS__REPEAT_DELAY
+        && mLongPressRepeatDelay <= MAX_LONG_PRESS__REPEAT_DELAY) {
+      mLongPressRepeatDelay = longPressRepeatDelay;
+    } else {
+      mLongPressRepeatDelay = DEFAULT_LONG_PRESS_REPEAT_DELAY;
+    }
+  }
+
+  /**
+   * Reload this instance of {@link VirtualKeysView} with the info passed in {@code extraKeysInfo}.
+   *
+   * @param extraKeysInfo The {@link VirtualKeysInfo} that defines the necessary info for the extra
+   *     keys.
+   */
+  @SuppressLint("ClickableViewAccessibility")
+  public void reload(VirtualKeysInfo extraKeysInfo) {
+    if (extraKeysInfo == null) return;
+
+    for (SpecialButtonState state : mSpecialButtons.values()) state.buttons = new ArrayList<>();
+
+    removeAllViews();
+
+    VirtualKeyButton[][] buttons = extraKeysInfo.getMatrix();
+
+    setRowCount(buttons.length);
+    setColumnCount(maximumLength(buttons));
+
+    for (int row = 0; row < buttons.length; row++) {
+      for (int col = 0; col < buttons[row].length; col++) {
+        final VirtualKeyButton buttonInfo = buttons[row][col];
+
+        Button button;
+        if (isSpecialButton(buttonInfo)) {
+          button = createSpecialButton(buttonInfo.getKey(), true);
+          if (button == null) return;
+        } else {
+          button = new Button(getContext(), null, android.R.attr.buttonBarButtonStyle);
+        }
+
+        button.setText(buttonInfo.getDisplay());
+        button.setTextColor(mButtonTextColor);
+        button.setAllCaps(mButtonTextAllCaps);
+        button.setPadding(0, 0, 0, 0);
+
+        button.setOnClickListener(
+            view -> {
+              performVirtualKeyButtonHapticFeedback(view, buttonInfo, button);
+              onAnyVirtualKeyButtonClick(view, buttonInfo, button);
+            });
+
+        button.setOnTouchListener(
+            (view, event) -> {
+              switch (event.getAction()) {
+                case MotionEvent.ACTION_DOWN:
+                  view.setBackgroundColor(mButtonActiveBackgroundColor);
+                  // Start long press scheduled executors which will be stopped in
+                  // next MotionEvent
+                  startScheduledExecutors(view, buttonInfo, button);
+                  return true;
+
+                case MotionEvent.ACTION_MOVE:
+                  if (buttonInfo.getPopup() != null) {
+                    // Show popup on swipe up
+                    if (mPopupWindow == null && event.getY() < 0) {
+                      stopScheduledExecutors();
+                      view.setBackgroundColor(mButtonBackgroundColor);
+                      showPopup(view, buttonInfo.getPopup());
+                    }
+                    if (mPopupWindow != null && event.getY() > 0) {
+                      view.setBackgroundColor(mButtonActiveBackgroundColor);
+                      dismissPopup();
+                    }
+                  }
+                  return true;
+
+                case MotionEvent.ACTION_CANCEL:
+                  view.setBackgroundColor(mButtonBackgroundColor);
+                  stopScheduledExecutors();
+                  return true;
+
+                case MotionEvent.ACTION_UP:
+                  view.setBackgroundColor(mButtonBackgroundColor);
+                  stopScheduledExecutors();
+                  // If ACTION_UP up was not from a repetitive key or was with a
+                  // key with a popup
+                  // button
+                  if (mLongPressCount == 0 || mPopupWindow != null) {
+                    // Trigger popup button click if swipe up complete
+                    if (mPopupWindow != null) {
+                      dismissPopup();
+                      if (buttonInfo.getPopup() != null) {
+                        onAnyVirtualKeyButtonClick(view, buttonInfo.getPopup(), button);
+                      }
+                    } else {
+                      view.performClick();
+                    }
+                  }
+                  return true;
+
+                default:
+                  return true;
+              }
+            });
+
+        LayoutParams param = new GridLayout.LayoutParams();
+        param.width = 0;
+        param.height = 0;
+        param.setMargins(0, 0, 0, 0);
+        param.columnSpec = GridLayout.spec(col, GridLayout.FILL, 1.f);
+        param.rowSpec = GridLayout.spec(row, GridLayout.FILL, 1.f);
+        button.setLayoutParams(param);
+
+        addView(button);
+      }
+    }
+  }
+
+  private void performVirtualKeyButtonHapticFeedback(
+      View view, VirtualKeyButton buttonInfo, Button button) {
+    if (mVirtualKeysViewClient != null) {
+      // If client handled the feedback, then just return
+      if (mVirtualKeysViewClient.performVirtualKeyButtonHapticFeedback(view, buttonInfo, button))
+        return;
+    }
+
+    if (Settings.System.getInt(
+            getContext().getContentResolver(), Settings.System.HAPTIC_FEEDBACK_ENABLED, 0)
+        != 0) {
+
+      if (Build.VERSION.SDK_INT >= 28) {
+        button.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP);
+      } else {
+        // Perform haptic feedback only if no total silence mode enabled.
+        if (Settings.Global.getInt(getContext().getContentResolver(), "zen_mode", 0) != 2) {
+          button.performHapticFeedback(HapticFeedbackConstants.KEYBOARD_TAP);
+        }
+      }
+    }
+  }
+
+  private void onAnyVirtualKeyButtonClick(
+      View view, @NonNull VirtualKeyButton buttonInfo, Button button) {
+    if (isSpecialButton(buttonInfo)) {
+      if (mLongPressCount > 0) return;
+      SpecialButtonState state = mSpecialButtons.get(SpecialButton.valueOf(buttonInfo.getKey()));
+      if (state == null) return;
+
+      // Toggle active state and disable lock state if new state is not active
+      state.setIsActive(!state.isActive);
+      if (!state.isActive) state.setIsLocked(false);
+    } else {
+      onVirtualKeyButtonClick(view, buttonInfo, button);
+    }
+  }
+
+  private void onVirtualKeyButtonClick(View view, VirtualKeyButton buttonInfo, Button button) {
+    if (mVirtualKeysViewClient != null)
+      mVirtualKeysViewClient.onVirtualKeyButtonClick(view, buttonInfo, button);
+  }
+
+  private void startScheduledExecutors(View view, VirtualKeyButton buttonInfo, Button button) {
+    stopScheduledExecutors();
+    mLongPressCount = 0;
+    if (mRepetitiveKeys.contains(buttonInfo.getKey())) {
+      // Auto repeat key if long pressed until ACTION_UP stops it by calling
+      // stopScheduledExecutors.
+      // Currently, only one (last) repeat key can run at a time. Old ones are stopped.
+      mScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
+      mScheduledExecutor.scheduleWithFixedDelay(
+          () -> {
+            mLongPressCount++;
+            onVirtualKeyButtonClick(view, buttonInfo, button);
+          },
+          mLongPressTimeout,
+          mLongPressRepeatDelay,
+          TimeUnit.MILLISECONDS);
+    } else if (isSpecialButton(buttonInfo)) {
+      // Lock the key if long pressed by running mSpecialButtonsLongHoldRunnable after
+      // waiting for mLongPressTimeout milliseconds. If user does not long press, then the
+      // ACTION_UP triggered will cancel the runnable by calling stopScheduledExecutors before
+      // it has a chance to run.
+      SpecialButtonState state = mSpecialButtons.get(SpecialButton.valueOf(buttonInfo.getKey()));
+      if (state == null) return;
+      if (mHandler == null) mHandler = new Handler(Looper.getMainLooper());
+      mSpecialButtonsLongHoldRunnable = new SpecialButtonsLongHoldRunnable(state);
+      mHandler.postDelayed(mSpecialButtonsLongHoldRunnable, mLongPressTimeout);
+    }
+  }
+
+  private void stopScheduledExecutors() {
+    if (mScheduledExecutor != null) {
+      mScheduledExecutor.shutdownNow();
+      mScheduledExecutor = null;
+    }
+
+    if (mSpecialButtonsLongHoldRunnable != null && mHandler != null) {
+      mHandler.removeCallbacks(mSpecialButtonsLongHoldRunnable);
+      mSpecialButtonsLongHoldRunnable = null;
+    }
+  }
+
+  void showPopup(View view, VirtualKeyButton extraButton) {
+    int width = view.getMeasuredWidth();
+    int height = view.getMeasuredHeight();
+    Button button;
+    if (isSpecialButton(extraButton)) {
+      button = createSpecialButton(extraButton.getKey(), false);
+      if (button == null) return;
+    } else {
+      button = new Button(getContext(), null, android.R.attr.buttonBarButtonStyle);
+      button.setTextColor(mButtonTextColor);
+    }
+    button.setText(extraButton.getDisplay());
+    button.setAllCaps(mButtonTextAllCaps);
+    button.setPadding(0, 0, 0, 0);
+    button.setMinHeight(0);
+    button.setMinWidth(0);
+    button.setMinimumWidth(0);
+    button.setMinimumHeight(0);
+    button.setWidth(width);
+    button.setHeight(height);
+    button.setBackgroundColor(mButtonActiveBackgroundColor);
+    mPopupWindow = new PopupWindow(this);
+    mPopupWindow.setWidth(LayoutParams.WRAP_CONTENT);
+    mPopupWindow.setHeight(LayoutParams.WRAP_CONTENT);
+    mPopupWindow.setContentView(button);
+    mPopupWindow.setOutsideTouchable(true);
+    mPopupWindow.setFocusable(false);
+    mPopupWindow.showAsDropDown(view, 0, -2 * height);
+  }
+
+  private void dismissPopup() {
+    mPopupWindow.setContentView(null);
+    mPopupWindow.dismiss();
+    mPopupWindow = null;
+  }
+
+  /** Check whether a {@link VirtualKeyButton} is a {@link SpecialButton}. */
+  public boolean isSpecialButton(VirtualKeyButton button) {
+    return mSpecialButtonsKeys.contains(button.getKey());
+  }
+
+  private Button createSpecialButton(String buttonKey, boolean needUpdate) {
+    SpecialButtonState state = mSpecialButtons.get(SpecialButton.valueOf(buttonKey));
+    if (state == null) return null;
+    state.setIsCreated(true);
+    Button button = new Button(getContext(), null, android.R.attr.buttonBarButtonStyle);
+    button.setTextColor(state.isActive ? mButtonActiveTextColor : mButtonTextColor);
+    if (needUpdate) {
+      state.buttons.add(button);
+    }
+    return button;
+  }
+
+  /** General util function to compute the longest column length in a matrix. */
+  static int maximumLength(Object[][] matrix) {
+    int m = 0;
+    for (Object[] row : matrix) m = Math.max(m, row.length);
+    return m;
+  }
+
+  /**
+   * Read whether {@link SpecialButton} registered in {@link #mSpecialButtons} is active or not.
+   *
+   * @param specialButton The {@link SpecialButton} to read.
+   * @param autoSetInActive Set to {@code true} if {@link SpecialButtonState#isActive} should be set
+   *     {@code false} if button is not locked.
+   * @return Returns {@code null} if button does not exist in {@link #mSpecialButtons}. If button
+   *     exists, then returns {@code true} if the button is created in {@link VirtualKeysView} and
+   *     is active, otherwise {@code false}.
+   */
+  @Nullable
+  public Boolean readSpecialButton(SpecialButton specialButton, boolean autoSetInActive) {
+    SpecialButtonState state = mSpecialButtons.get(specialButton);
+    if (state == null) return null;
+
+    if (!state.isCreated || !state.isActive) return false;
+
+    // Disable active state only if not locked
+    if (autoSetInActive && !state.isLocked) state.setIsActive(false);
+
+    return true;
+  }
+
+  private class SpecialButtonsLongHoldRunnable implements Runnable {
+    private final SpecialButtonState mState;
+
+    public SpecialButtonsLongHoldRunnable(SpecialButtonState state) {
+      mState = state;
+    }
+
+    public void run() {
+      // Toggle active and lock state
+      mState.setIsLocked(!mState.isActive);
+      mState.setIsActive(!mState.isActive);
+      mLongPressCount++;
+    }
+  }
+
+  /** The client for the {@link VirtualKeysView}. */
+  public interface IVirtualKeysView {
+
+    /**
+     * This is called by {@link VirtualKeysView} when a button is clicked. This is also called for
+     * {@link #mRepetitiveKeys} and {@link VirtualKeyButton} that have a popup set. However, this is
+     * not called for {@link #mSpecialButtons}, whose state can instead be read via a call to {@link
+     * #readSpecialButton(SpecialButton, boolean)}.
+     *
+     * @param view The view that was clicked.
+     * @param buttonInfo The {@link VirtualKeyButton} for the button that was clicked. The button
+     *     may be a {@link VirtualKeyButton#KEY_MACRO} set which can be checked with a call to
+     *     {@link VirtualKeyButton#isMacro()}.
+     * @param button The {@link Button} that was clicked.
+     */
+    void onVirtualKeyButtonClick(View view, VirtualKeyButton buttonInfo, Button button);
+
+    /**
+     * This is called by {@link VirtualKeysView} when a button is clicked so that the client can
+     * perform any hepatic feedback. This is only called in the {@link Button.OnClickListener} and
+     * not for every repeat. Its also called for {@link #mSpecialButtons}.
+     *
+     * @param view The view that was clicked.
+     * @param buttonInfo The {@link VirtualKeyButton} for the button that was clicked.
+     * @param button The {@link Button} that was clicked.
+     * @return Return {@code true} if the client handled the feedback, otherwise {@code false} so
+     *     that {@link VirtualKeysView#performVirtualKeyButtonHapticFeedback(View, VirtualKeyButton,
+     *     Button)} can handle it depending on system settings.
+     */
+    boolean performVirtualKeyButtonHapticFeedback(
+        View view, VirtualKeyButton buttonInfo, Button button);
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/fragments/MainFragment.java b/app/src/main/java/com/sparkleseditor/fragments/MainFragment.java
index 58922fc..172a7dd 100644
--- a/app/src/main/java/com/sparkleseditor/fragments/MainFragment.java
+++ b/app/src/main/java/com/sparkleseditor/fragments/MainFragment.java
@@ -159,20 +159,6 @@ private void setupFileTree() {
     }
 
     private void slideXDrawer() {
-        /*int statusBarHeight =
-                getResources()
-                        .getDimensionPixelSize(
-                                getResources().getIdentifier("status_bar_height", "dimen", "android"));*/
-        int navigationBarHeight =
-                getResources()
-                        .getDimensionPixelSize(
-                                getResources().getIdentifier("navigation_bar_height", "dimen", "android"));
-        ViewGroup.LayoutParams layoutParams = binding.leftDrawerMenu.getLayoutParams();
-        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
-            ViewGroup.MarginLayoutParams marginLayoutParams = (ViewGroup.MarginLayoutParams) layoutParams;
-            binding.leftDrawerMenu.setLayoutParams(marginLayoutParams);
-        }
-
         binding.drawer.setScrimColor(Color.TRANSPARENT);
         binding.drawer.setDrawerElevation(0f);
         binding.drawer.addDrawerListener(new DrawerLayout.SimpleDrawerListener() {
@@ -243,6 +229,16 @@ private void setupToolbox() {
                     frgSettings
             );
         });
+        binding.term.setOnClickListener(
+                v->{
+                    Fragment frgTerm = new TerminalFragment();
+                    Navigator.pushTo(
+                            getParentFragmentManager(),
+                            R.id.nav_host,
+                            frgTerm
+                    );
+                }
+        );
     }
 
     @SuppressLint("NonConstantResourceId")
diff --git a/app/src/main/java/com/sparkleseditor/fragments/SettingsFragment.java b/app/src/main/java/com/sparkleseditor/fragments/SettingsFragment.java
index 00383ae..cc9a66c 100644
--- a/app/src/main/java/com/sparkleseditor/fragments/SettingsFragment.java
+++ b/app/src/main/java/com/sparkleseditor/fragments/SettingsFragment.java
@@ -5,14 +5,9 @@
 import android.view.View;
 import android.view.ViewGroup;
 
-import androidx.activity.OnBackPressedCallback;
 import androidx.annotation.NonNull;
-import androidx.fragment.app.Fragment;
 
-import com.sparkleseditor.R;
-import com.sparkleseditor.databinding.FragmentSecondBinding;
 import com.sparkleseditor.databinding.FragmentSettingsBinding;
-import com.sparkleseditor.navigation.Navigator;
 
 public class SettingsFragment extends BaseFragment {
 
diff --git a/app/src/main/java/com/sparkleseditor/fragments/SecondFragment.java b/app/src/main/java/com/sparkleseditor/fragments/TemplateFragment.java
similarity index 64%
rename from app/src/main/java/com/sparkleseditor/fragments/SecondFragment.java
rename to app/src/main/java/com/sparkleseditor/fragments/TemplateFragment.java
index ce66488..751ca7e 100644
--- a/app/src/main/java/com/sparkleseditor/fragments/SecondFragment.java
+++ b/app/src/main/java/com/sparkleseditor/fragments/TemplateFragment.java
@@ -6,15 +6,12 @@
 import android.view.ViewGroup;
 
 import androidx.annotation.NonNull;
-import androidx.fragment.app.Fragment;
-import androidx.navigation.fragment.NavHostFragment;
 
-import com.sparkleseditor.R;
-import com.sparkleseditor.databinding.FragmentSecondBinding;
+import com.sparkleseditor.databinding.FragmentTemplateBinding;
 
-public class SecondFragment extends BaseFragment {
+public class TemplateFragment extends BaseFragment {
 
-    private FragmentSecondBinding binding;
+    private FragmentTemplateBinding binding;
 
     @Override
     public View onCreateView(
@@ -22,7 +19,7 @@ public View onCreateView(
             Bundle savedInstanceState
     ) {
 
-        binding = FragmentSecondBinding.inflate(inflater, container, false);
+        binding = FragmentTemplateBinding.inflate(inflater, container, false);
         return binding.getRoot();
 
     }
diff --git a/app/src/main/java/com/sparkleseditor/fragments/TerminalFragment.java b/app/src/main/java/com/sparkleseditor/fragments/TerminalFragment.java
new file mode 100644
index 0000000..5912bd5
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/fragments/TerminalFragment.java
@@ -0,0 +1,138 @@
+package com.sparkleseditor.fragments;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+
+import androidx.annotation.NonNull;
+
+import com.blankj.utilcode.util.SizeUtils;
+import com.sparkleseditor.R;
+import com.sparkleseditor.components.virtualkeys.VirtualKeysConstants;
+import com.sparkleseditor.components.virtualkeys.VirtualKeysInfo;
+import com.sparkleseditor.databinding.FragmentTerminalBinding;
+import com.sparkleseditor.utils.TerminalBackEnd;
+import com.sparkleseditor.components.virtualkeys.VirtualKeysListener;
+import com.termux.terminal.TerminalEmulator;
+import com.termux.terminal.TerminalSession;
+import com.termux.view.TerminalView;
+import java.io.File;
+
+import org.json.JSONException;
+
+public class TerminalFragment extends BaseFragment {
+
+    public FragmentTerminalBinding binding;
+    private TerminalBackEnd backEnd;
+
+    private static final String VIRTUAL_KEYS = """
+    [
+        ["ESC", {"key":"/","popup":"\\\\"}, {"key":"-","popup":"|"}, "HOME", "UP", "END", "PGUP"],
+        ["TAB", "CTRL", "ALT", "LEFT", "DOWN", "RIGHT", "PGDN"]
+    ]
+    """.trim();
+    private TerminalView terminal;
+
+
+    @Override
+    public View onCreateView(
+            @NonNull LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState
+    ) {
+        binding = FragmentTerminalBinding.inflate(inflater, container, false);
+        backEnd = new TerminalBackEnd(new TerminalFragment());
+        setupTerminalView();
+        try {
+            setupVirtualKeys();
+        } catch (JSONException e) {
+            throw new RuntimeException(e);
+        }
+
+
+        return binding.getRoot();
+    }
+    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+    }
+
+    private void setupVirtualKeys() throws JSONException {
+
+        if (binding.extraKeysView == null) {
+            android.util.Log.e("TerminalFragment", "extraKeysView is null — check fragment_terminal.xml");
+            return;
+        }
+        binding.extraKeysView.setVirtualKeysViewClient(new VirtualKeysListener(terminal.mTermSession));
+        binding.extraKeysView.reload(new VirtualKeysInfo(VIRTUAL_KEYS, "", VirtualKeysConstants.CONTROL_CHARS_ALIASES));
+    }
+
+    private void setupTerminalView() {
+        setupToolbar();
+        terminal = new TerminalView(requireContext(), null);
+        backEnd.setTerminal(terminal);
+        terminal.setTerminalViewClient(backEnd);
+        TerminalSession session = createSession();
+        terminal.attachSession(session);
+        terminal.setKeepScreenOn(true);
+        terminal.requestFocus();
+        terminal.setTextSize(SizeUtils.dp2px(14f));
+        terminal.setFocusableInTouchMode(true);
+        LinearLayout.LayoutParams params =
+                new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 0);
+        params.weight = 1f;
+        binding.getRoot().addView(terminal, 1, params);
+
+    }
+
+    private void setupToolbar() {
+        com.google.android.material.appbar.MaterialToolbar toolbar = new com.google.android.material.appbar.MaterialToolbar(requireContext());
+        toolbar.setTitle("Terminal");
+        toolbar.setNavigationIcon(R.drawable.ic_arrow_back_ios_new_rounded_24);
+        toolbar.setNavigationOnClickListener(v -> {
+            getParentFragmentManager().popBackStack();
+        });
+
+        LinearLayout.LayoutParams toolbarParams = new LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                (int) (56 * getResources().getDisplayMetrics().density)
+        );
+        binding.getRoot().addView(toolbar, 0, toolbarParams);
+
+    }
+
+    private TerminalSession createSession() {
+
+        String[] env = {
+                "HOME=" + requireContext().getFilesDir().getAbsolutePath(),
+                "PUBLIC_HOME=" + requireContext().getExternalFilesDir(null).getAbsolutePath(),
+                "COLORTERM=truecolor",
+                "TERM=xterm-256color"
+        };
+
+        String shell = "/system/bin/sh";
+        String[] args = new String[] {};
+
+        return new TerminalSession(
+                shell,
+                requireContext().getFilesDir().getAbsolutePath(),
+                args,
+                env,
+                TerminalEmulator.DEFAULT_TERMINAL_TRANSCRIPT_ROWS,
+                backEnd);
+
+    }
+
+
+
+    @Override
+    public void onDestroyView() {
+        if (terminal != null && terminal.mTermSession != null) {
+            terminal.mTermSession.finishIfRunning();
+        }
+        super.onDestroyView();
+        binding = null;
+    }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/sparkleseditor/utils/FileUtil.java b/app/src/main/java/com/sparkleseditor/utils/FileUtil.java
new file mode 100755
index 0000000..3bdd544
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/utils/FileUtil.java
@@ -0,0 +1,599 @@
+package com.sparkleseditor.utils;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
+import android.graphics.LightingColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.media.ExifInterface;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.DocumentsContract;
+import android.provider.MediaStore;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.net.URLDecoder;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+
+public class FileUtil {
+
+  private static void createNewFile(String path) {
+    int lastSep = path.lastIndexOf(File.separator);
+    if (lastSep > 0) {
+      String dirPath = path.substring(0, lastSep);
+      makeDir(dirPath);
+    }
+
+    File file = new File(path);
+
+    try {
+      if (!file.exists()) file.createNewFile();
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static String readFile(String path) {
+    createNewFile(path);
+
+    StringBuilder sb = new StringBuilder();
+    FileReader fr = null;
+    try {
+      fr = new FileReader(new File(path));
+
+      char[] buff = new char[1024];
+      int length = 0;
+
+      while ((length = fr.read(buff)) > 0) {
+        sb.append(new String(buff, 0, length));
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      if (fr != null) {
+        try {
+          fr.close();
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+    }
+
+    return sb.toString();
+  }
+
+  public static void writeFile(String path, String str) {
+    createNewFile(path);
+    FileWriter fileWriter = null;
+
+    try {
+      fileWriter = new FileWriter(new File(path), false);
+      fileWriter.write(str);
+      fileWriter.flush();
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      try {
+        if (fileWriter != null) fileWriter.close();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  public static void copyFile(String sourcePath, String destPath) {
+    if (!isExistFile(sourcePath)) return;
+    createNewFile(destPath);
+
+    FileInputStream fis = null;
+    FileOutputStream fos = null;
+
+    try {
+      fis = new FileInputStream(sourcePath);
+      fos = new FileOutputStream(destPath, false);
+
+      byte[] buff = new byte[1024];
+      int length = 0;
+
+      while ((length = fis.read(buff)) > 0) {
+        fos.write(buff, 0, length);
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      if (fis != null) {
+        try {
+          fis.close();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
+      if (fos != null) {
+        try {
+          fos.close();
+        } catch (IOException e) {
+          e.printStackTrace();
+        }
+      }
+    }
+  }
+
+  public static void copyDir(String oldPath, String newPath) {
+    File oldFile = new File(oldPath);
+    File[] files = oldFile.listFiles();
+    File newFile = new File(newPath);
+    if (!newFile.exists()) {
+      newFile.mkdirs();
+    }
+    for (File file : files) {
+      if (file.isFile()) {
+        copyFile(file.getPath(), newPath + "/" + file.getName());
+      } else if (file.isDirectory()) {
+        copyDir(file.getPath(), newPath + "/" + file.getName());
+      }
+    }
+  }
+
+  public static void moveFile(String sourcePath, String destPath) {
+    copyFile(sourcePath, destPath);
+    deleteFile(sourcePath);
+  }
+
+  public static void deleteFile(String path) {
+    File file = new File(path);
+
+    if (!file.exists()) return;
+
+    if (file.isFile()) {
+      file.delete();
+      return;
+    }
+
+    File[] fileArr = file.listFiles();
+
+    if (fileArr != null) {
+      for (File subFile : fileArr) {
+        if (subFile.isDirectory()) {
+          deleteFile(subFile.getAbsolutePath());
+        }
+
+        if (subFile.isFile()) {
+          subFile.delete();
+        }
+      }
+    }
+
+    file.delete();
+  }
+
+  public static boolean isExistFile(String path) {
+    File file = new File(path);
+    return file.exists();
+  }
+
+  public static void makeDir(String path) {
+    if (!isExistFile(path)) {
+      File file = new File(path);
+      file.mkdirs();
+    }
+  }
+
+  public static void listDir(String path, ArrayList<String> list) {
+    File dir = new File(path);
+    if (!dir.exists() || dir.isFile()) return;
+
+    File[] listFiles = dir.listFiles();
+    if (listFiles == null || listFiles.length <= 0) return;
+
+    if (list == null) return;
+    list.clear();
+    for (File file : listFiles) {
+      list.add(file.getAbsolutePath());
+    }
+  }
+
+  public static boolean isDirectory(String path) {
+    if (!isExistFile(path)) return false;
+    return new File(path).isDirectory();
+  }
+
+  public static boolean isFile(String path) {
+    if (!isExistFile(path)) return false;
+    return new File(path).isFile();
+  }
+
+  public static long getFileLength(String path) {
+    if (!isExistFile(path)) return 0;
+    return new File(path).length();
+  }
+
+  public static String getExternalStorageDir() {
+    return Environment.getExternalStorageDirectory().getAbsolutePath();
+  }
+
+  public static String getPackageDataDir(Context context) {
+    return context.getExternalFilesDir(null).getAbsolutePath();
+  }
+
+  public static String getPublicDir(String type) {
+    return Environment.getExternalStoragePublicDirectory(type).getAbsolutePath();
+  }
+
+  public static String convertUriToFilePath(final Context context, final Uri uri) {
+    String path = null;
+    if (DocumentsContract.isDocumentUri(context, uri)) {
+      if (isExternalStorageDocument(uri)) {
+        final String docId = DocumentsContract.getDocumentId(uri);
+        final String[] split = docId.split(":");
+        final String type = split[0];
+
+        if ("primary".equalsIgnoreCase(type)) {
+          path = Environment.getExternalStorageDirectory() + "/" + split[1];
+        }
+      } else if (isDownloadsDocument(uri)) {
+        final String docId = DocumentsContract.getDocumentId(uri);
+        final String[] split = docId.split(":");
+        final String type = split[0];
+
+        if ("raw".equalsIgnoreCase(type)) {
+          return split[1];
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && "msf".equalsIgnoreCase(type)) {
+          final String selection = "_id=?";
+          final String[] selectionArgs = new String[] {split[1]};
+
+          path =
+              getDataColumn(
+                  context, MediaStore.Downloads.EXTERNAL_CONTENT_URI, selection, selectionArgs);
+        } else {
+
+          final Uri contentUri =
+              ContentUris.withAppendedId(
+                  Uri.parse("content://downloads/public_downloads"), Long.valueOf(docId));
+
+          path = getDataColumn(context, contentUri, null, null);
+        }
+      } else if (isMediaDocument(uri)) {
+        final String docId = DocumentsContract.getDocumentId(uri);
+        final String[] split = docId.split(":");
+        final String type = split[0];
+
+        Uri contentUri = null;
+        if ("image".equals(type)) {
+          contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+        } else if ("video".equals(type)) {
+          contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+        } else if ("audio".equals(type)) {
+          contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+        }
+
+        final String selection = "_id=?";
+        final String[] selectionArgs = new String[] {split[1]};
+
+        path = getDataColumn(context, contentUri, selection, selectionArgs);
+      }
+    } else if (ContentResolver.SCHEME_CONTENT.equalsIgnoreCase(uri.getScheme())) {
+      path = getDataColumn(context, uri, null, null);
+    } else if (ContentResolver.SCHEME_FILE.equalsIgnoreCase(uri.getScheme())) {
+      path = uri.getPath();
+    }
+
+    if (path != null) {
+      try {
+        return URLDecoder.decode(path, "UTF-8");
+      } catch (Exception e) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  private static String getDataColumn(
+      Context context, Uri uri, String selection, String[] selectionArgs) {
+    final String column = MediaStore.Images.Media.DATA;
+    final String[] projection = {column};
+
+    try (Cursor cursor =
+        context.getContentResolver().query(uri, projection, selection, selectionArgs, null)) {
+      if (cursor != null && cursor.moveToFirst()) {
+        final int column_index = cursor.getColumnIndexOrThrow(column);
+        return cursor.getString(column_index);
+      }
+    } catch (Exception e) {
+
+    }
+    return null;
+  }
+
+  private static boolean isExternalStorageDocument(Uri uri) {
+    return "com.android.externalstorage.documents".equals(uri.getAuthority());
+  }
+
+  private static boolean isDownloadsDocument(Uri uri) {
+    return "com.android.providers.downloads.documents".equals(uri.getAuthority());
+  }
+
+  private static boolean isMediaDocument(Uri uri) {
+    return "com.android.providers.media.documents".equals(uri.getAuthority());
+  }
+
+  private static void saveBitmap(Bitmap bitmap, String destPath) {
+    FileUtil.createNewFile(destPath);
+    try (FileOutputStream out = new FileOutputStream(new File(destPath))) {
+      bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  public static Bitmap getScaledBitmap(String path, int max) {
+    Bitmap src = BitmapFactory.decodeFile(path);
+
+    int width = src.getWidth();
+    int height = src.getHeight();
+    float rate = 0.0f;
+
+    if (width > height) {
+      rate = max / (float) width;
+      height = (int) (height * rate);
+      width = max;
+    } else {
+      rate = max / (float) height;
+      width = (int) (width * rate);
+      height = max;
+    }
+
+    return Bitmap.createScaledBitmap(src, width, height, true);
+  }
+
+  public static int calculateInSampleSize(
+      BitmapFactory.Options options, int reqWidth, int reqHeight) {
+    final int width = options.outWidth;
+    final int height = options.outHeight;
+    int inSampleSize = 1;
+
+    if (height > reqHeight || width > reqWidth) {
+      final int halfHeight = height / 2;
+      final int halfWidth = width / 2;
+
+      while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
+        inSampleSize *= 2;
+      }
+    }
+
+    return inSampleSize;
+  }
+
+  public static Bitmap decodeSampleBitmapFromPath(String path, int reqWidth, int reqHeight) {
+    final BitmapFactory.Options options = new BitmapFactory.Options();
+    options.inJustDecodeBounds = true;
+    BitmapFactory.decodeFile(path, options);
+
+    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
+
+    options.inJustDecodeBounds = false;
+    return BitmapFactory.decodeFile(path, options);
+  }
+
+  public static void resizeBitmapFileRetainRatio(String fromPath, String destPath, int max) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap bitmap = getScaledBitmap(fromPath, max);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void resizeBitmapFileToSquare(String fromPath, String destPath, int max) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Bitmap bitmap = Bitmap.createScaledBitmap(src, max, max, true);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void resizeBitmapFileToCircle(String fromPath, String destPath) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Bitmap bitmap = Bitmap.createBitmap(src.getWidth(), src.getHeight(), Bitmap.Config.ARGB_8888);
+    Canvas canvas = new Canvas(bitmap);
+
+    final int color = 0xff424242;
+    final Paint paint = new Paint();
+    final Rect rect = new Rect(0, 0, src.getWidth(), src.getHeight());
+
+    paint.setAntiAlias(true);
+    canvas.drawARGB(0, 0, 0, 0);
+    paint.setColor(color);
+    canvas.drawCircle(src.getWidth() / 2, src.getHeight() / 2, src.getWidth() / 2, paint);
+    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
+    canvas.drawBitmap(src, rect, rect, paint);
+
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void resizeBitmapFileWithRoundedBorder(
+      String fromPath, String destPath, int pixels) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Bitmap bitmap = Bitmap.createBitmap(src.getWidth(), src.getHeight(), Bitmap.Config.ARGB_8888);
+    Canvas canvas = new Canvas(bitmap);
+
+    final int color = 0xff424242;
+    final Paint paint = new Paint();
+    final Rect rect = new Rect(0, 0, src.getWidth(), src.getHeight());
+    final RectF rectF = new RectF(rect);
+    final float roundPx = pixels;
+
+    paint.setAntiAlias(true);
+    canvas.drawARGB(0, 0, 0, 0);
+    paint.setColor(color);
+    canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
+
+    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
+    canvas.drawBitmap(src, rect, rect, paint);
+
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void cropBitmapFileFromCenter(String fromPath, String destPath, int w, int h) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+
+    int width = src.getWidth();
+    int height = src.getHeight();
+
+    if (width < w && height < h) return;
+
+    int x = 0;
+    int y = 0;
+
+    if (width > w) x = (width - w) / 2;
+
+    if (height > h) y = (height - h) / 2;
+
+    int cw = w;
+    int ch = h;
+
+    if (w > width) cw = width;
+
+    if (h > height) ch = height;
+
+    Bitmap bitmap = Bitmap.createBitmap(src, x, y, cw, ch);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void rotateBitmapFile(String fromPath, String destPath, float angle) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Matrix matrix = new Matrix();
+    matrix.postRotate(angle);
+    Bitmap bitmap = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void scaleBitmapFile(String fromPath, String destPath, float x, float y) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Matrix matrix = new Matrix();
+    matrix.postScale(x, y);
+
+    int w = src.getWidth();
+    int h = src.getHeight();
+
+    Bitmap bitmap = Bitmap.createBitmap(src, 0, 0, w, h, matrix, true);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void skewBitmapFile(String fromPath, String destPath, float x, float y) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Matrix matrix = new Matrix();
+    matrix.postSkew(x, y);
+
+    int w = src.getWidth();
+    int h = src.getHeight();
+
+    Bitmap bitmap = Bitmap.createBitmap(src, 0, 0, w, h, matrix, true);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void setBitmapFileColorFilter(String fromPath, String destPath, int color) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    Bitmap bitmap = Bitmap.createBitmap(src, 0, 0, src.getWidth() - 1, src.getHeight() - 1);
+    Paint p = new Paint();
+    ColorFilter filter = new LightingColorFilter(color, 1);
+    p.setColorFilter(filter);
+    Canvas canvas = new Canvas(bitmap);
+    canvas.drawBitmap(bitmap, 0, 0, p);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void setBitmapFileBrightness(String fromPath, String destPath, float brightness) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    ColorMatrix cm =
+        new ColorMatrix(
+            new float[] {
+              1, 0, 0, 0, brightness,
+              0, 1, 0, 0, brightness,
+              0, 0, 1, 0, brightness,
+              0, 0, 0, 1, 0
+            });
+
+    Bitmap bitmap = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
+    Canvas canvas = new Canvas(bitmap);
+    Paint paint = new Paint();
+    paint.setColorFilter(new ColorMatrixColorFilter(cm));
+    canvas.drawBitmap(src, 0, 0, paint);
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static void setBitmapFileContrast(String fromPath, String destPath, float contrast) {
+    if (!isExistFile(fromPath)) return;
+    Bitmap src = BitmapFactory.decodeFile(fromPath);
+    ColorMatrix cm =
+        new ColorMatrix(
+            new float[] {
+              contrast, 0, 0, 0, 0, 0, contrast, 0, 0, 0, 0, 0, contrast, 0, 0, 0, 0, 0, 1, 0
+            });
+
+    Bitmap bitmap = Bitmap.createBitmap(src.getWidth(), src.getHeight(), src.getConfig());
+    Canvas canvas = new Canvas(bitmap);
+    Paint paint = new Paint();
+    paint.setColorFilter(new ColorMatrixColorFilter(cm));
+    canvas.drawBitmap(src, 0, 0, paint);
+
+    saveBitmap(bitmap, destPath);
+  }
+
+  public static int getJpegRotate(String filePath) {
+    int rotate = 0;
+    try {
+      ExifInterface exif = new ExifInterface(filePath);
+      int iOrientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
+
+      switch (iOrientation) {
+        case ExifInterface.ORIENTATION_ROTATE_90:
+          rotate = 90;
+          break;
+
+        case ExifInterface.ORIENTATION_ROTATE_180:
+          rotate = 180;
+          break;
+
+        case ExifInterface.ORIENTATION_ROTATE_270:
+          rotate = 270;
+          break;
+      }
+    } catch (IOException e) {
+      return 0;
+    }
+
+    return rotate;
+  }
+
+  public static File createNewPictureFile(Context context) {
+    SimpleDateFormat date = new SimpleDateFormat("yyyyMMdd_HHmmss");
+    String fileName = date.format(new Date()) + ".jpg";
+    return new File(
+        context.getExternalFilesDir(Environment.DIRECTORY_DCIM).getAbsolutePath()
+            + File.separator
+            + fileName);
+  }
+}
diff --git a/app/src/main/java/com/sparkleseditor/utils/TerminalBackEnd.java b/app/src/main/java/com/sparkleseditor/utils/TerminalBackEnd.java
new file mode 100644
index 0000000..2b9bea3
--- /dev/null
+++ b/app/src/main/java/com/sparkleseditor/utils/TerminalBackEnd.java
@@ -0,0 +1,241 @@
+package com.sparkleseditor.utils;
+
+import static com.blankj.utilcode.util.KeyboardUtils.showSoftInput;
+
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+
+import androidx.fragment.app.Fragment;
+
+import com.blankj.utilcode.util.ClipboardUtils;
+import com.blankj.utilcode.util.KeyboardUtils;
+import com.blankj.utilcode.util.SizeUtils;
+import com.sparkleseditor.components.virtualkeys.VirtualKeysView;
+import com.sparkleseditor.databinding.FragmentTerminalBinding;
+import com.sparkleseditor.fragments.TerminalFragment;
+import com.sparkleseditor.components.virtualkeys.SpecialButton;
+import com.termux.terminal.TerminalEmulator;
+import com.termux.terminal.TerminalSession;
+import com.termux.terminal.TerminalSessionClient;
+import com.termux.view.TerminalView;
+import com.termux.view.TerminalViewClient;
+
+public class TerminalBackEnd implements TerminalViewClient, TerminalSessionClient {
+
+  private int fontSize = SizeUtils.dp2px(24f);
+  private TerminalView terminal;
+  private final TerminalFragment fragment;
+
+  private VirtualKeysView extraKeysView;
+
+  public void setExtraKeysView(VirtualKeysView view) {
+    this.extraKeysView = view;
+  }
+
+  public TerminalBackEnd(Fragment fragment) {
+      this.fragment = new TerminalFragment();
+  }
+
+  public void setTerminal(TerminalView terminalView) {
+    this.terminal = terminalView;
+  }
+
+  @Override
+  public void onTextChanged(TerminalSession changedSession) {
+    terminal.onScreenUpdated();
+  }
+
+  @Override
+  public void onTitleChanged(TerminalSession changedSession) {}
+
+  @Override
+  public void onSessionFinished(TerminalSession finishedSession) {}
+
+  @Override
+  public void onCopyTextToClipboard(TerminalSession session, String text) {
+    ClipboardUtils.copyText("Terminal", text);
+  }
+
+  @Override
+  public void onPasteTextFromClipboard(TerminalSession session) {
+    String clip = ClipboardUtils.getText().toString();
+    if (!clip.trim().isEmpty() && terminal.mEmulator != null) {
+      terminal.mEmulator.paste(clip);
+    }
+  }
+
+  @Override
+  public void onBell(TerminalSession session) {}
+
+  @Override
+  public void onColorsChanged(TerminalSession session) {}
+
+  @Override
+  public void onTerminalCursorStateChange(boolean state) {}
+
+  @Override
+  public Integer getTerminalCursorStyle() {
+    return TerminalEmulator.DEFAULT_TERMINAL_CURSOR_STYLE;
+  }
+
+  @Override
+  public void logError(String tag, String message) {
+    Log.e(tag, message);
+  }
+
+  @Override
+  public void logWarn(String tag, String message) {
+    Log.w(tag, message);
+  }
+
+  @Override
+  public void logInfo(String tag, String message) {
+    Log.i(tag, message);
+  }
+
+  @Override
+  public void logDebug(String tag, String message) {
+    Log.d(tag, message);
+  }
+
+  @Override
+  public void logVerbose(String tag, String message) {
+    Log.v(tag, message);
+  }
+
+  @Override
+  public void logStackTraceWithMessage(String tag, String message, Exception e) {
+    Log.e(tag, message);
+    if (e != null) {
+      e.printStackTrace();
+    }
+  }
+
+  @Override
+  public void logStackTrace(String tag, Exception e) {
+    if (e != null) {
+      e.printStackTrace();
+    }
+  }
+
+  @Override
+  public float onScale(float scale) {
+    return fontSize;
+  }
+
+  @Override
+  public void onSingleTapUp(MotionEvent e) {
+    showSoftInput();
+  }
+
+  @Override
+  public boolean shouldBackButtonBeMappedToEscape() {
+    return false;
+  }
+
+  @Override
+  public boolean shouldEnforceCharBasedInput() {
+    return true;
+  }
+
+  @Override
+  public boolean shouldUseCtrlSpaceWorkaround() {
+    return false;
+  }
+
+  @Override
+  public boolean isTerminalViewSelected() {
+    return true;
+  }
+
+  @Override
+  public void copyModeChanged(boolean copyMode) {}
+
+  @Override
+  public boolean onKeyDown(int keyCode, KeyEvent e, TerminalSession session) {
+    if (extraKeysView == null) {
+      return false ;
+    }
+    if (keyCode == KeyEvent.KEYCODE_ENTER && !session.isRunning()) {
+      fragment.requireActivity().finish();
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public boolean onKeyUp(int keyCode, KeyEvent e) {
+    return false;
+  }
+
+  @Override
+  public boolean onLongPress(MotionEvent event) {
+    return false;
+  }
+
+  @Override
+  public boolean readControlKey() {
+
+    if (extraKeysView == null) {
+      return false ;
+    }
+
+
+    Boolean state = fragment.binding.extraKeysView.readSpecialButton(SpecialButton.CTRL, true);
+    return state != null && state;
+  }
+
+  @Override
+  public boolean readAltKey() {
+
+    if (extraKeysView == null) {
+      return false ;
+    }
+
+    Boolean state = fragment.binding.extraKeysView.readSpecialButton(SpecialButton.ALT, true);
+    return state != null && state;
+  }
+
+  @Override
+  public boolean readShiftKey() {
+    if (extraKeysView == null) {
+      return false ;
+    }
+
+    Boolean state = fragment.binding.extraKeysView.readSpecialButton(SpecialButton.SHIFT, true);
+    return state != null && state;
+  }
+
+  @Override
+  public boolean readFnKey() {
+
+    if (extraKeysView == null) {
+      return false ;
+    }
+
+    Boolean state = fragment.binding.extraKeysView.readSpecialButton(SpecialButton.FN, true);
+    return state != null && state;
+  }
+
+  @Override
+  public boolean onCodePoint(int codePoint, boolean ctrlDown, TerminalSession session) {
+    return false;
+  }
+
+  @Override
+  public void onEmulatorSet() {
+    setTerminalCursorBlinkingState(true);
+  }
+
+  private void setTerminalCursorBlinkingState(boolean start) {
+    if (terminal.mEmulator != null) {
+      terminal.setTerminalCursorBlinkerState(start, true);
+    }
+  }
+
+  private void showSoftInput() {
+    terminal.requestFocus();
+    KeyboardUtils.showSoftInput(terminal);
+  }
+}
diff --git a/app/src/main/res/layout-v26/fragment_terminal.xml b/app/src/main/res/layout-v26/fragment_terminal.xml
new file mode 100644
index 0000000..40fbbba
--- /dev/null
+++ b/app/src/main/res/layout-v26/fragment_terminal.xml
@@ -0,0 +1,19 @@
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.sparkleseditor.components.virtualkeys.VirtualKeysView
+        android:id="@+id/extra_keys_view"
+        style="?android:attr/buttonBarStyle"
+        android:layout_width="match_parent"
+        android:focusable="false"
+        android:clickable="false"
+        android:focusedByDefault="false"
+        android:longClickable="false"
+        android:layout_height="75dp"
+        android:fitsSystemWindows="false"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/layout/fragment_second.xml b/app/src/main/res/layout/fragment_template.xml
similarity index 96%
rename from app/src/main/res/layout/fragment_second.xml
rename to app/src/main/res/layout/fragment_template.xml
index 6ea56a5..2c1145b 100644
--- a/app/src/main/res/layout/fragment_second.xml
+++ b/app/src/main/res/layout/fragment_template.xml
@@ -4,7 +4,7 @@
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
-    tools:context=".fragments.SecondFragment">
+    tools:context=".fragments.TemplateFragment">
 
     <androidx.constraintlayout.widget.ConstraintLayout
         android:layout_width="match_parent"
diff --git a/app/src/main/res/layout/fragment_terminal.xml b/app/src/main/res/layout/fragment_terminal.xml
new file mode 100644
index 0000000..40fbbba
--- /dev/null
+++ b/app/src/main/res/layout/fragment_terminal.xml
@@ -0,0 +1,19 @@
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.sparkleseditor.components.virtualkeys.VirtualKeysView
+        android:id="@+id/extra_keys_view"
+        style="?android:attr/buttonBarStyle"
+        android:layout_width="match_parent"
+        android:focusable="false"
+        android:clickable="false"
+        android:focusedByDefault="false"
+        android:longClickable="false"
+        android:layout_height="75dp"
+        android:fitsSystemWindows="false"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 67341d3..3c32a16 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -13,7 +13,10 @@ material = "1.14.0-alpha09"
 constraintlayout = "2.2.1"
 navigationFragment = "2.9.7"
 navigationUi = "2.9.7"
+terminalEmulator = "0.118.1"
+terminalView = "0.118.1"
 transition = "1.7.0"
+utilcodex = "1.31.1"
 
 [libraries]
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
@@ -32,7 +35,10 @@ material = { group = "com.google.android.material", name = "material", version.r
 constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }
 navigation-fragment = { group = "androidx.navigation", name = "navigation-fragment", version.ref = "navigationFragment" }
 navigation-ui = { group = "androidx.navigation", name = "navigation-ui", version.ref = "navigationUi" }
+terminal-emulator = { module = "com.github.termux.termux-app:terminal-emulator", version.ref = "terminalEmulator" }
+terminal-view = { module = "com.github.termux.termux-app:terminal-view", version.ref = "terminalView" }
 transition = { module = "androidx.transition:transition", version.ref = "transition" }
+utilcodex = { module = "com.blankj:utilcodex", version.ref = "utilcodex" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index e14975d..e60d8ea 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -8,7 +8,8 @@ pluginManagement {
             }
         }
         mavenCentral()
-        gradlePluginPortal()
+        maven { url = uri("https://jitpack.io/")}
+            gradlePluginPortal()
     }
 }
 dependencyResolutionManagement {
@@ -16,9 +17,11 @@ dependencyResolutionManagement {
     repositories {
         google()
         mavenCentral()
+        maven { url = uri("https://jitpack.io/")}
+
     }
 }
 
 rootProject.name = "Sparkles Editor"
 include(":app")
-include(":filetree")
+include(":filetree")
\ No newline at end of file